diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3890b0e --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +node_modules +dist/ +.idea +.vscode \ No newline at end of file diff --git a/Readme.md b/Readme.md new file mode 100644 index 0000000..2bc3f7e --- /dev/null +++ b/Readme.md @@ -0,0 +1 @@ +grpc_web_proto_compile --clear_output_dir --verbosity=1 --js_out_options="import_style=commonjs,binary" --grpc_web_out_options="import_style=commonjs+dts,mode=grpcweb" ./proto ./src/grpc-web \ No newline at end of file diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..27122ff --- /dev/null +++ b/package-lock.json @@ -0,0 +1,568 @@ +{ + "name": "grpc-web", + "version": "1.0.0", + "lockfileVersion": 2, + "requires": true, + "packages": { + "": { + "name": "grpc-web", + "version": "1.0.0", + "license": "ISC", + "dependencies": { + "google-protobuf": "^3.21.0", + "grpc-web": "1.2.1" + }, + "devDependencies": { + "@types/node": "^18.7.18", + "protobufjs": "^7.1.1", + "ts-node": "^10.9.1", + "xhr2": "^0.2.1" + } + }, + "node_modules/@cspotcode/source-map-support": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz", + "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==", + "dev": true, + "dependencies": { + "@jridgewell/trace-mapping": "0.3.9" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz", + "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==", + "dev": true, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.14", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz", + "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==", + "dev": true + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.9", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz", + "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==", + "dev": true, + "dependencies": { + "@jridgewell/resolve-uri": "^3.0.3", + "@jridgewell/sourcemap-codec": "^1.4.10" + } + }, + "node_modules/@protobufjs/aspromise": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz", + "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==", + "dev": true + }, + "node_modules/@protobufjs/base64": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz", + "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==", + "dev": true + }, + "node_modules/@protobufjs/codegen": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz", + "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==", + "dev": true + }, + "node_modules/@protobufjs/eventemitter": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz", + "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==", + "dev": true + }, + "node_modules/@protobufjs/fetch": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz", + "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==", + "dev": true, + "dependencies": { + "@protobufjs/aspromise": "^1.1.1", + "@protobufjs/inquire": "^1.1.0" + } + }, + "node_modules/@protobufjs/float": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz", + "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==", + "dev": true + }, + "node_modules/@protobufjs/inquire": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz", + "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==", + "dev": true + }, + "node_modules/@protobufjs/path": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz", + "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==", + "dev": true + }, + "node_modules/@protobufjs/pool": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz", + "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==", + "dev": true + }, + "node_modules/@protobufjs/utf8": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz", + "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==", + "dev": true + }, + "node_modules/@tsconfig/node10": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz", + "integrity": "sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==", + "dev": true + }, + "node_modules/@tsconfig/node12": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz", + "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==", + "dev": true + }, + "node_modules/@tsconfig/node14": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz", + "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==", + "dev": true + }, + "node_modules/@tsconfig/node16": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz", + "integrity": "sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==", + "dev": true + }, + "node_modules/@types/node": { + "version": "18.7.18", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.18.tgz", + "integrity": "sha512-m+6nTEOadJZuTPkKR/SYK3A2d7FZrgElol9UP1Kae90VVU4a6mxnPuLiIW1m4Cq4gZ/nWb9GrdVXJCoCazDAbg==", + "dev": true + }, + "node_modules/acorn": { + "version": "8.8.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.0.tgz", + "integrity": "sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==", + "dev": true, + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-walk": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz", + "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==", + "dev": true, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/arg": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", + "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==", + "dev": true + }, + "node_modules/create-require": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz", + "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==", + "dev": true + }, + "node_modules/diff": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz", + "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==", + "dev": true, + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/google-protobuf": { + "version": "3.21.0", + "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.21.0.tgz", + "integrity": "sha512-byR7MBTK4tZ5PZEb+u5ZTzpt4SfrTxv5682MjPlHN16XeqgZE2/8HOIWeiXe8JKnT9OVbtBGhbq8mtvkK8cd5g==" + }, + "node_modules/grpc-web": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/grpc-web/-/grpc-web-1.2.1.tgz", + "integrity": "sha512-ibBaJPzfMVuLPgaST9w0kZl60s+SnkPBQp6QKdpEr85tpc1gXW2QDqSne9xiyiym0logDfdUSm4aX5h9YBA2mw==" + }, + "node_modules/long": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/long/-/long-5.2.0.tgz", + "integrity": "sha512-9RTUNjK60eJbx3uz+TEGF7fUr29ZDxR5QzXcyDpeSfeH28S9ycINflOgOlppit5U+4kNTe83KQnMEerw7GmE8w==", + "dev": true + }, + "node_modules/make-error": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", + "dev": true + }, + "node_modules/protobufjs": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.1.1.tgz", + "integrity": "sha512-d0nMQqS/aT3lfV8bKi9Gbg73vPd2LcDdTDOu6RE/M+h9DY8g1EmDzk3ADPccthEWfTBjkR2oxNdx9Gs8YubT+g==", + "dev": true, + "hasInstallScript": true, + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/ts-node": { + "version": "10.9.1", + "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz", + "integrity": "sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==", + "dev": true, + "dependencies": { + "@cspotcode/source-map-support": "^0.8.0", + "@tsconfig/node10": "^1.0.7", + "@tsconfig/node12": "^1.0.7", + "@tsconfig/node14": "^1.0.0", + "@tsconfig/node16": "^1.0.2", + "acorn": "^8.4.1", + "acorn-walk": "^8.1.1", + "arg": "^4.1.0", + "create-require": "^1.1.0", + "diff": "^4.0.1", + "make-error": "^1.1.1", + "v8-compile-cache-lib": "^3.0.1", + "yn": "3.1.1" + }, + "bin": { + "ts-node": "dist/bin.js", + "ts-node-cwd": "dist/bin-cwd.js", + "ts-node-esm": "dist/bin-esm.js", + "ts-node-script": "dist/bin-script.js", + "ts-node-transpile-only": "dist/bin-transpile.js", + "ts-script": "dist/bin-script-deprecated.js" + }, + "peerDependencies": { + "@swc/core": ">=1.2.50", + "@swc/wasm": ">=1.2.50", + "@types/node": "*", + "typescript": ">=2.7" + }, + "peerDependenciesMeta": { + "@swc/core": { + "optional": true + }, + "@swc/wasm": { + "optional": true + } + } + }, + "node_modules/typescript": { + "version": "4.8.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.8.3.tgz", + "integrity": "sha512-goMHfm00nWPa8UvR/CPSvykqf6dVV8x/dp0c5mFTMTIu0u0FlGWRioyy7Nn0PGAdHxpJZnuO/ut+PpQ8UiHAig==", + "dev": true, + "peer": true, + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/v8-compile-cache-lib": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz", + "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==", + "dev": true + }, + "node_modules/xhr2": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/xhr2/-/xhr2-0.2.1.tgz", + "integrity": "sha512-sID0rrVCqkVNUn8t6xuv9+6FViXjUVXq8H5rWOH2rz9fDNQEd4g0EA2XlcEdJXRz5BMEn4O1pJFdT+z4YHhoWw==", + "dev": true, + "engines": { + "node": ">= 6" + } + }, + "node_modules/yn": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz", + "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==", + "dev": true, + "engines": { + "node": ">=6" + } + } + }, + "dependencies": { + "@cspotcode/source-map-support": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz", + "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==", + "dev": true, + "requires": { + "@jridgewell/trace-mapping": "0.3.9" + } + }, + "@jridgewell/resolve-uri": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz", + "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==", + "dev": true + }, + "@jridgewell/sourcemap-codec": { + "version": "1.4.14", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz", + "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==", + "dev": true + }, + "@jridgewell/trace-mapping": { + "version": "0.3.9", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz", + "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==", + "dev": true, + "requires": { + "@jridgewell/resolve-uri": "^3.0.3", + "@jridgewell/sourcemap-codec": "^1.4.10" + } + }, + "@protobufjs/aspromise": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz", + "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==", + "dev": true + }, + "@protobufjs/base64": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz", + "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==", + "dev": true + }, + "@protobufjs/codegen": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz", + "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==", + "dev": true + }, + "@protobufjs/eventemitter": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz", + "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==", + "dev": true + }, + "@protobufjs/fetch": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz", + "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==", + "dev": true, + "requires": { + "@protobufjs/aspromise": "^1.1.1", + "@protobufjs/inquire": "^1.1.0" + } + }, + "@protobufjs/float": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz", + "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==", + "dev": true + }, + "@protobufjs/inquire": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz", + "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==", + "dev": true + }, + "@protobufjs/path": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz", + "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==", + "dev": true + }, + "@protobufjs/pool": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz", + "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==", + "dev": true + }, + "@protobufjs/utf8": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz", + "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==", + "dev": true + }, + "@tsconfig/node10": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz", + "integrity": "sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==", + "dev": true + }, + "@tsconfig/node12": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz", + "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==", + "dev": true + }, + "@tsconfig/node14": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz", + "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==", + "dev": true + }, + "@tsconfig/node16": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz", + "integrity": "sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==", + "dev": true + }, + "@types/node": { + "version": "18.7.18", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.18.tgz", + "integrity": "sha512-m+6nTEOadJZuTPkKR/SYK3A2d7FZrgElol9UP1Kae90VVU4a6mxnPuLiIW1m4Cq4gZ/nWb9GrdVXJCoCazDAbg==", + "dev": true + }, + "acorn": { + "version": "8.8.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.0.tgz", + "integrity": "sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==", + "dev": true + }, + "acorn-walk": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz", + "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==", + "dev": true + }, + "arg": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", + "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==", + "dev": true + }, + "create-require": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz", + "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==", + "dev": true + }, + "diff": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz", + "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==", + "dev": true + }, + "google-protobuf": { + "version": "3.21.0", + "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.21.0.tgz", + "integrity": "sha512-byR7MBTK4tZ5PZEb+u5ZTzpt4SfrTxv5682MjPlHN16XeqgZE2/8HOIWeiXe8JKnT9OVbtBGhbq8mtvkK8cd5g==" + }, + "grpc-web": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/grpc-web/-/grpc-web-1.2.1.tgz", + "integrity": "sha512-ibBaJPzfMVuLPgaST9w0kZl60s+SnkPBQp6QKdpEr85tpc1gXW2QDqSne9xiyiym0logDfdUSm4aX5h9YBA2mw==" + }, + "long": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/long/-/long-5.2.0.tgz", + "integrity": "sha512-9RTUNjK60eJbx3uz+TEGF7fUr29ZDxR5QzXcyDpeSfeH28S9ycINflOgOlppit5U+4kNTe83KQnMEerw7GmE8w==", + "dev": true + }, + "make-error": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", + "dev": true + }, + "protobufjs": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.1.1.tgz", + "integrity": "sha512-d0nMQqS/aT3lfV8bKi9Gbg73vPd2LcDdTDOu6RE/M+h9DY8g1EmDzk3ADPccthEWfTBjkR2oxNdx9Gs8YubT+g==", + "dev": true, + "requires": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + } + }, + "ts-node": { + "version": "10.9.1", + "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz", + "integrity": "sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==", + "dev": true, + "requires": { + "@cspotcode/source-map-support": "^0.8.0", + "@tsconfig/node10": "^1.0.7", + "@tsconfig/node12": "^1.0.7", + "@tsconfig/node14": "^1.0.0", + "@tsconfig/node16": "^1.0.2", + "acorn": "^8.4.1", + "acorn-walk": "^8.1.1", + "arg": "^4.1.0", + "create-require": "^1.1.0", + "diff": "^4.0.1", + "make-error": "^1.1.1", + "v8-compile-cache-lib": "^3.0.1", + "yn": "3.1.1" + } + }, + "typescript": { + "version": "4.8.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.8.3.tgz", + "integrity": "sha512-goMHfm00nWPa8UvR/CPSvykqf6dVV8x/dp0c5mFTMTIu0u0FlGWRioyy7Nn0PGAdHxpJZnuO/ut+PpQ8UiHAig==", + "dev": true, + "peer": true + }, + "v8-compile-cache-lib": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz", + "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==", + "dev": true + }, + "xhr2": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/xhr2/-/xhr2-0.2.1.tgz", + "integrity": "sha512-sID0rrVCqkVNUn8t6xuv9+6FViXjUVXq8H5rWOH2rz9fDNQEd4g0EA2XlcEdJXRz5BMEn4O1pJFdT+z4YHhoWw==", + "dev": true + }, + "yn": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz", + "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==", + "dev": true + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..3d308f8 --- /dev/null +++ b/package.json @@ -0,0 +1,29 @@ +{ + "name": "grpc-web", + "version": "1.0.0", + "description": "", + "main": "src/index.js", + "types": "src/index.d.ts", + "scripts": { + "test": "ts-node src/index.ts" + }, + "author": "", + "license": "ISC", + "dependencies": { + "google-protobuf": "^3.21.0", + "grpc-web": "1.2.1" + }, + "devDependencies": { + "@types/node": "^18.7.18", + "ts-node": "^10.9.1", + "xhr2": "^0.2.1", + "protobufjs": "^7.1.1" + }, + "files": [ + "index.js", + "index.d.ts", + "package-lock.json", + "tsconfig.json", + "src/**" + ] +} diff --git a/proto/authentication.proto b/proto/authentication.proto new file mode 100644 index 0000000..b034af4 --- /dev/null +++ b/proto/authentication.proto @@ -0,0 +1,74 @@ +syntax = "proto3"; + +package web.authentication; + +service ClientAuthentication { + rpc viaAuthCode (AuthRequest) returns (AuthResponse) {} + rpc logout (Empty) returns (Empty) {} +} + +message PlayerInfo { + int64 nucleusId = 1; + int64 personaId = 2; + int32 platformId = 3; +} + +enum Platform { + UNKNOWN = 0; + PC = 1; + PS4 = 2; + XBOXONE = 3; + PS5 = 4; + XBSX = 5; + COMMON = 6; +} + +enum Reason { + NONE = 0; + PLAYER = 1; + SYNC = 2; +} + +message AuthRequest { + string authCode = 1; + string redirectUri = 2; + string product = 3; + string firstPartyId = 4; + Platform platform = 5; +} + +message Duration { + int64 seconds = 1; + int32 nanos = 2; +} + +message TimeTravel { + Duration offset = 1; +} + +message ProtocolVersionOverride { + string original = 1; + string overridden = 2; + Reason reason = 3; +} + +enum UserBits { + USER_BIT_UNSPECIFIED = 0; + USER_BIT_ACCEPTED_TOS = 1; + USER_BIT_ENABLE_USERSHARING = 2; + USER_BIT_ENABLE_CRASHREPORTS = 3; + USER_BIT_COMPLETED_TUTORIAL = 4; + USER_BIT_CLIENT_ENABLE_USAGESHARING = 5; +} + +message Empty { +} + +message AuthResponse { + string sessionId = 1; + PlayerInfo player = 3; + repeated UserBits userBits = 4; + TimeTravel timeTravel = 5; + ProtocolVersionOverride protocolVersionOverride = 6; +} + diff --git a/proto/communitygames.proto b/proto/communitygames.proto new file mode 100644 index 0000000..39e5cab --- /dev/null +++ b/proto/communitygames.proto @@ -0,0 +1,534 @@ +syntax = "proto3"; + +package web.communitygames; + +service CommunityGames { + rpc createPlayground (CreatePlaygroundRequest) returns (CreatePlaygroundResponse) {} // current + rpc updatePlayground (UpdatePlaygroundRequest) returns (UpdatePlaygroundResponse) {} // current + rpc deletePlayground (DeletePlaygroundRequest) returns (DeletePlaygroundResponse) {} // current + rpc getPlayground (GetPlaygroundRequest) returns (PlaygroundInfoResponse) {} // current + rpc listPlaygroundsByOwner (ListPlaygroundsByOwnerRequest) returns (ListPlaygroundsByOwnerResponse) {} // current + rpc getBlueprintsById (GetBlueprintsByIdRequest) returns (GetBlueprintsByIdResponse) {} + rpc getScheduledBlueprints (GetScheduledBlueprintsRequest) returns (GetScheduledBlueprintsResponse) {} // current + rpc getConstraints (GetConstraintsRequest) returns (GetConstraintsResponse) {} // current + rpc sharePlayground (SharePlaygroundRequest) returns (SharePlaygroundResponse) {} // current + rpc getProgressionTypes (GetProgressionTypesRequest) returns (GetProgressionTypesResponse) {} // current +} + +enum Platform { + UNKNOWN = 0; + PC = 1; + PS4 = 2; + XBOXONE = 3; + PS5 = 4; + XBSX = 5; + COMMON = 6; +} + +enum InputMethods { + ALL = 0; + KEYBOARD_MOUSE = 1; + GAME_CONTROLLER = 3; +} + +enum IncludeFields { + AVAILABLE_GAME_DATA = 0; + METADATA = 1; + CUSTOM_DATA = 2; + CONSTRAINTS = 3; + AVAILABLE_TAGS = 4; +} + +enum State { + ACTIVE = 0; + ARCHIVED = 1; +} + +enum Category { + CATEGORY_UNKNOWN = 0; + CATEGORY_MODE = 1; + CATEGORY_PACKAGE = 2; + CATEGORY_GENERAL = 3; +} + +enum PhantomGameState { + ENABLED = 0; + DISABLED = 1; +} + +enum CapacityType { + AI_BACKFILL = 0; + AI_STATIC = 1; +} + +enum RotationBehavior { + LOOP = 0; + MATCHMAKE = 1; + ONE_MAP = 2; +} + +enum RoundBehavior { + CONTINUE = 0; +} + +enum BalancingMethod { + UNSPECIFIED = 0; + EVEN_NUMBERS = 1; + EVEN_PERCENTAGE = 2; + FILL_IN_TEAM_ORDER = 3; +} + +message ProgressionEntry { + string progressionMode = 1; + repeated Mutator progressibles = 2; +} + +message TranslationMetadata { + string kind = 1; + string translationId = 2; +} + +message ResourceLocation { + string ref = 1; + string url = 2; +} + +message Resource { + ResourceLocation location = 1; + string kind = 2; +} + +message Metadata { + repeated TranslationMetadata translations = 1; + repeated Resource resources = 2; +} + +message Tag { + string id = 1; + int32 sortOrder = 2; + Metadata metadata = 3; +} + +message ProgressionMode { + string value = 1; +} + +message PlaygroundResponse { + Playground originalPlayground = 1; + Playground validatedPlayground = 2; + repeated Tag tag = 3; + ProgressionMode progressionMode = 4; +} + +message MapInfo { + string mapname = 1; + string mode = 2; + uint32 gameSize = 3; + uint32 rounds = 4; + Mutator mutators = 5; + string location = 6; + uint32 preRoundSize = 7; + uint32 warmUpSize = 8; + uint32 allowedSpectators = 9; +} + +message MapRotation { + repeated MapInfo maps = 1; + RotationBehavior rotationBehavior = 2; + RoundBehavior roundBehavior = 3; +} + +message TeamStructure { + int32 teamId = 1; + int32 capacity = 2; +} + +message InternalTeamStructure { + int32 teamId = 1; + int32 capacity = 2; + CapacityType capacityType = 3; +} + +message MutatorSparseFloatEntry { + uint32 index = 1; + float value = 2; +} + +message MutatorSparseFloat { + float defaultValue = 1; + uint32 size = 2; + repeated MutatorSparseFloatEntry sparseValues = 3; +} + +message MutatorFloat { + float value = 1; +} + +message MutatorBoolean { + bool boolValue = 1; +} + +message MutatorString { + string stringValue = 1; +} + +message MutatorInt { + int32 value = 1; +} + +message MutatorSparseBooleanEntry { + uint32 index = 1; + bool value = 2; +} + +message MutatorSparseBoolean { + bool defaultValue = 1; + uint32 size = 2; + repeated MutatorSparseBooleanEntry sparseValues = 3; +} + +message SparseIntEntity { + repeated int32 values = 1; +} + +message MutatorSparseIntEntry { + uint32 index = 1; + int32 value = 2; +} + +message MutatorSparseInt { + int32 defaultValue = 1; + uint32 size = 2; + MutatorSparseIntEntry sparseValues = 3; +} + +message MutatorKind { + MutatorBoolean mutatorBoolean = 1; + MutatorString mutatorString = 4; + MutatorFloat mutatorFloat = 5; + MutatorInt mutatorInt = 6; + MutatorSparseBoolean mutatorSparseBoolean = 7; + MutatorSparseInt mutatorSparseInt = 8; + MutatorSparseFloat mutatorSparseFloat = 9; +} + +message TeamComposition { + TeamStructure teams = 1; + repeated InternalTeamStructure internalTeams = 2; + BalancingMethod balancingMethod = 3; +} + +message Mutator { + string name = 1; + string category = 2; + MutatorKind kind = 3; + string id = 4; +} + +message Timestamp { + int64 seconds = 1 [jstype=JS_STRING]; + int32 nanos = 2; +} + +message StringValue { + string value = 1; +} + +message GameServerMessage { + string kind = 1; + string text = 2; +} + +message GameServerSettings { + string name = 1; + StringValue description = 2; + repeated GameServerMessage gameServerMessage = 3; + StringValue configName = 4; + StringValue ConfigDescription = 5; + PhantomGameState phantomGameState = 6; +} + +message PlayerInfo { + uint64 nucleusId = 1 [jstype=JS_STRING]; + uint64 personaId = 2 [jstype=JS_STRING]; + Platform platformId = 3; +} + +message PlatformRestrictions { + repeated Platform platforms = 1; +} + +message InputMethodResrictions { + repeated InputMethods inputMethods = 1; +} + +message Restrictions { + PlatformRestrictions platformRestrictions = 1; + InputMethodResrictions inputMethodResctrictions = 2; +} + +message Compressed { + bytes compiledModRules = 1; + int32 rulesVersion = 2; + int32 inflatedSize = 3; +} + +message Uncompressed { + bytes compiledModRules = 1; + int32 rulesVersion = 2; +} + +message CompiledRules { + Uncompressed uncompressed = 1; + Compressed compressed = 2; +} + +message CompatibleModRules { + bytes rules = 1; + // bytes compiledOld = 2; + int32 rulesVersion = 3; + CompiledRules compiled = 4; +} + +message InCompatibleModRules { + bytes rules = 1; + int32 rulesVersion = 2; + int32 blueprintRulesVersion = 3; +} + +message OriginalModRules { + CompatibleModRules compatibleRules = 1; + InCompatibleModRules incompatibleRules = 2; +} + +message AssetCategoryTagBooleanOverride { + repeated string assetCategoryTags = 1; + bool value = 2; +} + +message AssetCategoryTagBooleanTeamOverride { + repeated string assetCategoryTags = 1; + bool value = 2; + uint32 teamId = 3; +} + +message AssetCategoryBoolean { + bool defaultValue = 1; + AssetCategoryTagBooleanOverride overrides = 2; + repeated AssetCategoryTagBooleanTeamOverride teamOverrides = 3; +} + +message AssetCategory { + string tagId = 1; + AssetCategoryBoolean boolean = 2; +} + +message Playground { + string playgroundId = 1; + string blueprintType = 3; + string name = 4; + string description = 5; + repeated Mutator mutators = 6; + MapRotation mapRotation = 7; + State state = 8; + string checksum = 9; + string secret = 10; + Timestamp createdAt = 11; + Timestamp updatedAt = 12; + GameServerSettings serverSettings = 13; + PlayerInfo owner = 14; + Restrictions restrictions = 15; + OriginalModRules modRules = 16; + repeated AssetCategory assetCategories = 17; + TeamComposition teamComposition = 18; +} + +message ListPlaygroundsByOwnerRequest { + string blueprintType = 1; + string protocolVersion = 2; +} + +message GetConstraintsRequest { +} + +message GetBlueprintsByIdRequest { + repeated string blueprintIds = 1; + repeated IncludeFields includeFields = 2; +} + +message GlobalConstraints { + int32 maxPlaygroundsPerPlayer = 1; + int32 maxGameServersPerPlayer = 2; + int32 maxFollowedHostsListSize = 3; +} + +message IntRange { + int32 minValue = 1; + int32 maxValue = 2; +} + +message AvailableIntValues { + IntRange range = 1; + SparseIntEntity sparseValues = 2; +} + +message AvailableIntValue { + int32 defaultValue = 1; + AvailableIntValues availableValues = 2; +} + +message AvailableMutator { + string name = 1; + string category = 2; + // AvailableMutatorKind kind = 3; // TODO: + Metadata metadata = 4; + string id = 5; +} + +message AvailableMapEntry { + string levelName = 1; + string gameMode = 2; + string levelLocation = 3; + AvailableIntValue gameSize = 4; + AvailableIntValue rounds = 5; + AvailableIntValue preRoundSize = 6; + AvailableIntValue warmUpSize = 7; + AvailableIntValue allowedSpectators = 8; + repeated AvailableMutator mutators = 9; + repeated Metadata metadata = 10; +} + +message AvailableTag { + string id = 1; + Metadata metadata = 2; + Category category = 3; +} + +message AvailableAssetCategoryTag { + string tagId = 1; + string name = 2; + repeated string childrenTags = 3; + Metadata metadata = 4; +} + +message AvailableAssetCategories { + repeated AvailableAssetCategoryTag rootTags = 1; + repeated AvailableAssetCategoryTag tags = 2; +} + +message PlaygroundConstraints { + int32 maxNameSize = 1; + int32 maxDescriptionSize = 2; + int32 maxSecretSize = 3; + int32 maxMapsInRotation = 4; + int32 maxMutators = 5; + int32 maxConfigNameSize = 6; + int32 maxConfigDescriptionSize = 7; +} + +message ModRulesDefinition { + int32 rulesVersion = 1; + bytes modBuilder = 2; +} + +message AvailableGameData { + repeated AvailableMutator mutators = 1; + repeated AvailableMapEntry maps = 2; + ModRulesDefinition modRules = 4; + AvailableAssetCategories assetCategories = 5; +} + +message Blueprint { + string blueprintType = 1; + string name = 2; + AvailableGameData availableGameData = 3; + Metadata metadata = 4; + bytes customData = 5; + PlaygroundConstraints playgroundConstraints = 6; + repeated AvailableTag availableTags = 7; +} + +message ShortCode { + string code = 1; +} + +message GetProgressionTypesRequest { +} + +message BlueprintInfo { + string blueprintType = 1; + string blueprintId = 2; +} + +message GetProgressionTypesResponse { + repeated ProgressionEntry entries = 1; +} + +message GetScheduledBlueprintsRequest { + string protocolVersion = 1; +} + +message GetScheduledBlueprintsResponse { + BlueprintInfo blueprints = 1; +} + +message GetBlueprintsByIdResponse { + repeated Blueprint blueprint = 1; +} + +message GetConstraintsResponse { + GlobalConstraints globalConstraints = 1; +} + +message ListPlaygroundsByOwnerResponse { + repeated PlaygroundResponse playgroundResponses = 2; +} + +message CreatePlaygroundRequest { + string blueprintType = 2; + string name = 3; + StringValue description = 4; + repeated Mutator mutators = 5; + MapRotation mapRotation = 6; + StringValue secret = 7; + GameServerSettings serverSettings = 8; + Restrictions restrictions = 9; + bytes originalModRules = 10; + repeated AssetCategory assetCategories = 11; + TeamComposition teamComposition = 12; +} + +message UpdatePlaygroundRequest { + Playground newPlayground = 2; +} + +message DeletePlaygroundRequest { + string playgroundId = 1; +} + +message GetPlaygroundRequest { + string playgroundId = 2; +} + +message SharePlaygroundRequest { + string playgroundId = 1; +} + +message SharePlaygroundResponse { + ShortCode shortCode = 1; +} + +message CreatePlaygroundResponse { + PlaygroundResponse playgroundResponse = 2; +} + +message UpdatePlaygroundResponse { + PlaygroundResponse playgroundResponse = 2; +} + +message DeletePlaygroundResponse { +} + +message PlaygroundInfoResponse { + PlaygroundResponse playground = 1; +} \ No newline at end of file diff --git a/proto/localization.proto b/proto/localization.proto new file mode 100644 index 0000000..62da1c0 --- /dev/null +++ b/proto/localization.proto @@ -0,0 +1,47 @@ +syntax = "proto3"; + +package web.localization; + +service ClientLocalization { + rpc getTranslations (GetTranslationsRequest) returns (GetTranslationsResponse) {} +} + +message SidList { + repeated string sids = 1; +} + +message CategoryIdList { + repeated int32 ids = 1; +} + +message SubCategoryIdList { + repeated int32 ids = 1; +} + +message TranslationsQuery { + SidList sidList = 1; + CategoryIdList categoryIdList = 2; + SubCategoryIdList subCategoryIdList = 3; +} + +message LocalizedText { + string sid = 1; + string localizedText = 2; + int32 categoryId = 3; +} + +message Timestamp { + int64 seconds = 1 [jstype=JS_STRING]; + int32 nanos = 2; +} + +message GetTranslationsRequest { + TranslationsQuery translationsQuery = 1; + string locale = 4; + Timestamp fetchFrom = 5; +} + +message GetTranslationsResponse { + repeated LocalizedText localizedTexts = 3; + Timestamp fetchedUntil = 4; +} diff --git a/proto/reporting.proto b/proto/reporting.proto new file mode 100644 index 0000000..e0caf24 --- /dev/null +++ b/proto/reporting.proto @@ -0,0 +1,44 @@ +syntax = "proto3"; + +package web.reporting; + +service WebReporting { + rpc reportPlayground (ReportPlaygroundRequest) returns (ReportPlaygroundResponse) {} +} + +enum Category { + UNKNOWN_CATEGORY = 0; + CHEATING = 1; + HARASSMENT = 2; + SPAM = 3; + PLAGIARISM = 4; + HATE_SPEECH = 5; + SEXUALLY_EXPLICIT = 6; + CHILD_SOLICITATION = 7; + TERRORIST_THREAT = 8; + CLIENT_HACK = 9; + SUICIDE_THREAT = 10; + DOXING = 11; + ADVERTISING = 12; + INAPPROPRIATE = 13; + VIOLENT = 14; + OFFENSIVE = 15; + OFFENSIVE_CHAT = 16; + OFFENSIVE_NAME = 17; +} + +message StringValue { + string value = 1; +} + +message ReportPlaygroundRequest { + string protocolVersion = 1; + string playgroundId = 2; + Category category = 3; + StringValue requesterEmail = 4; + StringValue subject = 5; +} + +message ReportPlaygroundResponse { + string petitionId = 1; +} \ No newline at end of file diff --git a/protoc-gen-js b/protoc-gen-js new file mode 100644 index 0000000..779a585 Binary files /dev/null and b/protoc-gen-js differ diff --git a/src/grpc-web/proto/authentication_grpc_web_pb.d.ts b/src/grpc-web/proto/authentication_grpc_web_pb.d.ts new file mode 100644 index 0000000..fed2283 --- /dev/null +++ b/src/grpc-web/proto/authentication_grpc_web_pb.d.ts @@ -0,0 +1,45 @@ +import * as grpcWeb from 'grpc-web'; + +import { + AuthRequest, + AuthResponse, + Empty} from './authentication_pb'; + +export class ClientAuthenticationClient { + constructor (hostname: string, + credentials?: null | { [index: string]: string; }, + options?: null | { [index: string]: string; }); + + viaAuthCode( + request: AuthRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: AuthResponse) => void + ): grpcWeb.ClientReadableStream; + + logout( + request: Empty, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: Empty) => void + ): grpcWeb.ClientReadableStream; + +} + +export class ClientAuthenticationPromiseClient { + constructor (hostname: string, + credentials?: null | { [index: string]: string; }, + options?: null | { [index: string]: string; }); + + viaAuthCode( + request: AuthRequest, + metadata?: grpcWeb.Metadata + ): Promise; + + logout( + request: Empty, + metadata?: grpcWeb.Metadata + ): Promise; + +} + diff --git a/src/grpc-web/proto/authentication_grpc_web_pb.js b/src/grpc-web/proto/authentication_grpc_web_pb.js new file mode 100644 index 0000000..e4b4351 --- /dev/null +++ b/src/grpc-web/proto/authentication_grpc_web_pb.js @@ -0,0 +1,235 @@ +/** + * @fileoverview gRPC-Web generated client stub for web.authentication + * @enhanceable + * @public + */ + +// GENERATED CODE -- DO NOT EDIT! + + +/* eslint-disable */ +// @ts-nocheck + + + +const grpc = {}; +grpc.web = require('grpc-web'); + +const proto = {}; +proto.web = {}; +proto.web.authentication = require('./authentication_pb.js'); + +/** + * @param {string} hostname + * @param {?Object} credentials + * @param {?Object} options + * @constructor + * @struct + * @final + */ +proto.web.authentication.ClientAuthenticationClient = + function(hostname, credentials, options) { + if (!options) options = {}; + options['format'] = 'binary'; + + /** + * @private @const {!grpc.web.GrpcWebClientBase} The client + */ + this.client_ = new grpc.web.GrpcWebClientBase(options); + + /** + * @private @const {string} The hostname + */ + this.hostname_ = hostname; + +}; + + +/** + * @param {string} hostname + * @param {?Object} credentials + * @param {?Object} options + * @constructor + * @struct + * @final + */ +proto.web.authentication.ClientAuthenticationPromiseClient = + function(hostname, credentials, options) { + if (!options) options = {}; + options['format'] = 'binary'; + + /** + * @private @const {!grpc.web.GrpcWebClientBase} The client + */ + this.client_ = new grpc.web.GrpcWebClientBase(options); + + /** + * @private @const {string} The hostname + */ + this.hostname_ = hostname; + +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.authentication.AuthRequest, + * !proto.web.authentication.AuthResponse>} + */ +const methodDescriptor_ClientAuthentication_viaAuthCode = new grpc.web.MethodDescriptor( + '/web.authentication.ClientAuthentication/viaAuthCode', + grpc.web.MethodType.UNARY, + proto.web.authentication.AuthRequest, + proto.web.authentication.AuthResponse, + /** + * @param {!proto.web.authentication.AuthRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.authentication.AuthResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.authentication.AuthRequest, + * !proto.web.authentication.AuthResponse>} + */ +const methodInfo_ClientAuthentication_viaAuthCode = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.authentication.AuthResponse, + /** + * @param {!proto.web.authentication.AuthRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.authentication.AuthResponse.deserializeBinary +); + + +/** + * @param {!proto.web.authentication.AuthRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.authentication.AuthResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.authentication.ClientAuthenticationClient.prototype.viaAuthCode = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.authentication.ClientAuthentication/viaAuthCode', + request, + metadata || {}, + methodDescriptor_ClientAuthentication_viaAuthCode, + callback); +}; + + +/** + * @param {!proto.web.authentication.AuthRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.authentication.ClientAuthenticationPromiseClient.prototype.viaAuthCode = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.authentication.ClientAuthentication/viaAuthCode', + request, + metadata || {}, + methodDescriptor_ClientAuthentication_viaAuthCode); +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.authentication.Empty, + * !proto.web.authentication.Empty>} + */ +const methodDescriptor_ClientAuthentication_logout = new grpc.web.MethodDescriptor( + '/web.authentication.ClientAuthentication/logout', + grpc.web.MethodType.UNARY, + proto.web.authentication.Empty, + proto.web.authentication.Empty, + /** + * @param {!proto.web.authentication.Empty} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.authentication.Empty.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.authentication.Empty, + * !proto.web.authentication.Empty>} + */ +const methodInfo_ClientAuthentication_logout = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.authentication.Empty, + /** + * @param {!proto.web.authentication.Empty} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.authentication.Empty.deserializeBinary +); + + +/** + * @param {!proto.web.authentication.Empty} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.authentication.Empty)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.authentication.ClientAuthenticationClient.prototype.logout = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.authentication.ClientAuthentication/logout', + request, + metadata || {}, + methodDescriptor_ClientAuthentication_logout, + callback); +}; + + +/** + * @param {!proto.web.authentication.Empty} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.authentication.ClientAuthenticationPromiseClient.prototype.logout = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.authentication.ClientAuthentication/logout', + request, + metadata || {}, + methodDescriptor_ClientAuthentication_logout); +}; + + +module.exports = proto.web.authentication; + diff --git a/src/grpc-web/proto/authentication_pb.d.ts b/src/grpc-web/proto/authentication_pb.d.ts new file mode 100644 index 0000000..61288cb --- /dev/null +++ b/src/grpc-web/proto/authentication_pb.d.ts @@ -0,0 +1,208 @@ +import * as jspb from "google-protobuf" + +export class PlayerInfo extends jspb.Message { + getNucleusid(): number; + setNucleusid(value: number): PlayerInfo; + + getPersonaid(): number; + setPersonaid(value: number): PlayerInfo; + + getPlatformid(): number; + setPlatformid(value: number): PlayerInfo; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): PlayerInfo.AsObject; + static toObject(includeInstance: boolean, msg: PlayerInfo): PlayerInfo.AsObject; + static serializeBinaryToWriter(message: PlayerInfo, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): PlayerInfo; + static deserializeBinaryFromReader(message: PlayerInfo, reader: jspb.BinaryReader): PlayerInfo; +} + +export namespace PlayerInfo { + export type AsObject = { + nucleusid: number, + personaid: number, + platformid: number, + } +} + +export class AuthRequest extends jspb.Message { + getAuthcode(): string; + setAuthcode(value: string): AuthRequest; + + getRedirecturi(): string; + setRedirecturi(value: string): AuthRequest; + + getProduct(): string; + setProduct(value: string): AuthRequest; + + getFirstpartyid(): string; + setFirstpartyid(value: string): AuthRequest; + + getPlatform(): Platform; + setPlatform(value: Platform): AuthRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AuthRequest.AsObject; + static toObject(includeInstance: boolean, msg: AuthRequest): AuthRequest.AsObject; + static serializeBinaryToWriter(message: AuthRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AuthRequest; + static deserializeBinaryFromReader(message: AuthRequest, reader: jspb.BinaryReader): AuthRequest; +} + +export namespace AuthRequest { + export type AsObject = { + authcode: string, + redirecturi: string, + product: string, + firstpartyid: string, + platform: Platform, + } +} + +export class Duration extends jspb.Message { + getSeconds(): number; + setSeconds(value: number): Duration; + + getNanos(): number; + setNanos(value: number): Duration; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Duration.AsObject; + static toObject(includeInstance: boolean, msg: Duration): Duration.AsObject; + static serializeBinaryToWriter(message: Duration, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Duration; + static deserializeBinaryFromReader(message: Duration, reader: jspb.BinaryReader): Duration; +} + +export namespace Duration { + export type AsObject = { + seconds: number, + nanos: number, + } +} + +export class TimeTravel extends jspb.Message { + getOffset(): Duration | undefined; + setOffset(value?: Duration): TimeTravel; + hasOffset(): boolean; + clearOffset(): TimeTravel; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): TimeTravel.AsObject; + static toObject(includeInstance: boolean, msg: TimeTravel): TimeTravel.AsObject; + static serializeBinaryToWriter(message: TimeTravel, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): TimeTravel; + static deserializeBinaryFromReader(message: TimeTravel, reader: jspb.BinaryReader): TimeTravel; +} + +export namespace TimeTravel { + export type AsObject = { + offset?: Duration.AsObject, + } +} + +export class ProtocolVersionOverride extends jspb.Message { + getOriginal(): string; + setOriginal(value: string): ProtocolVersionOverride; + + getOverridden(): string; + setOverridden(value: string): ProtocolVersionOverride; + + getReason(): Reason; + setReason(value: Reason): ProtocolVersionOverride; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ProtocolVersionOverride.AsObject; + static toObject(includeInstance: boolean, msg: ProtocolVersionOverride): ProtocolVersionOverride.AsObject; + static serializeBinaryToWriter(message: ProtocolVersionOverride, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ProtocolVersionOverride; + static deserializeBinaryFromReader(message: ProtocolVersionOverride, reader: jspb.BinaryReader): ProtocolVersionOverride; +} + +export namespace ProtocolVersionOverride { + export type AsObject = { + original: string, + overridden: string, + reason: Reason, + } +} + +export class Empty extends jspb.Message { + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Empty.AsObject; + static toObject(includeInstance: boolean, msg: Empty): Empty.AsObject; + static serializeBinaryToWriter(message: Empty, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Empty; + static deserializeBinaryFromReader(message: Empty, reader: jspb.BinaryReader): Empty; +} + +export namespace Empty { + export type AsObject = { + } +} + +export class AuthResponse extends jspb.Message { + getSessionid(): string; + setSessionid(value: string): AuthResponse; + + getPlayer(): PlayerInfo | undefined; + setPlayer(value?: PlayerInfo): AuthResponse; + hasPlayer(): boolean; + clearPlayer(): AuthResponse; + + getUserbitsList(): Array; + setUserbitsList(value: Array): AuthResponse; + clearUserbitsList(): AuthResponse; + addUserbits(value: UserBits, index?: number): AuthResponse; + + getTimetravel(): TimeTravel | undefined; + setTimetravel(value?: TimeTravel): AuthResponse; + hasTimetravel(): boolean; + clearTimetravel(): AuthResponse; + + getProtocolversionoverride(): ProtocolVersionOverride | undefined; + setProtocolversionoverride(value?: ProtocolVersionOverride): AuthResponse; + hasProtocolversionoverride(): boolean; + clearProtocolversionoverride(): AuthResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AuthResponse.AsObject; + static toObject(includeInstance: boolean, msg: AuthResponse): AuthResponse.AsObject; + static serializeBinaryToWriter(message: AuthResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AuthResponse; + static deserializeBinaryFromReader(message: AuthResponse, reader: jspb.BinaryReader): AuthResponse; +} + +export namespace AuthResponse { + export type AsObject = { + sessionid: string, + player?: PlayerInfo.AsObject, + userbitsList: Array, + timetravel?: TimeTravel.AsObject, + protocolversionoverride?: ProtocolVersionOverride.AsObject, + } +} + +export enum Platform { + UNKNOWN = 0, + PC = 1, + PS4 = 2, + XBOXONE = 3, + PS5 = 4, + XBSX = 5, + COMMON = 6, +} +export enum Reason { + NONE = 0, + PLAYER = 1, + SYNC = 2, +} +export enum UserBits { + USER_BIT_UNSPECIFIED = 0, + USER_BIT_ACCEPTED_TOS = 1, + USER_BIT_ENABLE_USERSHARING = 2, + USER_BIT_ENABLE_CRASHREPORTS = 3, + USER_BIT_COMPLETED_TUTORIAL = 4, + USER_BIT_CLIENT_ENABLE_USAGESHARING = 5, +} diff --git a/src/grpc-web/proto/authentication_pb.js b/src/grpc-web/proto/authentication_pb.js new file mode 100644 index 0000000..21fffa8 --- /dev/null +++ b/src/grpc-web/proto/authentication_pb.js @@ -0,0 +1,1587 @@ +// source: proto/authentication.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! + +var jspb = require('google-protobuf'); +var goog = jspb; +var global = Function('return this')(); + +goog.exportSymbol('proto.web.authentication.AuthRequest', null, global); +goog.exportSymbol('proto.web.authentication.AuthResponse', null, global); +goog.exportSymbol('proto.web.authentication.Duration', null, global); +goog.exportSymbol('proto.web.authentication.Empty', null, global); +goog.exportSymbol('proto.web.authentication.Platform', null, global); +goog.exportSymbol('proto.web.authentication.PlayerInfo', null, global); +goog.exportSymbol('proto.web.authentication.ProtocolVersionOverride', null, global); +goog.exportSymbol('proto.web.authentication.Reason', null, global); +goog.exportSymbol('proto.web.authentication.TimeTravel', null, global); +goog.exportSymbol('proto.web.authentication.UserBits', 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.web.authentication.PlayerInfo = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.authentication.PlayerInfo, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.authentication.PlayerInfo.displayName = 'proto.web.authentication.PlayerInfo'; +} +/** + * 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.web.authentication.AuthRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.authentication.AuthRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.authentication.AuthRequest.displayName = 'proto.web.authentication.AuthRequest'; +} +/** + * 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.web.authentication.Duration = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.authentication.Duration, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.authentication.Duration.displayName = 'proto.web.authentication.Duration'; +} +/** + * 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.web.authentication.TimeTravel = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.authentication.TimeTravel, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.authentication.TimeTravel.displayName = 'proto.web.authentication.TimeTravel'; +} +/** + * 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.web.authentication.ProtocolVersionOverride = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.authentication.ProtocolVersionOverride, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.authentication.ProtocolVersionOverride.displayName = 'proto.web.authentication.ProtocolVersionOverride'; +} +/** + * 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.web.authentication.Empty = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.authentication.Empty, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.authentication.Empty.displayName = 'proto.web.authentication.Empty'; +} +/** + * 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.web.authentication.AuthResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.authentication.AuthResponse.repeatedFields_, null); +}; +goog.inherits(proto.web.authentication.AuthResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.authentication.AuthResponse.displayName = 'proto.web.authentication.AuthResponse'; +} + + + +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.web.authentication.PlayerInfo.prototype.toObject = function(opt_includeInstance) { + return proto.web.authentication.PlayerInfo.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.web.authentication.PlayerInfo} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.PlayerInfo.toObject = function(includeInstance, msg) { + var f, obj = { + nucleusid: jspb.Message.getFieldWithDefault(msg, 1, 0), + personaid: jspb.Message.getFieldWithDefault(msg, 2, 0), + platformid: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.authentication.PlayerInfo} + */ +proto.web.authentication.PlayerInfo.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.authentication.PlayerInfo; + return proto.web.authentication.PlayerInfo.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.authentication.PlayerInfo} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.authentication.PlayerInfo} + */ +proto.web.authentication.PlayerInfo.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readInt64()); + msg.setNucleusid(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt64()); + msg.setPersonaid(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setPlatformid(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.authentication.PlayerInfo.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.authentication.PlayerInfo.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.authentication.PlayerInfo} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.PlayerInfo.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getNucleusid(); + if (f !== 0) { + writer.writeInt64( + 1, + f + ); + } + f = message.getPersonaid(); + if (f !== 0) { + writer.writeInt64( + 2, + f + ); + } + f = message.getPlatformid(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } +}; + + +/** + * optional int64 nucleusId = 1; + * @return {number} + */ +proto.web.authentication.PlayerInfo.prototype.getNucleusid = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.authentication.PlayerInfo} returns this + */ +proto.web.authentication.PlayerInfo.prototype.setNucleusid = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional int64 personaId = 2; + * @return {number} + */ +proto.web.authentication.PlayerInfo.prototype.getPersonaid = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.authentication.PlayerInfo} returns this + */ +proto.web.authentication.PlayerInfo.prototype.setPersonaid = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional int32 platformId = 3; + * @return {number} + */ +proto.web.authentication.PlayerInfo.prototype.getPlatformid = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.authentication.PlayerInfo} returns this + */ +proto.web.authentication.PlayerInfo.prototype.setPlatformid = function(value) { + return jspb.Message.setProto3IntField(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.web.authentication.AuthRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.authentication.AuthRequest.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.web.authentication.AuthRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.AuthRequest.toObject = function(includeInstance, msg) { + var f, obj = { + authcode: jspb.Message.getFieldWithDefault(msg, 1, ""), + redirecturi: jspb.Message.getFieldWithDefault(msg, 2, ""), + product: jspb.Message.getFieldWithDefault(msg, 3, ""), + firstpartyid: jspb.Message.getFieldWithDefault(msg, 4, ""), + platform: 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.web.authentication.AuthRequest} + */ +proto.web.authentication.AuthRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.authentication.AuthRequest; + return proto.web.authentication.AuthRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.authentication.AuthRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.authentication.AuthRequest} + */ +proto.web.authentication.AuthRequest.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.setAuthcode(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setRedirecturi(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setProduct(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setFirstpartyid(value); + break; + case 5: + var value = /** @type {!proto.web.authentication.Platform} */ (reader.readEnum()); + msg.setPlatform(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.authentication.AuthRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.authentication.AuthRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.authentication.AuthRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.AuthRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getAuthcode(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getRedirecturi(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getProduct(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getFirstpartyid(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } + f = message.getPlatform(); + if (f !== 0.0) { + writer.writeEnum( + 5, + f + ); + } +}; + + +/** + * optional string authCode = 1; + * @return {string} + */ +proto.web.authentication.AuthRequest.prototype.getAuthcode = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.authentication.AuthRequest} returns this + */ +proto.web.authentication.AuthRequest.prototype.setAuthcode = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string redirectUri = 2; + * @return {string} + */ +proto.web.authentication.AuthRequest.prototype.getRedirecturi = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.authentication.AuthRequest} returns this + */ +proto.web.authentication.AuthRequest.prototype.setRedirecturi = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string product = 3; + * @return {string} + */ +proto.web.authentication.AuthRequest.prototype.getProduct = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.authentication.AuthRequest} returns this + */ +proto.web.authentication.AuthRequest.prototype.setProduct = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional string firstPartyId = 4; + * @return {string} + */ +proto.web.authentication.AuthRequest.prototype.getFirstpartyid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.authentication.AuthRequest} returns this + */ +proto.web.authentication.AuthRequest.prototype.setFirstpartyid = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * optional Platform platform = 5; + * @return {!proto.web.authentication.Platform} + */ +proto.web.authentication.AuthRequest.prototype.getPlatform = function() { + return /** @type {!proto.web.authentication.Platform} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); +}; + + +/** + * @param {!proto.web.authentication.Platform} value + * @return {!proto.web.authentication.AuthRequest} returns this + */ +proto.web.authentication.AuthRequest.prototype.setPlatform = function(value) { + return jspb.Message.setProto3EnumField(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.web.authentication.Duration.prototype.toObject = function(opt_includeInstance) { + return proto.web.authentication.Duration.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.web.authentication.Duration} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.Duration.toObject = function(includeInstance, msg) { + var f, obj = { + seconds: jspb.Message.getFieldWithDefault(msg, 1, 0), + nanos: jspb.Message.getFieldWithDefault(msg, 2, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.authentication.Duration} + */ +proto.web.authentication.Duration.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.authentication.Duration; + return proto.web.authentication.Duration.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.authentication.Duration} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.authentication.Duration} + */ +proto.web.authentication.Duration.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readInt64()); + msg.setSeconds(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setNanos(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.authentication.Duration.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.authentication.Duration.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.authentication.Duration} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.Duration.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getSeconds(); + if (f !== 0) { + writer.writeInt64( + 1, + f + ); + } + f = message.getNanos(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } +}; + + +/** + * optional int64 seconds = 1; + * @return {number} + */ +proto.web.authentication.Duration.prototype.getSeconds = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.authentication.Duration} returns this + */ +proto.web.authentication.Duration.prototype.setSeconds = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional int32 nanos = 2; + * @return {number} + */ +proto.web.authentication.Duration.prototype.getNanos = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.authentication.Duration} returns this + */ +proto.web.authentication.Duration.prototype.setNanos = function(value) { + return jspb.Message.setProto3IntField(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.web.authentication.TimeTravel.prototype.toObject = function(opt_includeInstance) { + return proto.web.authentication.TimeTravel.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.web.authentication.TimeTravel} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.TimeTravel.toObject = function(includeInstance, msg) { + var f, obj = { + offset: (f = msg.getOffset()) && proto.web.authentication.Duration.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.web.authentication.TimeTravel} + */ +proto.web.authentication.TimeTravel.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.authentication.TimeTravel; + return proto.web.authentication.TimeTravel.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.authentication.TimeTravel} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.authentication.TimeTravel} + */ +proto.web.authentication.TimeTravel.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.authentication.Duration; + reader.readMessage(value,proto.web.authentication.Duration.deserializeBinaryFromReader); + msg.setOffset(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.authentication.TimeTravel.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.authentication.TimeTravel.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.authentication.TimeTravel} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.TimeTravel.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getOffset(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.authentication.Duration.serializeBinaryToWriter + ); + } +}; + + +/** + * optional Duration offset = 1; + * @return {?proto.web.authentication.Duration} + */ +proto.web.authentication.TimeTravel.prototype.getOffset = function() { + return /** @type{?proto.web.authentication.Duration} */ ( + jspb.Message.getWrapperField(this, proto.web.authentication.Duration, 1)); +}; + + +/** + * @param {?proto.web.authentication.Duration|undefined} value + * @return {!proto.web.authentication.TimeTravel} returns this +*/ +proto.web.authentication.TimeTravel.prototype.setOffset = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.authentication.TimeTravel} returns this + */ +proto.web.authentication.TimeTravel.prototype.clearOffset = function() { + return this.setOffset(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.authentication.TimeTravel.prototype.hasOffset = function() { + return jspb.Message.getField(this, 1) != 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.web.authentication.ProtocolVersionOverride.prototype.toObject = function(opt_includeInstance) { + return proto.web.authentication.ProtocolVersionOverride.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.web.authentication.ProtocolVersionOverride} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.ProtocolVersionOverride.toObject = function(includeInstance, msg) { + var f, obj = { + original: jspb.Message.getFieldWithDefault(msg, 1, ""), + overridden: jspb.Message.getFieldWithDefault(msg, 2, ""), + reason: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.authentication.ProtocolVersionOverride} + */ +proto.web.authentication.ProtocolVersionOverride.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.authentication.ProtocolVersionOverride; + return proto.web.authentication.ProtocolVersionOverride.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.authentication.ProtocolVersionOverride} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.authentication.ProtocolVersionOverride} + */ +proto.web.authentication.ProtocolVersionOverride.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.setOriginal(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setOverridden(value); + break; + case 3: + var value = /** @type {!proto.web.authentication.Reason} */ (reader.readEnum()); + msg.setReason(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.authentication.ProtocolVersionOverride.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.authentication.ProtocolVersionOverride.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.authentication.ProtocolVersionOverride} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.ProtocolVersionOverride.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getOriginal(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getOverridden(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getReason(); + if (f !== 0.0) { + writer.writeEnum( + 3, + f + ); + } +}; + + +/** + * optional string original = 1; + * @return {string} + */ +proto.web.authentication.ProtocolVersionOverride.prototype.getOriginal = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.authentication.ProtocolVersionOverride} returns this + */ +proto.web.authentication.ProtocolVersionOverride.prototype.setOriginal = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string overridden = 2; + * @return {string} + */ +proto.web.authentication.ProtocolVersionOverride.prototype.getOverridden = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.authentication.ProtocolVersionOverride} returns this + */ +proto.web.authentication.ProtocolVersionOverride.prototype.setOverridden = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional Reason reason = 3; + * @return {!proto.web.authentication.Reason} + */ +proto.web.authentication.ProtocolVersionOverride.prototype.getReason = function() { + return /** @type {!proto.web.authentication.Reason} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {!proto.web.authentication.Reason} value + * @return {!proto.web.authentication.ProtocolVersionOverride} returns this + */ +proto.web.authentication.ProtocolVersionOverride.prototype.setReason = function(value) { + return jspb.Message.setProto3EnumField(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.web.authentication.Empty.prototype.toObject = function(opt_includeInstance) { + return proto.web.authentication.Empty.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.web.authentication.Empty} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.Empty.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.authentication.Empty} + */ +proto.web.authentication.Empty.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.authentication.Empty; + return proto.web.authentication.Empty.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.authentication.Empty} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.authentication.Empty} + */ +proto.web.authentication.Empty.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.authentication.Empty.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.authentication.Empty.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.authentication.Empty} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.Empty.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.authentication.AuthResponse.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.web.authentication.AuthResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.authentication.AuthResponse.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.web.authentication.AuthResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.AuthResponse.toObject = function(includeInstance, msg) { + var f, obj = { + sessionid: jspb.Message.getFieldWithDefault(msg, 1, ""), + player: (f = msg.getPlayer()) && proto.web.authentication.PlayerInfo.toObject(includeInstance, f), + userbitsList: (f = jspb.Message.getRepeatedField(msg, 4)) == null ? undefined : f, + timetravel: (f = msg.getTimetravel()) && proto.web.authentication.TimeTravel.toObject(includeInstance, f), + protocolversionoverride: (f = msg.getProtocolversionoverride()) && proto.web.authentication.ProtocolVersionOverride.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.web.authentication.AuthResponse} + */ +proto.web.authentication.AuthResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.authentication.AuthResponse; + return proto.web.authentication.AuthResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.authentication.AuthResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.authentication.AuthResponse} + */ +proto.web.authentication.AuthResponse.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.setSessionid(value); + break; + case 3: + var value = new proto.web.authentication.PlayerInfo; + reader.readMessage(value,proto.web.authentication.PlayerInfo.deserializeBinaryFromReader); + msg.setPlayer(value); + break; + case 4: + var value = /** @type {!Array} */ (reader.readPackedEnum()); + msg.setUserbitsList(value); + break; + case 5: + var value = new proto.web.authentication.TimeTravel; + reader.readMessage(value,proto.web.authentication.TimeTravel.deserializeBinaryFromReader); + msg.setTimetravel(value); + break; + case 6: + var value = new proto.web.authentication.ProtocolVersionOverride; + reader.readMessage(value,proto.web.authentication.ProtocolVersionOverride.deserializeBinaryFromReader); + msg.setProtocolversionoverride(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.authentication.AuthResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.authentication.AuthResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.authentication.AuthResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.authentication.AuthResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getSessionid(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getPlayer(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.web.authentication.PlayerInfo.serializeBinaryToWriter + ); + } + f = message.getUserbitsList(); + if (f.length > 0) { + writer.writePackedEnum( + 4, + f + ); + } + f = message.getTimetravel(); + if (f != null) { + writer.writeMessage( + 5, + f, + proto.web.authentication.TimeTravel.serializeBinaryToWriter + ); + } + f = message.getProtocolversionoverride(); + if (f != null) { + writer.writeMessage( + 6, + f, + proto.web.authentication.ProtocolVersionOverride.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string sessionId = 1; + * @return {string} + */ +proto.web.authentication.AuthResponse.prototype.getSessionid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.authentication.AuthResponse} returns this + */ +proto.web.authentication.AuthResponse.prototype.setSessionid = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional PlayerInfo player = 3; + * @return {?proto.web.authentication.PlayerInfo} + */ +proto.web.authentication.AuthResponse.prototype.getPlayer = function() { + return /** @type{?proto.web.authentication.PlayerInfo} */ ( + jspb.Message.getWrapperField(this, proto.web.authentication.PlayerInfo, 3)); +}; + + +/** + * @param {?proto.web.authentication.PlayerInfo|undefined} value + * @return {!proto.web.authentication.AuthResponse} returns this +*/ +proto.web.authentication.AuthResponse.prototype.setPlayer = function(value) { + return jspb.Message.setWrapperField(this, 3, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.authentication.AuthResponse} returns this + */ +proto.web.authentication.AuthResponse.prototype.clearPlayer = function() { + return this.setPlayer(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.authentication.AuthResponse.prototype.hasPlayer = function() { + return jspb.Message.getField(this, 3) != null; +}; + + +/** + * repeated UserBits userBits = 4; + * @return {!Array} + */ +proto.web.authentication.AuthResponse.prototype.getUserbitsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 4)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.authentication.AuthResponse} returns this + */ +proto.web.authentication.AuthResponse.prototype.setUserbitsList = function(value) { + return jspb.Message.setField(this, 4, value || []); +}; + + +/** + * @param {!proto.web.authentication.UserBits} value + * @param {number=} opt_index + * @return {!proto.web.authentication.AuthResponse} returns this + */ +proto.web.authentication.AuthResponse.prototype.addUserbits = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 4, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.authentication.AuthResponse} returns this + */ +proto.web.authentication.AuthResponse.prototype.clearUserbitsList = function() { + return this.setUserbitsList([]); +}; + + +/** + * optional TimeTravel timeTravel = 5; + * @return {?proto.web.authentication.TimeTravel} + */ +proto.web.authentication.AuthResponse.prototype.getTimetravel = function() { + return /** @type{?proto.web.authentication.TimeTravel} */ ( + jspb.Message.getWrapperField(this, proto.web.authentication.TimeTravel, 5)); +}; + + +/** + * @param {?proto.web.authentication.TimeTravel|undefined} value + * @return {!proto.web.authentication.AuthResponse} returns this +*/ +proto.web.authentication.AuthResponse.prototype.setTimetravel = function(value) { + return jspb.Message.setWrapperField(this, 5, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.authentication.AuthResponse} returns this + */ +proto.web.authentication.AuthResponse.prototype.clearTimetravel = function() { + return this.setTimetravel(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.authentication.AuthResponse.prototype.hasTimetravel = function() { + return jspb.Message.getField(this, 5) != null; +}; + + +/** + * optional ProtocolVersionOverride protocolVersionOverride = 6; + * @return {?proto.web.authentication.ProtocolVersionOverride} + */ +proto.web.authentication.AuthResponse.prototype.getProtocolversionoverride = function() { + return /** @type{?proto.web.authentication.ProtocolVersionOverride} */ ( + jspb.Message.getWrapperField(this, proto.web.authentication.ProtocolVersionOverride, 6)); +}; + + +/** + * @param {?proto.web.authentication.ProtocolVersionOverride|undefined} value + * @return {!proto.web.authentication.AuthResponse} returns this +*/ +proto.web.authentication.AuthResponse.prototype.setProtocolversionoverride = function(value) { + return jspb.Message.setWrapperField(this, 6, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.authentication.AuthResponse} returns this + */ +proto.web.authentication.AuthResponse.prototype.clearProtocolversionoverride = function() { + return this.setProtocolversionoverride(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.authentication.AuthResponse.prototype.hasProtocolversionoverride = function() { + return jspb.Message.getField(this, 6) != null; +}; + + +/** + * @enum {number} + */ +proto.web.authentication.Platform = { + UNKNOWN: 0, + PC: 1, + PS4: 2, + XBOXONE: 3, + PS5: 4, + XBSX: 5, + COMMON: 6 +}; + +/** + * @enum {number} + */ +proto.web.authentication.Reason = { + NONE: 0, + PLAYER: 1, + SYNC: 2 +}; + +/** + * @enum {number} + */ +proto.web.authentication.UserBits = { + USER_BIT_UNSPECIFIED: 0, + USER_BIT_ACCEPTED_TOS: 1, + USER_BIT_ENABLE_USERSHARING: 2, + USER_BIT_ENABLE_CRASHREPORTS: 3, + USER_BIT_COMPLETED_TUTORIAL: 4, + USER_BIT_CLIENT_ENABLE_USAGESHARING: 5 +}; + +goog.object.extend(exports, proto.web.authentication); diff --git a/src/grpc-web/proto/communitygames_grpc_web_pb.d.ts b/src/grpc-web/proto/communitygames_grpc_web_pb.d.ts new file mode 100644 index 0000000..f4fa830 --- /dev/null +++ b/src/grpc-web/proto/communitygames_grpc_web_pb.d.ts @@ -0,0 +1,158 @@ +import * as grpcWeb from 'grpc-web'; + +import { + CreatePlaygroundRequest, + CreatePlaygroundResponse, + DeletePlaygroundRequest, + DeletePlaygroundResponse, + GetBlueprintsByIdRequest, + GetBlueprintsByIdResponse, + GetConstraintsRequest, + GetConstraintsResponse, + GetPlaygroundRequest, + GetProgressionTypesRequest, + GetProgressionTypesResponse, + GetScheduledBlueprintsRequest, + GetScheduledBlueprintsResponse, + ListPlaygroundsByOwnerRequest, + ListPlaygroundsByOwnerResponse, + PlaygroundInfoResponse, + SharePlaygroundRequest, + SharePlaygroundResponse, + UpdatePlaygroundRequest, + UpdatePlaygroundResponse} from './communitygames_pb'; + +export class CommunityGamesClient { + constructor (hostname: string, + credentials?: null | { [index: string]: string; }, + options?: null | { [index: string]: string; }); + + createPlayground( + request: CreatePlaygroundRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: CreatePlaygroundResponse) => void + ): grpcWeb.ClientReadableStream; + + updatePlayground( + request: UpdatePlaygroundRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: UpdatePlaygroundResponse) => void + ): grpcWeb.ClientReadableStream; + + deletePlayground( + request: DeletePlaygroundRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: DeletePlaygroundResponse) => void + ): grpcWeb.ClientReadableStream; + + getPlayground( + request: GetPlaygroundRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: PlaygroundInfoResponse) => void + ): grpcWeb.ClientReadableStream; + + listPlaygroundsByOwner( + request: ListPlaygroundsByOwnerRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: ListPlaygroundsByOwnerResponse) => void + ): grpcWeb.ClientReadableStream; + + getBlueprintsById( + request: GetBlueprintsByIdRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: GetBlueprintsByIdResponse) => void + ): grpcWeb.ClientReadableStream; + + getScheduledBlueprints( + request: GetScheduledBlueprintsRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: GetScheduledBlueprintsResponse) => void + ): grpcWeb.ClientReadableStream; + + getConstraints( + request: GetConstraintsRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: GetConstraintsResponse) => void + ): grpcWeb.ClientReadableStream; + + sharePlayground( + request: SharePlaygroundRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: SharePlaygroundResponse) => void + ): grpcWeb.ClientReadableStream; + + getProgressionTypes( + request: GetProgressionTypesRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: GetProgressionTypesResponse) => void + ): grpcWeb.ClientReadableStream; + +} + +export class CommunityGamesPromiseClient { + constructor (hostname: string, + credentials?: null | { [index: string]: string; }, + options?: null | { [index: string]: string; }); + + createPlayground( + request: CreatePlaygroundRequest, + metadata?: grpcWeb.Metadata + ): Promise; + + updatePlayground( + request: UpdatePlaygroundRequest, + metadata?: grpcWeb.Metadata + ): Promise; + + deletePlayground( + request: DeletePlaygroundRequest, + metadata?: grpcWeb.Metadata + ): Promise; + + getPlayground( + request: GetPlaygroundRequest, + metadata?: grpcWeb.Metadata + ): Promise; + + listPlaygroundsByOwner( + request: ListPlaygroundsByOwnerRequest, + metadata?: grpcWeb.Metadata + ): Promise; + + getBlueprintsById( + request: GetBlueprintsByIdRequest, + metadata?: grpcWeb.Metadata + ): Promise; + + getScheduledBlueprints( + request: GetScheduledBlueprintsRequest, + metadata?: grpcWeb.Metadata + ): Promise; + + getConstraints( + request: GetConstraintsRequest, + metadata?: grpcWeb.Metadata + ): Promise; + + sharePlayground( + request: SharePlaygroundRequest, + metadata?: grpcWeb.Metadata + ): Promise; + + getProgressionTypes( + request: GetProgressionTypesRequest, + metadata?: grpcWeb.Metadata + ): Promise; + +} + diff --git a/src/grpc-web/proto/communitygames_grpc_web_pb.js b/src/grpc-web/proto/communitygames_grpc_web_pb.js new file mode 100644 index 0000000..3913f4e --- /dev/null +++ b/src/grpc-web/proto/communitygames_grpc_web_pb.js @@ -0,0 +1,875 @@ +/** + * @fileoverview gRPC-Web generated client stub for web.communitygames + * @enhanceable + * @public + */ + +// GENERATED CODE -- DO NOT EDIT! + + +/* eslint-disable */ +// @ts-nocheck + + + +const grpc = {}; +grpc.web = require('grpc-web'); + +const proto = {}; +proto.web = {}; +proto.web.communitygames = require('./communitygames_pb.js'); + +/** + * @param {string} hostname + * @param {?Object} credentials + * @param {?Object} options + * @constructor + * @struct + * @final + */ +proto.web.communitygames.CommunityGamesClient = + function(hostname, credentials, options) { + if (!options) options = {}; + options['format'] = 'binary'; + + /** + * @private @const {!grpc.web.GrpcWebClientBase} The client + */ + this.client_ = new grpc.web.GrpcWebClientBase(options); + + /** + * @private @const {string} The hostname + */ + this.hostname_ = hostname; + +}; + + +/** + * @param {string} hostname + * @param {?Object} credentials + * @param {?Object} options + * @constructor + * @struct + * @final + */ +proto.web.communitygames.CommunityGamesPromiseClient = + function(hostname, credentials, options) { + if (!options) options = {}; + options['format'] = 'binary'; + + /** + * @private @const {!grpc.web.GrpcWebClientBase} The client + */ + this.client_ = new grpc.web.GrpcWebClientBase(options); + + /** + * @private @const {string} The hostname + */ + this.hostname_ = hostname; + +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.communitygames.CreatePlaygroundRequest, + * !proto.web.communitygames.CreatePlaygroundResponse>} + */ +const methodDescriptor_CommunityGames_createPlayground = new grpc.web.MethodDescriptor( + '/web.communitygames.CommunityGames/createPlayground', + grpc.web.MethodType.UNARY, + proto.web.communitygames.CreatePlaygroundRequest, + proto.web.communitygames.CreatePlaygroundResponse, + /** + * @param {!proto.web.communitygames.CreatePlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.CreatePlaygroundResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.communitygames.CreatePlaygroundRequest, + * !proto.web.communitygames.CreatePlaygroundResponse>} + */ +const methodInfo_CommunityGames_createPlayground = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.communitygames.CreatePlaygroundResponse, + /** + * @param {!proto.web.communitygames.CreatePlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.CreatePlaygroundResponse.deserializeBinary +); + + +/** + * @param {!proto.web.communitygames.CreatePlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.communitygames.CreatePlaygroundResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.communitygames.CommunityGamesClient.prototype.createPlayground = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.communitygames.CommunityGames/createPlayground', + request, + metadata || {}, + methodDescriptor_CommunityGames_createPlayground, + callback); +}; + + +/** + * @param {!proto.web.communitygames.CreatePlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.communitygames.CommunityGamesPromiseClient.prototype.createPlayground = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.communitygames.CommunityGames/createPlayground', + request, + metadata || {}, + methodDescriptor_CommunityGames_createPlayground); +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.communitygames.UpdatePlaygroundRequest, + * !proto.web.communitygames.UpdatePlaygroundResponse>} + */ +const methodDescriptor_CommunityGames_updatePlayground = new grpc.web.MethodDescriptor( + '/web.communitygames.CommunityGames/updatePlayground', + grpc.web.MethodType.UNARY, + proto.web.communitygames.UpdatePlaygroundRequest, + proto.web.communitygames.UpdatePlaygroundResponse, + /** + * @param {!proto.web.communitygames.UpdatePlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.UpdatePlaygroundResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.communitygames.UpdatePlaygroundRequest, + * !proto.web.communitygames.UpdatePlaygroundResponse>} + */ +const methodInfo_CommunityGames_updatePlayground = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.communitygames.UpdatePlaygroundResponse, + /** + * @param {!proto.web.communitygames.UpdatePlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.UpdatePlaygroundResponse.deserializeBinary +); + + +/** + * @param {!proto.web.communitygames.UpdatePlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.communitygames.UpdatePlaygroundResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.communitygames.CommunityGamesClient.prototype.updatePlayground = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.communitygames.CommunityGames/updatePlayground', + request, + metadata || {}, + methodDescriptor_CommunityGames_updatePlayground, + callback); +}; + + +/** + * @param {!proto.web.communitygames.UpdatePlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.communitygames.CommunityGamesPromiseClient.prototype.updatePlayground = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.communitygames.CommunityGames/updatePlayground', + request, + metadata || {}, + methodDescriptor_CommunityGames_updatePlayground); +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.communitygames.DeletePlaygroundRequest, + * !proto.web.communitygames.DeletePlaygroundResponse>} + */ +const methodDescriptor_CommunityGames_deletePlayground = new grpc.web.MethodDescriptor( + '/web.communitygames.CommunityGames/deletePlayground', + grpc.web.MethodType.UNARY, + proto.web.communitygames.DeletePlaygroundRequest, + proto.web.communitygames.DeletePlaygroundResponse, + /** + * @param {!proto.web.communitygames.DeletePlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.DeletePlaygroundResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.communitygames.DeletePlaygroundRequest, + * !proto.web.communitygames.DeletePlaygroundResponse>} + */ +const methodInfo_CommunityGames_deletePlayground = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.communitygames.DeletePlaygroundResponse, + /** + * @param {!proto.web.communitygames.DeletePlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.DeletePlaygroundResponse.deserializeBinary +); + + +/** + * @param {!proto.web.communitygames.DeletePlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.communitygames.DeletePlaygroundResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.communitygames.CommunityGamesClient.prototype.deletePlayground = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.communitygames.CommunityGames/deletePlayground', + request, + metadata || {}, + methodDescriptor_CommunityGames_deletePlayground, + callback); +}; + + +/** + * @param {!proto.web.communitygames.DeletePlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.communitygames.CommunityGamesPromiseClient.prototype.deletePlayground = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.communitygames.CommunityGames/deletePlayground', + request, + metadata || {}, + methodDescriptor_CommunityGames_deletePlayground); +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.communitygames.GetPlaygroundRequest, + * !proto.web.communitygames.PlaygroundInfoResponse>} + */ +const methodDescriptor_CommunityGames_getPlayground = new grpc.web.MethodDescriptor( + '/web.communitygames.CommunityGames/getPlayground', + grpc.web.MethodType.UNARY, + proto.web.communitygames.GetPlaygroundRequest, + proto.web.communitygames.PlaygroundInfoResponse, + /** + * @param {!proto.web.communitygames.GetPlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.PlaygroundInfoResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.communitygames.GetPlaygroundRequest, + * !proto.web.communitygames.PlaygroundInfoResponse>} + */ +const methodInfo_CommunityGames_getPlayground = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.communitygames.PlaygroundInfoResponse, + /** + * @param {!proto.web.communitygames.GetPlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.PlaygroundInfoResponse.deserializeBinary +); + + +/** + * @param {!proto.web.communitygames.GetPlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.communitygames.PlaygroundInfoResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.communitygames.CommunityGamesClient.prototype.getPlayground = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.communitygames.CommunityGames/getPlayground', + request, + metadata || {}, + methodDescriptor_CommunityGames_getPlayground, + callback); +}; + + +/** + * @param {!proto.web.communitygames.GetPlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.communitygames.CommunityGamesPromiseClient.prototype.getPlayground = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.communitygames.CommunityGames/getPlayground', + request, + metadata || {}, + methodDescriptor_CommunityGames_getPlayground); +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.communitygames.ListPlaygroundsByOwnerRequest, + * !proto.web.communitygames.ListPlaygroundsByOwnerResponse>} + */ +const methodDescriptor_CommunityGames_listPlaygroundsByOwner = new grpc.web.MethodDescriptor( + '/web.communitygames.CommunityGames/listPlaygroundsByOwner', + grpc.web.MethodType.UNARY, + proto.web.communitygames.ListPlaygroundsByOwnerRequest, + proto.web.communitygames.ListPlaygroundsByOwnerResponse, + /** + * @param {!proto.web.communitygames.ListPlaygroundsByOwnerRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.ListPlaygroundsByOwnerResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.communitygames.ListPlaygroundsByOwnerRequest, + * !proto.web.communitygames.ListPlaygroundsByOwnerResponse>} + */ +const methodInfo_CommunityGames_listPlaygroundsByOwner = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.communitygames.ListPlaygroundsByOwnerResponse, + /** + * @param {!proto.web.communitygames.ListPlaygroundsByOwnerRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.ListPlaygroundsByOwnerResponse.deserializeBinary +); + + +/** + * @param {!proto.web.communitygames.ListPlaygroundsByOwnerRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.communitygames.ListPlaygroundsByOwnerResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.communitygames.CommunityGamesClient.prototype.listPlaygroundsByOwner = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.communitygames.CommunityGames/listPlaygroundsByOwner', + request, + metadata || {}, + methodDescriptor_CommunityGames_listPlaygroundsByOwner, + callback); +}; + + +/** + * @param {!proto.web.communitygames.ListPlaygroundsByOwnerRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.communitygames.CommunityGamesPromiseClient.prototype.listPlaygroundsByOwner = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.communitygames.CommunityGames/listPlaygroundsByOwner', + request, + metadata || {}, + methodDescriptor_CommunityGames_listPlaygroundsByOwner); +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.communitygames.GetBlueprintsByIdRequest, + * !proto.web.communitygames.GetBlueprintsByIdResponse>} + */ +const methodDescriptor_CommunityGames_getBlueprintsById = new grpc.web.MethodDescriptor( + '/web.communitygames.CommunityGames/getBlueprintsById', + grpc.web.MethodType.UNARY, + proto.web.communitygames.GetBlueprintsByIdRequest, + proto.web.communitygames.GetBlueprintsByIdResponse, + /** + * @param {!proto.web.communitygames.GetBlueprintsByIdRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.GetBlueprintsByIdResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.communitygames.GetBlueprintsByIdRequest, + * !proto.web.communitygames.GetBlueprintsByIdResponse>} + */ +const methodInfo_CommunityGames_getBlueprintsById = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.communitygames.GetBlueprintsByIdResponse, + /** + * @param {!proto.web.communitygames.GetBlueprintsByIdRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.GetBlueprintsByIdResponse.deserializeBinary +); + + +/** + * @param {!proto.web.communitygames.GetBlueprintsByIdRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.communitygames.GetBlueprintsByIdResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.communitygames.CommunityGamesClient.prototype.getBlueprintsById = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.communitygames.CommunityGames/getBlueprintsById', + request, + metadata || {}, + methodDescriptor_CommunityGames_getBlueprintsById, + callback); +}; + + +/** + * @param {!proto.web.communitygames.GetBlueprintsByIdRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.communitygames.CommunityGamesPromiseClient.prototype.getBlueprintsById = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.communitygames.CommunityGames/getBlueprintsById', + request, + metadata || {}, + methodDescriptor_CommunityGames_getBlueprintsById); +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.communitygames.GetScheduledBlueprintsRequest, + * !proto.web.communitygames.GetScheduledBlueprintsResponse>} + */ +const methodDescriptor_CommunityGames_getScheduledBlueprints = new grpc.web.MethodDescriptor( + '/web.communitygames.CommunityGames/getScheduledBlueprints', + grpc.web.MethodType.UNARY, + proto.web.communitygames.GetScheduledBlueprintsRequest, + proto.web.communitygames.GetScheduledBlueprintsResponse, + /** + * @param {!proto.web.communitygames.GetScheduledBlueprintsRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.GetScheduledBlueprintsResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.communitygames.GetScheduledBlueprintsRequest, + * !proto.web.communitygames.GetScheduledBlueprintsResponse>} + */ +const methodInfo_CommunityGames_getScheduledBlueprints = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.communitygames.GetScheduledBlueprintsResponse, + /** + * @param {!proto.web.communitygames.GetScheduledBlueprintsRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.GetScheduledBlueprintsResponse.deserializeBinary +); + + +/** + * @param {!proto.web.communitygames.GetScheduledBlueprintsRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.communitygames.GetScheduledBlueprintsResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.communitygames.CommunityGamesClient.prototype.getScheduledBlueprints = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.communitygames.CommunityGames/getScheduledBlueprints', + request, + metadata || {}, + methodDescriptor_CommunityGames_getScheduledBlueprints, + callback); +}; + + +/** + * @param {!proto.web.communitygames.GetScheduledBlueprintsRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.communitygames.CommunityGamesPromiseClient.prototype.getScheduledBlueprints = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.communitygames.CommunityGames/getScheduledBlueprints', + request, + metadata || {}, + methodDescriptor_CommunityGames_getScheduledBlueprints); +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.communitygames.GetConstraintsRequest, + * !proto.web.communitygames.GetConstraintsResponse>} + */ +const methodDescriptor_CommunityGames_getConstraints = new grpc.web.MethodDescriptor( + '/web.communitygames.CommunityGames/getConstraints', + grpc.web.MethodType.UNARY, + proto.web.communitygames.GetConstraintsRequest, + proto.web.communitygames.GetConstraintsResponse, + /** + * @param {!proto.web.communitygames.GetConstraintsRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.GetConstraintsResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.communitygames.GetConstraintsRequest, + * !proto.web.communitygames.GetConstraintsResponse>} + */ +const methodInfo_CommunityGames_getConstraints = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.communitygames.GetConstraintsResponse, + /** + * @param {!proto.web.communitygames.GetConstraintsRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.GetConstraintsResponse.deserializeBinary +); + + +/** + * @param {!proto.web.communitygames.GetConstraintsRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.communitygames.GetConstraintsResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.communitygames.CommunityGamesClient.prototype.getConstraints = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.communitygames.CommunityGames/getConstraints', + request, + metadata || {}, + methodDescriptor_CommunityGames_getConstraints, + callback); +}; + + +/** + * @param {!proto.web.communitygames.GetConstraintsRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.communitygames.CommunityGamesPromiseClient.prototype.getConstraints = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.communitygames.CommunityGames/getConstraints', + request, + metadata || {}, + methodDescriptor_CommunityGames_getConstraints); +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.communitygames.SharePlaygroundRequest, + * !proto.web.communitygames.SharePlaygroundResponse>} + */ +const methodDescriptor_CommunityGames_sharePlayground = new grpc.web.MethodDescriptor( + '/web.communitygames.CommunityGames/sharePlayground', + grpc.web.MethodType.UNARY, + proto.web.communitygames.SharePlaygroundRequest, + proto.web.communitygames.SharePlaygroundResponse, + /** + * @param {!proto.web.communitygames.SharePlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.SharePlaygroundResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.communitygames.SharePlaygroundRequest, + * !proto.web.communitygames.SharePlaygroundResponse>} + */ +const methodInfo_CommunityGames_sharePlayground = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.communitygames.SharePlaygroundResponse, + /** + * @param {!proto.web.communitygames.SharePlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.SharePlaygroundResponse.deserializeBinary +); + + +/** + * @param {!proto.web.communitygames.SharePlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.communitygames.SharePlaygroundResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.communitygames.CommunityGamesClient.prototype.sharePlayground = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.communitygames.CommunityGames/sharePlayground', + request, + metadata || {}, + methodDescriptor_CommunityGames_sharePlayground, + callback); +}; + + +/** + * @param {!proto.web.communitygames.SharePlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.communitygames.CommunityGamesPromiseClient.prototype.sharePlayground = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.communitygames.CommunityGames/sharePlayground', + request, + metadata || {}, + methodDescriptor_CommunityGames_sharePlayground); +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.communitygames.GetProgressionTypesRequest, + * !proto.web.communitygames.GetProgressionTypesResponse>} + */ +const methodDescriptor_CommunityGames_getProgressionTypes = new grpc.web.MethodDescriptor( + '/web.communitygames.CommunityGames/getProgressionTypes', + grpc.web.MethodType.UNARY, + proto.web.communitygames.GetProgressionTypesRequest, + proto.web.communitygames.GetProgressionTypesResponse, + /** + * @param {!proto.web.communitygames.GetProgressionTypesRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.GetProgressionTypesResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.communitygames.GetProgressionTypesRequest, + * !proto.web.communitygames.GetProgressionTypesResponse>} + */ +const methodInfo_CommunityGames_getProgressionTypes = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.communitygames.GetProgressionTypesResponse, + /** + * @param {!proto.web.communitygames.GetProgressionTypesRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.communitygames.GetProgressionTypesResponse.deserializeBinary +); + + +/** + * @param {!proto.web.communitygames.GetProgressionTypesRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.communitygames.GetProgressionTypesResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.communitygames.CommunityGamesClient.prototype.getProgressionTypes = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.communitygames.CommunityGames/getProgressionTypes', + request, + metadata || {}, + methodDescriptor_CommunityGames_getProgressionTypes, + callback); +}; + + +/** + * @param {!proto.web.communitygames.GetProgressionTypesRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.communitygames.CommunityGamesPromiseClient.prototype.getProgressionTypes = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.communitygames.CommunityGames/getProgressionTypes', + request, + metadata || {}, + methodDescriptor_CommunityGames_getProgressionTypes); +}; + + +module.exports = proto.web.communitygames; + diff --git a/src/grpc-web/proto/communitygames_pb.d.ts b/src/grpc-web/proto/communitygames_pb.d.ts new file mode 100644 index 0000000..66336db --- /dev/null +++ b/src/grpc-web/proto/communitygames_pb.d.ts @@ -0,0 +1,2235 @@ +import * as jspb from "google-protobuf" + +export class ProgressionEntry extends jspb.Message { + getProgressionmode(): string; + setProgressionmode(value: string): ProgressionEntry; + + getProgressiblesList(): Array; + setProgressiblesList(value: Array): ProgressionEntry; + clearProgressiblesList(): ProgressionEntry; + addProgressibles(value?: Mutator, index?: number): Mutator; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ProgressionEntry.AsObject; + static toObject(includeInstance: boolean, msg: ProgressionEntry): ProgressionEntry.AsObject; + static serializeBinaryToWriter(message: ProgressionEntry, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ProgressionEntry; + static deserializeBinaryFromReader(message: ProgressionEntry, reader: jspb.BinaryReader): ProgressionEntry; +} + +export namespace ProgressionEntry { + export type AsObject = { + progressionmode: string, + progressiblesList: Array, + } +} + +export class TranslationMetadata extends jspb.Message { + getKind(): string; + setKind(value: string): TranslationMetadata; + + getTranslationid(): string; + setTranslationid(value: string): TranslationMetadata; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): TranslationMetadata.AsObject; + static toObject(includeInstance: boolean, msg: TranslationMetadata): TranslationMetadata.AsObject; + static serializeBinaryToWriter(message: TranslationMetadata, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): TranslationMetadata; + static deserializeBinaryFromReader(message: TranslationMetadata, reader: jspb.BinaryReader): TranslationMetadata; +} + +export namespace TranslationMetadata { + export type AsObject = { + kind: string, + translationid: string, + } +} + +export class ResourceLocation extends jspb.Message { + getRef(): string; + setRef(value: string): ResourceLocation; + + getUrl(): string; + setUrl(value: string): ResourceLocation; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ResourceLocation.AsObject; + static toObject(includeInstance: boolean, msg: ResourceLocation): ResourceLocation.AsObject; + static serializeBinaryToWriter(message: ResourceLocation, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ResourceLocation; + static deserializeBinaryFromReader(message: ResourceLocation, reader: jspb.BinaryReader): ResourceLocation; +} + +export namespace ResourceLocation { + export type AsObject = { + ref: string, + url: string, + } +} + +export class Resource extends jspb.Message { + getLocation(): ResourceLocation | undefined; + setLocation(value?: ResourceLocation): Resource; + hasLocation(): boolean; + clearLocation(): Resource; + + getKind(): string; + setKind(value: string): Resource; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Resource.AsObject; + static toObject(includeInstance: boolean, msg: Resource): Resource.AsObject; + static serializeBinaryToWriter(message: Resource, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Resource; + static deserializeBinaryFromReader(message: Resource, reader: jspb.BinaryReader): Resource; +} + +export namespace Resource { + export type AsObject = { + location?: ResourceLocation.AsObject, + kind: string, + } +} + +export class Metadata extends jspb.Message { + getTranslationsList(): Array; + setTranslationsList(value: Array): Metadata; + clearTranslationsList(): Metadata; + addTranslations(value?: TranslationMetadata, index?: number): TranslationMetadata; + + getResourcesList(): Array; + setResourcesList(value: Array): Metadata; + clearResourcesList(): Metadata; + addResources(value?: Resource, index?: number): Resource; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Metadata.AsObject; + static toObject(includeInstance: boolean, msg: Metadata): Metadata.AsObject; + static serializeBinaryToWriter(message: Metadata, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Metadata; + static deserializeBinaryFromReader(message: Metadata, reader: jspb.BinaryReader): Metadata; +} + +export namespace Metadata { + export type AsObject = { + translationsList: Array, + resourcesList: Array, + } +} + +export class Tag extends jspb.Message { + getId(): string; + setId(value: string): Tag; + + getSortorder(): number; + setSortorder(value: number): Tag; + + getMetadata(): Metadata | undefined; + setMetadata(value?: Metadata): Tag; + hasMetadata(): boolean; + clearMetadata(): Tag; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Tag.AsObject; + static toObject(includeInstance: boolean, msg: Tag): Tag.AsObject; + static serializeBinaryToWriter(message: Tag, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Tag; + static deserializeBinaryFromReader(message: Tag, reader: jspb.BinaryReader): Tag; +} + +export namespace Tag { + export type AsObject = { + id: string, + sortorder: number, + metadata?: Metadata.AsObject, + } +} + +export class ProgressionMode extends jspb.Message { + getValue(): string; + setValue(value: string): ProgressionMode; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ProgressionMode.AsObject; + static toObject(includeInstance: boolean, msg: ProgressionMode): ProgressionMode.AsObject; + static serializeBinaryToWriter(message: ProgressionMode, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ProgressionMode; + static deserializeBinaryFromReader(message: ProgressionMode, reader: jspb.BinaryReader): ProgressionMode; +} + +export namespace ProgressionMode { + export type AsObject = { + value: string, + } +} + +export class PlaygroundResponse extends jspb.Message { + getOriginalplayground(): Playground | undefined; + setOriginalplayground(value?: Playground): PlaygroundResponse; + hasOriginalplayground(): boolean; + clearOriginalplayground(): PlaygroundResponse; + + getValidatedplayground(): Playground | undefined; + setValidatedplayground(value?: Playground): PlaygroundResponse; + hasValidatedplayground(): boolean; + clearValidatedplayground(): PlaygroundResponse; + + getTagList(): Array; + setTagList(value: Array): PlaygroundResponse; + clearTagList(): PlaygroundResponse; + addTag(value?: Tag, index?: number): Tag; + + getProgressionmode(): ProgressionMode | undefined; + setProgressionmode(value?: ProgressionMode): PlaygroundResponse; + hasProgressionmode(): boolean; + clearProgressionmode(): PlaygroundResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): PlaygroundResponse.AsObject; + static toObject(includeInstance: boolean, msg: PlaygroundResponse): PlaygroundResponse.AsObject; + static serializeBinaryToWriter(message: PlaygroundResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): PlaygroundResponse; + static deserializeBinaryFromReader(message: PlaygroundResponse, reader: jspb.BinaryReader): PlaygroundResponse; +} + +export namespace PlaygroundResponse { + export type AsObject = { + originalplayground?: Playground.AsObject, + validatedplayground?: Playground.AsObject, + tagList: Array, + progressionmode?: ProgressionMode.AsObject, + } +} + +export class MapInfo extends jspb.Message { + getMapname(): string; + setMapname(value: string): MapInfo; + + getMode(): string; + setMode(value: string): MapInfo; + + getGamesize(): number; + setGamesize(value: number): MapInfo; + + getRounds(): number; + setRounds(value: number): MapInfo; + + getMutators(): Mutator | undefined; + setMutators(value?: Mutator): MapInfo; + hasMutators(): boolean; + clearMutators(): MapInfo; + + getLocation(): string; + setLocation(value: string): MapInfo; + + getPreroundsize(): number; + setPreroundsize(value: number): MapInfo; + + getWarmupsize(): number; + setWarmupsize(value: number): MapInfo; + + getAllowedspectators(): number; + setAllowedspectators(value: number): MapInfo; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MapInfo.AsObject; + static toObject(includeInstance: boolean, msg: MapInfo): MapInfo.AsObject; + static serializeBinaryToWriter(message: MapInfo, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MapInfo; + static deserializeBinaryFromReader(message: MapInfo, reader: jspb.BinaryReader): MapInfo; +} + +export namespace MapInfo { + export type AsObject = { + mapname: string, + mode: string, + gamesize: number, + rounds: number, + mutators?: Mutator.AsObject, + location: string, + preroundsize: number, + warmupsize: number, + allowedspectators: number, + } +} + +export class MapRotation extends jspb.Message { + getMapsList(): Array; + setMapsList(value: Array): MapRotation; + clearMapsList(): MapRotation; + addMaps(value?: MapInfo, index?: number): MapInfo; + + getRotationbehavior(): RotationBehavior; + setRotationbehavior(value: RotationBehavior): MapRotation; + + getRoundbehavior(): RoundBehavior; + setRoundbehavior(value: RoundBehavior): MapRotation; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MapRotation.AsObject; + static toObject(includeInstance: boolean, msg: MapRotation): MapRotation.AsObject; + static serializeBinaryToWriter(message: MapRotation, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MapRotation; + static deserializeBinaryFromReader(message: MapRotation, reader: jspb.BinaryReader): MapRotation; +} + +export namespace MapRotation { + export type AsObject = { + mapsList: Array, + rotationbehavior: RotationBehavior, + roundbehavior: RoundBehavior, + } +} + +export class TeamStructure extends jspb.Message { + getTeamid(): number; + setTeamid(value: number): TeamStructure; + + getCapacity(): number; + setCapacity(value: number): TeamStructure; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): TeamStructure.AsObject; + static toObject(includeInstance: boolean, msg: TeamStructure): TeamStructure.AsObject; + static serializeBinaryToWriter(message: TeamStructure, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): TeamStructure; + static deserializeBinaryFromReader(message: TeamStructure, reader: jspb.BinaryReader): TeamStructure; +} + +export namespace TeamStructure { + export type AsObject = { + teamid: number, + capacity: number, + } +} + +export class InternalTeamStructure extends jspb.Message { + getTeamid(): number; + setTeamid(value: number): InternalTeamStructure; + + getCapacity(): number; + setCapacity(value: number): InternalTeamStructure; + + getCapacitytype(): CapacityType; + setCapacitytype(value: CapacityType): InternalTeamStructure; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): InternalTeamStructure.AsObject; + static toObject(includeInstance: boolean, msg: InternalTeamStructure): InternalTeamStructure.AsObject; + static serializeBinaryToWriter(message: InternalTeamStructure, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): InternalTeamStructure; + static deserializeBinaryFromReader(message: InternalTeamStructure, reader: jspb.BinaryReader): InternalTeamStructure; +} + +export namespace InternalTeamStructure { + export type AsObject = { + teamid: number, + capacity: number, + capacitytype: CapacityType, + } +} + +export class MutatorSparseFloatEntry extends jspb.Message { + getIndex(): number; + setIndex(value: number): MutatorSparseFloatEntry; + + getValue(): number; + setValue(value: number): MutatorSparseFloatEntry; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorSparseFloatEntry.AsObject; + static toObject(includeInstance: boolean, msg: MutatorSparseFloatEntry): MutatorSparseFloatEntry.AsObject; + static serializeBinaryToWriter(message: MutatorSparseFloatEntry, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorSparseFloatEntry; + static deserializeBinaryFromReader(message: MutatorSparseFloatEntry, reader: jspb.BinaryReader): MutatorSparseFloatEntry; +} + +export namespace MutatorSparseFloatEntry { + export type AsObject = { + index: number, + value: number, + } +} + +export class MutatorSparseFloat extends jspb.Message { + getDefaultvalue(): number; + setDefaultvalue(value: number): MutatorSparseFloat; + + getSize(): number; + setSize(value: number): MutatorSparseFloat; + + getSparsevaluesList(): Array; + setSparsevaluesList(value: Array): MutatorSparseFloat; + clearSparsevaluesList(): MutatorSparseFloat; + addSparsevalues(value?: MutatorSparseFloatEntry, index?: number): MutatorSparseFloatEntry; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorSparseFloat.AsObject; + static toObject(includeInstance: boolean, msg: MutatorSparseFloat): MutatorSparseFloat.AsObject; + static serializeBinaryToWriter(message: MutatorSparseFloat, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorSparseFloat; + static deserializeBinaryFromReader(message: MutatorSparseFloat, reader: jspb.BinaryReader): MutatorSparseFloat; +} + +export namespace MutatorSparseFloat { + export type AsObject = { + defaultvalue: number, + size: number, + sparsevaluesList: Array, + } +} + +export class MutatorFloat extends jspb.Message { + getValue(): number; + setValue(value: number): MutatorFloat; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorFloat.AsObject; + static toObject(includeInstance: boolean, msg: MutatorFloat): MutatorFloat.AsObject; + static serializeBinaryToWriter(message: MutatorFloat, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorFloat; + static deserializeBinaryFromReader(message: MutatorFloat, reader: jspb.BinaryReader): MutatorFloat; +} + +export namespace MutatorFloat { + export type AsObject = { + value: number, + } +} + +export class MutatorBoolean extends jspb.Message { + getBoolvalue(): boolean; + setBoolvalue(value: boolean): MutatorBoolean; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorBoolean.AsObject; + static toObject(includeInstance: boolean, msg: MutatorBoolean): MutatorBoolean.AsObject; + static serializeBinaryToWriter(message: MutatorBoolean, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorBoolean; + static deserializeBinaryFromReader(message: MutatorBoolean, reader: jspb.BinaryReader): MutatorBoolean; +} + +export namespace MutatorBoolean { + export type AsObject = { + boolvalue: boolean, + } +} + +export class MutatorString extends jspb.Message { + getStringvalue(): string; + setStringvalue(value: string): MutatorString; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorString.AsObject; + static toObject(includeInstance: boolean, msg: MutatorString): MutatorString.AsObject; + static serializeBinaryToWriter(message: MutatorString, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorString; + static deserializeBinaryFromReader(message: MutatorString, reader: jspb.BinaryReader): MutatorString; +} + +export namespace MutatorString { + export type AsObject = { + stringvalue: string, + } +} + +export class MutatorInt extends jspb.Message { + getValue(): number; + setValue(value: number): MutatorInt; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorInt.AsObject; + static toObject(includeInstance: boolean, msg: MutatorInt): MutatorInt.AsObject; + static serializeBinaryToWriter(message: MutatorInt, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorInt; + static deserializeBinaryFromReader(message: MutatorInt, reader: jspb.BinaryReader): MutatorInt; +} + +export namespace MutatorInt { + export type AsObject = { + value: number, + } +} + +export class MutatorSparseBooleanEntry extends jspb.Message { + getIndex(): number; + setIndex(value: number): MutatorSparseBooleanEntry; + + getValue(): boolean; + setValue(value: boolean): MutatorSparseBooleanEntry; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorSparseBooleanEntry.AsObject; + static toObject(includeInstance: boolean, msg: MutatorSparseBooleanEntry): MutatorSparseBooleanEntry.AsObject; + static serializeBinaryToWriter(message: MutatorSparseBooleanEntry, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorSparseBooleanEntry; + static deserializeBinaryFromReader(message: MutatorSparseBooleanEntry, reader: jspb.BinaryReader): MutatorSparseBooleanEntry; +} + +export namespace MutatorSparseBooleanEntry { + export type AsObject = { + index: number, + value: boolean, + } +} + +export class MutatorSparseBoolean extends jspb.Message { + getDefaultvalue(): boolean; + setDefaultvalue(value: boolean): MutatorSparseBoolean; + + getSize(): number; + setSize(value: number): MutatorSparseBoolean; + + getSparsevaluesList(): Array; + setSparsevaluesList(value: Array): MutatorSparseBoolean; + clearSparsevaluesList(): MutatorSparseBoolean; + addSparsevalues(value?: MutatorSparseBooleanEntry, index?: number): MutatorSparseBooleanEntry; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorSparseBoolean.AsObject; + static toObject(includeInstance: boolean, msg: MutatorSparseBoolean): MutatorSparseBoolean.AsObject; + static serializeBinaryToWriter(message: MutatorSparseBoolean, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorSparseBoolean; + static deserializeBinaryFromReader(message: MutatorSparseBoolean, reader: jspb.BinaryReader): MutatorSparseBoolean; +} + +export namespace MutatorSparseBoolean { + export type AsObject = { + defaultvalue: boolean, + size: number, + sparsevaluesList: Array, + } +} + +export class SparseIntEntity extends jspb.Message { + getValuesList(): Array; + setValuesList(value: Array): SparseIntEntity; + clearValuesList(): SparseIntEntity; + addValues(value: number, index?: number): SparseIntEntity; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): SparseIntEntity.AsObject; + static toObject(includeInstance: boolean, msg: SparseIntEntity): SparseIntEntity.AsObject; + static serializeBinaryToWriter(message: SparseIntEntity, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): SparseIntEntity; + static deserializeBinaryFromReader(message: SparseIntEntity, reader: jspb.BinaryReader): SparseIntEntity; +} + +export namespace SparseIntEntity { + export type AsObject = { + valuesList: Array, + } +} + +export class MutatorSparseIntEntry extends jspb.Message { + getIndex(): number; + setIndex(value: number): MutatorSparseIntEntry; + + getValue(): number; + setValue(value: number): MutatorSparseIntEntry; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorSparseIntEntry.AsObject; + static toObject(includeInstance: boolean, msg: MutatorSparseIntEntry): MutatorSparseIntEntry.AsObject; + static serializeBinaryToWriter(message: MutatorSparseIntEntry, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorSparseIntEntry; + static deserializeBinaryFromReader(message: MutatorSparseIntEntry, reader: jspb.BinaryReader): MutatorSparseIntEntry; +} + +export namespace MutatorSparseIntEntry { + export type AsObject = { + index: number, + value: number, + } +} + +export class MutatorSparseInt extends jspb.Message { + getDefaultvalue(): number; + setDefaultvalue(value: number): MutatorSparseInt; + + getSize(): number; + setSize(value: number): MutatorSparseInt; + + getSparsevalues(): MutatorSparseIntEntry | undefined; + setSparsevalues(value?: MutatorSparseIntEntry): MutatorSparseInt; + hasSparsevalues(): boolean; + clearSparsevalues(): MutatorSparseInt; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorSparseInt.AsObject; + static toObject(includeInstance: boolean, msg: MutatorSparseInt): MutatorSparseInt.AsObject; + static serializeBinaryToWriter(message: MutatorSparseInt, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorSparseInt; + static deserializeBinaryFromReader(message: MutatorSparseInt, reader: jspb.BinaryReader): MutatorSparseInt; +} + +export namespace MutatorSparseInt { + export type AsObject = { + defaultvalue: number, + size: number, + sparsevalues?: MutatorSparseIntEntry.AsObject, + } +} + +export class MutatorKind extends jspb.Message { + getMutatorboolean(): MutatorBoolean | undefined; + setMutatorboolean(value?: MutatorBoolean): MutatorKind; + hasMutatorboolean(): boolean; + clearMutatorboolean(): MutatorKind; + + getMutatorstring(): MutatorString | undefined; + setMutatorstring(value?: MutatorString): MutatorKind; + hasMutatorstring(): boolean; + clearMutatorstring(): MutatorKind; + + getMutatorfloat(): MutatorFloat | undefined; + setMutatorfloat(value?: MutatorFloat): MutatorKind; + hasMutatorfloat(): boolean; + clearMutatorfloat(): MutatorKind; + + getMutatorint(): MutatorInt | undefined; + setMutatorint(value?: MutatorInt): MutatorKind; + hasMutatorint(): boolean; + clearMutatorint(): MutatorKind; + + getMutatorsparseboolean(): MutatorSparseBoolean | undefined; + setMutatorsparseboolean(value?: MutatorSparseBoolean): MutatorKind; + hasMutatorsparseboolean(): boolean; + clearMutatorsparseboolean(): MutatorKind; + + getMutatorsparseint(): MutatorSparseInt | undefined; + setMutatorsparseint(value?: MutatorSparseInt): MutatorKind; + hasMutatorsparseint(): boolean; + clearMutatorsparseint(): MutatorKind; + + getMutatorsparsefloat(): MutatorSparseFloat | undefined; + setMutatorsparsefloat(value?: MutatorSparseFloat): MutatorKind; + hasMutatorsparsefloat(): boolean; + clearMutatorsparsefloat(): MutatorKind; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): MutatorKind.AsObject; + static toObject(includeInstance: boolean, msg: MutatorKind): MutatorKind.AsObject; + static serializeBinaryToWriter(message: MutatorKind, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): MutatorKind; + static deserializeBinaryFromReader(message: MutatorKind, reader: jspb.BinaryReader): MutatorKind; +} + +export namespace MutatorKind { + export type AsObject = { + mutatorboolean?: MutatorBoolean.AsObject, + mutatorstring?: MutatorString.AsObject, + mutatorfloat?: MutatorFloat.AsObject, + mutatorint?: MutatorInt.AsObject, + mutatorsparseboolean?: MutatorSparseBoolean.AsObject, + mutatorsparseint?: MutatorSparseInt.AsObject, + mutatorsparsefloat?: MutatorSparseFloat.AsObject, + } +} + +export class TeamComposition extends jspb.Message { + getTeams(): TeamStructure | undefined; + setTeams(value?: TeamStructure): TeamComposition; + hasTeams(): boolean; + clearTeams(): TeamComposition; + + getInternalteamsList(): Array; + setInternalteamsList(value: Array): TeamComposition; + clearInternalteamsList(): TeamComposition; + addInternalteams(value?: InternalTeamStructure, index?: number): InternalTeamStructure; + + getBalancingmethod(): BalancingMethod; + setBalancingmethod(value: BalancingMethod): TeamComposition; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): TeamComposition.AsObject; + static toObject(includeInstance: boolean, msg: TeamComposition): TeamComposition.AsObject; + static serializeBinaryToWriter(message: TeamComposition, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): TeamComposition; + static deserializeBinaryFromReader(message: TeamComposition, reader: jspb.BinaryReader): TeamComposition; +} + +export namespace TeamComposition { + export type AsObject = { + teams?: TeamStructure.AsObject, + internalteamsList: Array, + balancingmethod: BalancingMethod, + } +} + +export class Mutator extends jspb.Message { + getName(): string; + setName(value: string): Mutator; + + getCategory(): string; + setCategory(value: string): Mutator; + + getKind(): MutatorKind | undefined; + setKind(value?: MutatorKind): Mutator; + hasKind(): boolean; + clearKind(): Mutator; + + getId(): string; + setId(value: string): Mutator; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Mutator.AsObject; + static toObject(includeInstance: boolean, msg: Mutator): Mutator.AsObject; + static serializeBinaryToWriter(message: Mutator, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Mutator; + static deserializeBinaryFromReader(message: Mutator, reader: jspb.BinaryReader): Mutator; +} + +export namespace Mutator { + export type AsObject = { + name: string, + category: string, + kind?: MutatorKind.AsObject, + id: string, + } +} + +export class Timestamp extends jspb.Message { + getSeconds(): string; + setSeconds(value: string): Timestamp; + + getNanos(): number; + setNanos(value: number): Timestamp; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Timestamp.AsObject; + static toObject(includeInstance: boolean, msg: Timestamp): Timestamp.AsObject; + static serializeBinaryToWriter(message: Timestamp, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Timestamp; + static deserializeBinaryFromReader(message: Timestamp, reader: jspb.BinaryReader): Timestamp; +} + +export namespace Timestamp { + export type AsObject = { + seconds: string, + nanos: number, + } +} + +export class StringValue extends jspb.Message { + getValue(): string; + setValue(value: string): StringValue; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): StringValue.AsObject; + static toObject(includeInstance: boolean, msg: StringValue): StringValue.AsObject; + static serializeBinaryToWriter(message: StringValue, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): StringValue; + static deserializeBinaryFromReader(message: StringValue, reader: jspb.BinaryReader): StringValue; +} + +export namespace StringValue { + export type AsObject = { + value: string, + } +} + +export class GameServerMessage extends jspb.Message { + getKind(): string; + setKind(value: string): GameServerMessage; + + getText(): string; + setText(value: string): GameServerMessage; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GameServerMessage.AsObject; + static toObject(includeInstance: boolean, msg: GameServerMessage): GameServerMessage.AsObject; + static serializeBinaryToWriter(message: GameServerMessage, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GameServerMessage; + static deserializeBinaryFromReader(message: GameServerMessage, reader: jspb.BinaryReader): GameServerMessage; +} + +export namespace GameServerMessage { + export type AsObject = { + kind: string, + text: string, + } +} + +export class GameServerSettings extends jspb.Message { + getName(): string; + setName(value: string): GameServerSettings; + + getDescription(): StringValue | undefined; + setDescription(value?: StringValue): GameServerSettings; + hasDescription(): boolean; + clearDescription(): GameServerSettings; + + getGameservermessageList(): Array; + setGameservermessageList(value: Array): GameServerSettings; + clearGameservermessageList(): GameServerSettings; + addGameservermessage(value?: GameServerMessage, index?: number): GameServerMessage; + + getConfigname(): StringValue | undefined; + setConfigname(value?: StringValue): GameServerSettings; + hasConfigname(): boolean; + clearConfigname(): GameServerSettings; + + getConfigdescription(): StringValue | undefined; + setConfigdescription(value?: StringValue): GameServerSettings; + hasConfigdescription(): boolean; + clearConfigdescription(): GameServerSettings; + + getPhantomgamestate(): PhantomGameState; + setPhantomgamestate(value: PhantomGameState): GameServerSettings; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GameServerSettings.AsObject; + static toObject(includeInstance: boolean, msg: GameServerSettings): GameServerSettings.AsObject; + static serializeBinaryToWriter(message: GameServerSettings, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GameServerSettings; + static deserializeBinaryFromReader(message: GameServerSettings, reader: jspb.BinaryReader): GameServerSettings; +} + +export namespace GameServerSettings { + export type AsObject = { + name: string, + description?: StringValue.AsObject, + gameservermessageList: Array, + configname?: StringValue.AsObject, + configdescription?: StringValue.AsObject, + phantomgamestate: PhantomGameState, + } +} + +export class PlayerInfo extends jspb.Message { + getNucleusid(): string; + setNucleusid(value: string): PlayerInfo; + + getPersonaid(): string; + setPersonaid(value: string): PlayerInfo; + + getPlatformid(): Platform; + setPlatformid(value: Platform): PlayerInfo; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): PlayerInfo.AsObject; + static toObject(includeInstance: boolean, msg: PlayerInfo): PlayerInfo.AsObject; + static serializeBinaryToWriter(message: PlayerInfo, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): PlayerInfo; + static deserializeBinaryFromReader(message: PlayerInfo, reader: jspb.BinaryReader): PlayerInfo; +} + +export namespace PlayerInfo { + export type AsObject = { + nucleusid: string, + personaid: string, + platformid: Platform, + } +} + +export class PlatformRestrictions extends jspb.Message { + getPlatformsList(): Array; + setPlatformsList(value: Array): PlatformRestrictions; + clearPlatformsList(): PlatformRestrictions; + addPlatforms(value: Platform, index?: number): PlatformRestrictions; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): PlatformRestrictions.AsObject; + static toObject(includeInstance: boolean, msg: PlatformRestrictions): PlatformRestrictions.AsObject; + static serializeBinaryToWriter(message: PlatformRestrictions, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): PlatformRestrictions; + static deserializeBinaryFromReader(message: PlatformRestrictions, reader: jspb.BinaryReader): PlatformRestrictions; +} + +export namespace PlatformRestrictions { + export type AsObject = { + platformsList: Array, + } +} + +export class InputMethodResrictions extends jspb.Message { + getInputmethodsList(): Array; + setInputmethodsList(value: Array): InputMethodResrictions; + clearInputmethodsList(): InputMethodResrictions; + addInputmethods(value: InputMethods, index?: number): InputMethodResrictions; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): InputMethodResrictions.AsObject; + static toObject(includeInstance: boolean, msg: InputMethodResrictions): InputMethodResrictions.AsObject; + static serializeBinaryToWriter(message: InputMethodResrictions, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): InputMethodResrictions; + static deserializeBinaryFromReader(message: InputMethodResrictions, reader: jspb.BinaryReader): InputMethodResrictions; +} + +export namespace InputMethodResrictions { + export type AsObject = { + inputmethodsList: Array, + } +} + +export class Restrictions extends jspb.Message { + getPlatformrestrictions(): PlatformRestrictions | undefined; + setPlatformrestrictions(value?: PlatformRestrictions): Restrictions; + hasPlatformrestrictions(): boolean; + clearPlatformrestrictions(): Restrictions; + + getInputmethodresctrictions(): InputMethodResrictions | undefined; + setInputmethodresctrictions(value?: InputMethodResrictions): Restrictions; + hasInputmethodresctrictions(): boolean; + clearInputmethodresctrictions(): Restrictions; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Restrictions.AsObject; + static toObject(includeInstance: boolean, msg: Restrictions): Restrictions.AsObject; + static serializeBinaryToWriter(message: Restrictions, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Restrictions; + static deserializeBinaryFromReader(message: Restrictions, reader: jspb.BinaryReader): Restrictions; +} + +export namespace Restrictions { + export type AsObject = { + platformrestrictions?: PlatformRestrictions.AsObject, + inputmethodresctrictions?: InputMethodResrictions.AsObject, + } +} + +export class Compressed extends jspb.Message { + getCompiledmodrules(): Uint8Array | string; + getCompiledmodrules_asU8(): Uint8Array; + getCompiledmodrules_asB64(): string; + setCompiledmodrules(value: Uint8Array | string): Compressed; + + getRulesversion(): number; + setRulesversion(value: number): Compressed; + + getInflatedsize(): number; + setInflatedsize(value: number): Compressed; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Compressed.AsObject; + static toObject(includeInstance: boolean, msg: Compressed): Compressed.AsObject; + static serializeBinaryToWriter(message: Compressed, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Compressed; + static deserializeBinaryFromReader(message: Compressed, reader: jspb.BinaryReader): Compressed; +} + +export namespace Compressed { + export type AsObject = { + compiledmodrules: Uint8Array | string, + rulesversion: number, + inflatedsize: number, + } +} + +export class Uncompressed extends jspb.Message { + getCompiledmodrules(): Uint8Array | string; + getCompiledmodrules_asU8(): Uint8Array; + getCompiledmodrules_asB64(): string; + setCompiledmodrules(value: Uint8Array | string): Uncompressed; + + getRulesversion(): number; + setRulesversion(value: number): Uncompressed; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Uncompressed.AsObject; + static toObject(includeInstance: boolean, msg: Uncompressed): Uncompressed.AsObject; + static serializeBinaryToWriter(message: Uncompressed, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Uncompressed; + static deserializeBinaryFromReader(message: Uncompressed, reader: jspb.BinaryReader): Uncompressed; +} + +export namespace Uncompressed { + export type AsObject = { + compiledmodrules: Uint8Array | string, + rulesversion: number, + } +} + +export class CompiledRules extends jspb.Message { + getUncompressed(): Uncompressed | undefined; + setUncompressed(value?: Uncompressed): CompiledRules; + hasUncompressed(): boolean; + clearUncompressed(): CompiledRules; + + getCompressed(): Compressed | undefined; + setCompressed(value?: Compressed): CompiledRules; + hasCompressed(): boolean; + clearCompressed(): CompiledRules; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): CompiledRules.AsObject; + static toObject(includeInstance: boolean, msg: CompiledRules): CompiledRules.AsObject; + static serializeBinaryToWriter(message: CompiledRules, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): CompiledRules; + static deserializeBinaryFromReader(message: CompiledRules, reader: jspb.BinaryReader): CompiledRules; +} + +export namespace CompiledRules { + export type AsObject = { + uncompressed?: Uncompressed.AsObject, + compressed?: Compressed.AsObject, + } +} + +export class CompatibleModRules extends jspb.Message { + getRules(): Uint8Array | string; + getRules_asU8(): Uint8Array; + getRules_asB64(): string; + setRules(value: Uint8Array | string): CompatibleModRules; + + getRulesversion(): number; + setRulesversion(value: number): CompatibleModRules; + + getCompiled(): CompiledRules | undefined; + setCompiled(value?: CompiledRules): CompatibleModRules; + hasCompiled(): boolean; + clearCompiled(): CompatibleModRules; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): CompatibleModRules.AsObject; + static toObject(includeInstance: boolean, msg: CompatibleModRules): CompatibleModRules.AsObject; + static serializeBinaryToWriter(message: CompatibleModRules, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): CompatibleModRules; + static deserializeBinaryFromReader(message: CompatibleModRules, reader: jspb.BinaryReader): CompatibleModRules; +} + +export namespace CompatibleModRules { + export type AsObject = { + rules: Uint8Array | string, + rulesversion: number, + compiled?: CompiledRules.AsObject, + } +} + +export class InCompatibleModRules extends jspb.Message { + getRules(): Uint8Array | string; + getRules_asU8(): Uint8Array; + getRules_asB64(): string; + setRules(value: Uint8Array | string): InCompatibleModRules; + + getRulesversion(): number; + setRulesversion(value: number): InCompatibleModRules; + + getBlueprintrulesversion(): number; + setBlueprintrulesversion(value: number): InCompatibleModRules; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): InCompatibleModRules.AsObject; + static toObject(includeInstance: boolean, msg: InCompatibleModRules): InCompatibleModRules.AsObject; + static serializeBinaryToWriter(message: InCompatibleModRules, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): InCompatibleModRules; + static deserializeBinaryFromReader(message: InCompatibleModRules, reader: jspb.BinaryReader): InCompatibleModRules; +} + +export namespace InCompatibleModRules { + export type AsObject = { + rules: Uint8Array | string, + rulesversion: number, + blueprintrulesversion: number, + } +} + +export class OriginalModRules extends jspb.Message { + getCompatiblerules(): CompatibleModRules | undefined; + setCompatiblerules(value?: CompatibleModRules): OriginalModRules; + hasCompatiblerules(): boolean; + clearCompatiblerules(): OriginalModRules; + + getIncompatiblerules(): InCompatibleModRules | undefined; + setIncompatiblerules(value?: InCompatibleModRules): OriginalModRules; + hasIncompatiblerules(): boolean; + clearIncompatiblerules(): OriginalModRules; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): OriginalModRules.AsObject; + static toObject(includeInstance: boolean, msg: OriginalModRules): OriginalModRules.AsObject; + static serializeBinaryToWriter(message: OriginalModRules, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): OriginalModRules; + static deserializeBinaryFromReader(message: OriginalModRules, reader: jspb.BinaryReader): OriginalModRules; +} + +export namespace OriginalModRules { + export type AsObject = { + compatiblerules?: CompatibleModRules.AsObject, + incompatiblerules?: InCompatibleModRules.AsObject, + } +} + +export class AssetCategoryTagBooleanOverride extends jspb.Message { + getAssetcategorytagsList(): Array; + setAssetcategorytagsList(value: Array): AssetCategoryTagBooleanOverride; + clearAssetcategorytagsList(): AssetCategoryTagBooleanOverride; + addAssetcategorytags(value: string, index?: number): AssetCategoryTagBooleanOverride; + + getValue(): boolean; + setValue(value: boolean): AssetCategoryTagBooleanOverride; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AssetCategoryTagBooleanOverride.AsObject; + static toObject(includeInstance: boolean, msg: AssetCategoryTagBooleanOverride): AssetCategoryTagBooleanOverride.AsObject; + static serializeBinaryToWriter(message: AssetCategoryTagBooleanOverride, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AssetCategoryTagBooleanOverride; + static deserializeBinaryFromReader(message: AssetCategoryTagBooleanOverride, reader: jspb.BinaryReader): AssetCategoryTagBooleanOverride; +} + +export namespace AssetCategoryTagBooleanOverride { + export type AsObject = { + assetcategorytagsList: Array, + value: boolean, + } +} + +export class AssetCategoryTagBooleanTeamOverride extends jspb.Message { + getAssetcategorytagsList(): Array; + setAssetcategorytagsList(value: Array): AssetCategoryTagBooleanTeamOverride; + clearAssetcategorytagsList(): AssetCategoryTagBooleanTeamOverride; + addAssetcategorytags(value: string, index?: number): AssetCategoryTagBooleanTeamOverride; + + getValue(): boolean; + setValue(value: boolean): AssetCategoryTagBooleanTeamOverride; + + getTeamid(): number; + setTeamid(value: number): AssetCategoryTagBooleanTeamOverride; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AssetCategoryTagBooleanTeamOverride.AsObject; + static toObject(includeInstance: boolean, msg: AssetCategoryTagBooleanTeamOverride): AssetCategoryTagBooleanTeamOverride.AsObject; + static serializeBinaryToWriter(message: AssetCategoryTagBooleanTeamOverride, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AssetCategoryTagBooleanTeamOverride; + static deserializeBinaryFromReader(message: AssetCategoryTagBooleanTeamOverride, reader: jspb.BinaryReader): AssetCategoryTagBooleanTeamOverride; +} + +export namespace AssetCategoryTagBooleanTeamOverride { + export type AsObject = { + assetcategorytagsList: Array, + value: boolean, + teamid: number, + } +} + +export class AssetCategoryBoolean extends jspb.Message { + getDefaultvalue(): boolean; + setDefaultvalue(value: boolean): AssetCategoryBoolean; + + getOverrides(): AssetCategoryTagBooleanOverride | undefined; + setOverrides(value?: AssetCategoryTagBooleanOverride): AssetCategoryBoolean; + hasOverrides(): boolean; + clearOverrides(): AssetCategoryBoolean; + + getTeamoverridesList(): Array; + setTeamoverridesList(value: Array): AssetCategoryBoolean; + clearTeamoverridesList(): AssetCategoryBoolean; + addTeamoverrides(value?: AssetCategoryTagBooleanTeamOverride, index?: number): AssetCategoryTagBooleanTeamOverride; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AssetCategoryBoolean.AsObject; + static toObject(includeInstance: boolean, msg: AssetCategoryBoolean): AssetCategoryBoolean.AsObject; + static serializeBinaryToWriter(message: AssetCategoryBoolean, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AssetCategoryBoolean; + static deserializeBinaryFromReader(message: AssetCategoryBoolean, reader: jspb.BinaryReader): AssetCategoryBoolean; +} + +export namespace AssetCategoryBoolean { + export type AsObject = { + defaultvalue: boolean, + overrides?: AssetCategoryTagBooleanOverride.AsObject, + teamoverridesList: Array, + } +} + +export class AssetCategory extends jspb.Message { + getTagid(): string; + setTagid(value: string): AssetCategory; + + getBoolean(): AssetCategoryBoolean | undefined; + setBoolean(value?: AssetCategoryBoolean): AssetCategory; + hasBoolean(): boolean; + clearBoolean(): AssetCategory; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AssetCategory.AsObject; + static toObject(includeInstance: boolean, msg: AssetCategory): AssetCategory.AsObject; + static serializeBinaryToWriter(message: AssetCategory, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AssetCategory; + static deserializeBinaryFromReader(message: AssetCategory, reader: jspb.BinaryReader): AssetCategory; +} + +export namespace AssetCategory { + export type AsObject = { + tagid: string, + pb_boolean?: AssetCategoryBoolean.AsObject, + } +} + +export class Playground extends jspb.Message { + getPlaygroundid(): string; + setPlaygroundid(value: string): Playground; + + getBlueprinttype(): string; + setBlueprinttype(value: string): Playground; + + getName(): string; + setName(value: string): Playground; + + getDescription(): string; + setDescription(value: string): Playground; + + getMutatorsList(): Array; + setMutatorsList(value: Array): Playground; + clearMutatorsList(): Playground; + addMutators(value?: Mutator, index?: number): Mutator; + + getMaprotation(): MapRotation | undefined; + setMaprotation(value?: MapRotation): Playground; + hasMaprotation(): boolean; + clearMaprotation(): Playground; + + getState(): State; + setState(value: State): Playground; + + getChecksum(): string; + setChecksum(value: string): Playground; + + getSecret(): string; + setSecret(value: string): Playground; + + getCreatedat(): Timestamp | undefined; + setCreatedat(value?: Timestamp): Playground; + hasCreatedat(): boolean; + clearCreatedat(): Playground; + + getUpdatedat(): Timestamp | undefined; + setUpdatedat(value?: Timestamp): Playground; + hasUpdatedat(): boolean; + clearUpdatedat(): Playground; + + getServersettings(): GameServerSettings | undefined; + setServersettings(value?: GameServerSettings): Playground; + hasServersettings(): boolean; + clearServersettings(): Playground; + + getOwner(): PlayerInfo | undefined; + setOwner(value?: PlayerInfo): Playground; + hasOwner(): boolean; + clearOwner(): Playground; + + getRestrictions(): Restrictions | undefined; + setRestrictions(value?: Restrictions): Playground; + hasRestrictions(): boolean; + clearRestrictions(): Playground; + + getModrules(): OriginalModRules | undefined; + setModrules(value?: OriginalModRules): Playground; + hasModrules(): boolean; + clearModrules(): Playground; + + getAssetcategoriesList(): Array; + setAssetcategoriesList(value: Array): Playground; + clearAssetcategoriesList(): Playground; + addAssetcategories(value?: AssetCategory, index?: number): AssetCategory; + + getTeamcomposition(): TeamComposition | undefined; + setTeamcomposition(value?: TeamComposition): Playground; + hasTeamcomposition(): boolean; + clearTeamcomposition(): Playground; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Playground.AsObject; + static toObject(includeInstance: boolean, msg: Playground): Playground.AsObject; + static serializeBinaryToWriter(message: Playground, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Playground; + static deserializeBinaryFromReader(message: Playground, reader: jspb.BinaryReader): Playground; +} + +export namespace Playground { + export type AsObject = { + playgroundid: string, + blueprinttype: string, + name: string, + description: string, + mutatorsList: Array, + maprotation?: MapRotation.AsObject, + state: State, + checksum: string, + secret: string, + createdat?: Timestamp.AsObject, + updatedat?: Timestamp.AsObject, + serversettings?: GameServerSettings.AsObject, + owner?: PlayerInfo.AsObject, + restrictions?: Restrictions.AsObject, + modrules?: OriginalModRules.AsObject, + assetcategoriesList: Array, + teamcomposition?: TeamComposition.AsObject, + } +} + +export class ListPlaygroundsByOwnerRequest extends jspb.Message { + getBlueprinttype(): string; + setBlueprinttype(value: string): ListPlaygroundsByOwnerRequest; + + getProtocolversion(): string; + setProtocolversion(value: string): ListPlaygroundsByOwnerRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ListPlaygroundsByOwnerRequest.AsObject; + static toObject(includeInstance: boolean, msg: ListPlaygroundsByOwnerRequest): ListPlaygroundsByOwnerRequest.AsObject; + static serializeBinaryToWriter(message: ListPlaygroundsByOwnerRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ListPlaygroundsByOwnerRequest; + static deserializeBinaryFromReader(message: ListPlaygroundsByOwnerRequest, reader: jspb.BinaryReader): ListPlaygroundsByOwnerRequest; +} + +export namespace ListPlaygroundsByOwnerRequest { + export type AsObject = { + blueprinttype: string, + protocolversion: string, + } +} + +export class GetConstraintsRequest extends jspb.Message { + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetConstraintsRequest.AsObject; + static toObject(includeInstance: boolean, msg: GetConstraintsRequest): GetConstraintsRequest.AsObject; + static serializeBinaryToWriter(message: GetConstraintsRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetConstraintsRequest; + static deserializeBinaryFromReader(message: GetConstraintsRequest, reader: jspb.BinaryReader): GetConstraintsRequest; +} + +export namespace GetConstraintsRequest { + export type AsObject = { + } +} + +export class GetBlueprintsByIdRequest extends jspb.Message { + getBlueprintidsList(): Array; + setBlueprintidsList(value: Array): GetBlueprintsByIdRequest; + clearBlueprintidsList(): GetBlueprintsByIdRequest; + addBlueprintids(value: string, index?: number): GetBlueprintsByIdRequest; + + getIncludefieldsList(): Array; + setIncludefieldsList(value: Array): GetBlueprintsByIdRequest; + clearIncludefieldsList(): GetBlueprintsByIdRequest; + addIncludefields(value: IncludeFields, index?: number): GetBlueprintsByIdRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetBlueprintsByIdRequest.AsObject; + static toObject(includeInstance: boolean, msg: GetBlueprintsByIdRequest): GetBlueprintsByIdRequest.AsObject; + static serializeBinaryToWriter(message: GetBlueprintsByIdRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetBlueprintsByIdRequest; + static deserializeBinaryFromReader(message: GetBlueprintsByIdRequest, reader: jspb.BinaryReader): GetBlueprintsByIdRequest; +} + +export namespace GetBlueprintsByIdRequest { + export type AsObject = { + blueprintidsList: Array, + includefieldsList: Array, + } +} + +export class GlobalConstraints extends jspb.Message { + getMaxplaygroundsperplayer(): number; + setMaxplaygroundsperplayer(value: number): GlobalConstraints; + + getMaxgameserversperplayer(): number; + setMaxgameserversperplayer(value: number): GlobalConstraints; + + getMaxfollowedhostslistsize(): number; + setMaxfollowedhostslistsize(value: number): GlobalConstraints; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GlobalConstraints.AsObject; + static toObject(includeInstance: boolean, msg: GlobalConstraints): GlobalConstraints.AsObject; + static serializeBinaryToWriter(message: GlobalConstraints, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GlobalConstraints; + static deserializeBinaryFromReader(message: GlobalConstraints, reader: jspb.BinaryReader): GlobalConstraints; +} + +export namespace GlobalConstraints { + export type AsObject = { + maxplaygroundsperplayer: number, + maxgameserversperplayer: number, + maxfollowedhostslistsize: number, + } +} + +export class IntRange extends jspb.Message { + getMinvalue(): number; + setMinvalue(value: number): IntRange; + + getMaxvalue(): number; + setMaxvalue(value: number): IntRange; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): IntRange.AsObject; + static toObject(includeInstance: boolean, msg: IntRange): IntRange.AsObject; + static serializeBinaryToWriter(message: IntRange, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): IntRange; + static deserializeBinaryFromReader(message: IntRange, reader: jspb.BinaryReader): IntRange; +} + +export namespace IntRange { + export type AsObject = { + minvalue: number, + maxvalue: number, + } +} + +export class AvailableIntValues extends jspb.Message { + getRange(): IntRange | undefined; + setRange(value?: IntRange): AvailableIntValues; + hasRange(): boolean; + clearRange(): AvailableIntValues; + + getSparsevalues(): SparseIntEntity | undefined; + setSparsevalues(value?: SparseIntEntity): AvailableIntValues; + hasSparsevalues(): boolean; + clearSparsevalues(): AvailableIntValues; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AvailableIntValues.AsObject; + static toObject(includeInstance: boolean, msg: AvailableIntValues): AvailableIntValues.AsObject; + static serializeBinaryToWriter(message: AvailableIntValues, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AvailableIntValues; + static deserializeBinaryFromReader(message: AvailableIntValues, reader: jspb.BinaryReader): AvailableIntValues; +} + +export namespace AvailableIntValues { + export type AsObject = { + range?: IntRange.AsObject, + sparsevalues?: SparseIntEntity.AsObject, + } +} + +export class AvailableIntValue extends jspb.Message { + getDefaultvalue(): number; + setDefaultvalue(value: number): AvailableIntValue; + + getAvailablevalues(): AvailableIntValues | undefined; + setAvailablevalues(value?: AvailableIntValues): AvailableIntValue; + hasAvailablevalues(): boolean; + clearAvailablevalues(): AvailableIntValue; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AvailableIntValue.AsObject; + static toObject(includeInstance: boolean, msg: AvailableIntValue): AvailableIntValue.AsObject; + static serializeBinaryToWriter(message: AvailableIntValue, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AvailableIntValue; + static deserializeBinaryFromReader(message: AvailableIntValue, reader: jspb.BinaryReader): AvailableIntValue; +} + +export namespace AvailableIntValue { + export type AsObject = { + defaultvalue: number, + availablevalues?: AvailableIntValues.AsObject, + } +} + +export class AvailableMutator extends jspb.Message { + getName(): string; + setName(value: string): AvailableMutator; + + getCategory(): string; + setCategory(value: string): AvailableMutator; + + getMetadata(): Metadata | undefined; + setMetadata(value?: Metadata): AvailableMutator; + hasMetadata(): boolean; + clearMetadata(): AvailableMutator; + + getId(): string; + setId(value: string): AvailableMutator; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AvailableMutator.AsObject; + static toObject(includeInstance: boolean, msg: AvailableMutator): AvailableMutator.AsObject; + static serializeBinaryToWriter(message: AvailableMutator, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AvailableMutator; + static deserializeBinaryFromReader(message: AvailableMutator, reader: jspb.BinaryReader): AvailableMutator; +} + +export namespace AvailableMutator { + export type AsObject = { + name: string, + category: string, + metadata?: Metadata.AsObject, + id: string, + } +} + +export class AvailableMapEntry extends jspb.Message { + getLevelname(): string; + setLevelname(value: string): AvailableMapEntry; + + getGamemode(): string; + setGamemode(value: string): AvailableMapEntry; + + getLevellocation(): string; + setLevellocation(value: string): AvailableMapEntry; + + getGamesize(): AvailableIntValue | undefined; + setGamesize(value?: AvailableIntValue): AvailableMapEntry; + hasGamesize(): boolean; + clearGamesize(): AvailableMapEntry; + + getRounds(): AvailableIntValue | undefined; + setRounds(value?: AvailableIntValue): AvailableMapEntry; + hasRounds(): boolean; + clearRounds(): AvailableMapEntry; + + getPreroundsize(): AvailableIntValue | undefined; + setPreroundsize(value?: AvailableIntValue): AvailableMapEntry; + hasPreroundsize(): boolean; + clearPreroundsize(): AvailableMapEntry; + + getWarmupsize(): AvailableIntValue | undefined; + setWarmupsize(value?: AvailableIntValue): AvailableMapEntry; + hasWarmupsize(): boolean; + clearWarmupsize(): AvailableMapEntry; + + getAllowedspectators(): AvailableIntValue | undefined; + setAllowedspectators(value?: AvailableIntValue): AvailableMapEntry; + hasAllowedspectators(): boolean; + clearAllowedspectators(): AvailableMapEntry; + + getMutatorsList(): Array; + setMutatorsList(value: Array): AvailableMapEntry; + clearMutatorsList(): AvailableMapEntry; + addMutators(value?: AvailableMutator, index?: number): AvailableMutator; + + getMetadataList(): Array; + setMetadataList(value: Array): AvailableMapEntry; + clearMetadataList(): AvailableMapEntry; + addMetadata(value?: Metadata, index?: number): Metadata; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AvailableMapEntry.AsObject; + static toObject(includeInstance: boolean, msg: AvailableMapEntry): AvailableMapEntry.AsObject; + static serializeBinaryToWriter(message: AvailableMapEntry, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AvailableMapEntry; + static deserializeBinaryFromReader(message: AvailableMapEntry, reader: jspb.BinaryReader): AvailableMapEntry; +} + +export namespace AvailableMapEntry { + export type AsObject = { + levelname: string, + gamemode: string, + levellocation: string, + gamesize?: AvailableIntValue.AsObject, + rounds?: AvailableIntValue.AsObject, + preroundsize?: AvailableIntValue.AsObject, + warmupsize?: AvailableIntValue.AsObject, + allowedspectators?: AvailableIntValue.AsObject, + mutatorsList: Array, + metadataList: Array, + } +} + +export class AvailableTag extends jspb.Message { + getId(): string; + setId(value: string): AvailableTag; + + getMetadata(): Metadata | undefined; + setMetadata(value?: Metadata): AvailableTag; + hasMetadata(): boolean; + clearMetadata(): AvailableTag; + + getCategory(): Category; + setCategory(value: Category): AvailableTag; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AvailableTag.AsObject; + static toObject(includeInstance: boolean, msg: AvailableTag): AvailableTag.AsObject; + static serializeBinaryToWriter(message: AvailableTag, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AvailableTag; + static deserializeBinaryFromReader(message: AvailableTag, reader: jspb.BinaryReader): AvailableTag; +} + +export namespace AvailableTag { + export type AsObject = { + id: string, + metadata?: Metadata.AsObject, + category: Category, + } +} + +export class AvailableAssetCategoryTag extends jspb.Message { + getTagid(): string; + setTagid(value: string): AvailableAssetCategoryTag; + + getName(): string; + setName(value: string): AvailableAssetCategoryTag; + + getChildrentagsList(): Array; + setChildrentagsList(value: Array): AvailableAssetCategoryTag; + clearChildrentagsList(): AvailableAssetCategoryTag; + addChildrentags(value: string, index?: number): AvailableAssetCategoryTag; + + getMetadata(): Metadata | undefined; + setMetadata(value?: Metadata): AvailableAssetCategoryTag; + hasMetadata(): boolean; + clearMetadata(): AvailableAssetCategoryTag; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AvailableAssetCategoryTag.AsObject; + static toObject(includeInstance: boolean, msg: AvailableAssetCategoryTag): AvailableAssetCategoryTag.AsObject; + static serializeBinaryToWriter(message: AvailableAssetCategoryTag, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AvailableAssetCategoryTag; + static deserializeBinaryFromReader(message: AvailableAssetCategoryTag, reader: jspb.BinaryReader): AvailableAssetCategoryTag; +} + +export namespace AvailableAssetCategoryTag { + export type AsObject = { + tagid: string, + name: string, + childrentagsList: Array, + metadata?: Metadata.AsObject, + } +} + +export class AvailableAssetCategories extends jspb.Message { + getRoottagsList(): Array; + setRoottagsList(value: Array): AvailableAssetCategories; + clearRoottagsList(): AvailableAssetCategories; + addRoottags(value?: AvailableAssetCategoryTag, index?: number): AvailableAssetCategoryTag; + + getTagsList(): Array; + setTagsList(value: Array): AvailableAssetCategories; + clearTagsList(): AvailableAssetCategories; + addTags(value?: AvailableAssetCategoryTag, index?: number): AvailableAssetCategoryTag; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AvailableAssetCategories.AsObject; + static toObject(includeInstance: boolean, msg: AvailableAssetCategories): AvailableAssetCategories.AsObject; + static serializeBinaryToWriter(message: AvailableAssetCategories, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AvailableAssetCategories; + static deserializeBinaryFromReader(message: AvailableAssetCategories, reader: jspb.BinaryReader): AvailableAssetCategories; +} + +export namespace AvailableAssetCategories { + export type AsObject = { + roottagsList: Array, + tagsList: Array, + } +} + +export class PlaygroundConstraints extends jspb.Message { + getMaxnamesize(): number; + setMaxnamesize(value: number): PlaygroundConstraints; + + getMaxdescriptionsize(): number; + setMaxdescriptionsize(value: number): PlaygroundConstraints; + + getMaxsecretsize(): number; + setMaxsecretsize(value: number): PlaygroundConstraints; + + getMaxmapsinrotation(): number; + setMaxmapsinrotation(value: number): PlaygroundConstraints; + + getMaxmutators(): number; + setMaxmutators(value: number): PlaygroundConstraints; + + getMaxconfignamesize(): number; + setMaxconfignamesize(value: number): PlaygroundConstraints; + + getMaxconfigdescriptionsize(): number; + setMaxconfigdescriptionsize(value: number): PlaygroundConstraints; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): PlaygroundConstraints.AsObject; + static toObject(includeInstance: boolean, msg: PlaygroundConstraints): PlaygroundConstraints.AsObject; + static serializeBinaryToWriter(message: PlaygroundConstraints, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): PlaygroundConstraints; + static deserializeBinaryFromReader(message: PlaygroundConstraints, reader: jspb.BinaryReader): PlaygroundConstraints; +} + +export namespace PlaygroundConstraints { + export type AsObject = { + maxnamesize: number, + maxdescriptionsize: number, + maxsecretsize: number, + maxmapsinrotation: number, + maxmutators: number, + maxconfignamesize: number, + maxconfigdescriptionsize: number, + } +} + +export class ModRulesDefinition extends jspb.Message { + getRulesversion(): number; + setRulesversion(value: number): ModRulesDefinition; + + getModbuilder(): Uint8Array | string; + getModbuilder_asU8(): Uint8Array; + getModbuilder_asB64(): string; + setModbuilder(value: Uint8Array | string): ModRulesDefinition; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ModRulesDefinition.AsObject; + static toObject(includeInstance: boolean, msg: ModRulesDefinition): ModRulesDefinition.AsObject; + static serializeBinaryToWriter(message: ModRulesDefinition, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ModRulesDefinition; + static deserializeBinaryFromReader(message: ModRulesDefinition, reader: jspb.BinaryReader): ModRulesDefinition; +} + +export namespace ModRulesDefinition { + export type AsObject = { + rulesversion: number, + modbuilder: Uint8Array | string, + } +} + +export class AvailableGameData extends jspb.Message { + getMutatorsList(): Array; + setMutatorsList(value: Array): AvailableGameData; + clearMutatorsList(): AvailableGameData; + addMutators(value?: AvailableMutator, index?: number): AvailableMutator; + + getMapsList(): Array; + setMapsList(value: Array): AvailableGameData; + clearMapsList(): AvailableGameData; + addMaps(value?: AvailableMapEntry, index?: number): AvailableMapEntry; + + getModrules(): ModRulesDefinition | undefined; + setModrules(value?: ModRulesDefinition): AvailableGameData; + hasModrules(): boolean; + clearModrules(): AvailableGameData; + + getAssetcategories(): AvailableAssetCategories | undefined; + setAssetcategories(value?: AvailableAssetCategories): AvailableGameData; + hasAssetcategories(): boolean; + clearAssetcategories(): AvailableGameData; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AvailableGameData.AsObject; + static toObject(includeInstance: boolean, msg: AvailableGameData): AvailableGameData.AsObject; + static serializeBinaryToWriter(message: AvailableGameData, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AvailableGameData; + static deserializeBinaryFromReader(message: AvailableGameData, reader: jspb.BinaryReader): AvailableGameData; +} + +export namespace AvailableGameData { + export type AsObject = { + mutatorsList: Array, + mapsList: Array, + modrules?: ModRulesDefinition.AsObject, + assetcategories?: AvailableAssetCategories.AsObject, + } +} + +export class Blueprint extends jspb.Message { + getBlueprinttype(): string; + setBlueprinttype(value: string): Blueprint; + + getName(): string; + setName(value: string): Blueprint; + + getAvailablegamedata(): AvailableGameData | undefined; + setAvailablegamedata(value?: AvailableGameData): Blueprint; + hasAvailablegamedata(): boolean; + clearAvailablegamedata(): Blueprint; + + getMetadata(): Metadata | undefined; + setMetadata(value?: Metadata): Blueprint; + hasMetadata(): boolean; + clearMetadata(): Blueprint; + + getCustomdata(): Uint8Array | string; + getCustomdata_asU8(): Uint8Array; + getCustomdata_asB64(): string; + setCustomdata(value: Uint8Array | string): Blueprint; + + getPlaygroundconstraints(): PlaygroundConstraints | undefined; + setPlaygroundconstraints(value?: PlaygroundConstraints): Blueprint; + hasPlaygroundconstraints(): boolean; + clearPlaygroundconstraints(): Blueprint; + + getAvailabletagsList(): Array; + setAvailabletagsList(value: Array): Blueprint; + clearAvailabletagsList(): Blueprint; + addAvailabletags(value?: AvailableTag, index?: number): AvailableTag; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Blueprint.AsObject; + static toObject(includeInstance: boolean, msg: Blueprint): Blueprint.AsObject; + static serializeBinaryToWriter(message: Blueprint, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Blueprint; + static deserializeBinaryFromReader(message: Blueprint, reader: jspb.BinaryReader): Blueprint; +} + +export namespace Blueprint { + export type AsObject = { + blueprinttype: string, + name: string, + availablegamedata?: AvailableGameData.AsObject, + metadata?: Metadata.AsObject, + customdata: Uint8Array | string, + playgroundconstraints?: PlaygroundConstraints.AsObject, + availabletagsList: Array, + } +} + +export class ShortCode extends jspb.Message { + getCode(): string; + setCode(value: string): ShortCode; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ShortCode.AsObject; + static toObject(includeInstance: boolean, msg: ShortCode): ShortCode.AsObject; + static serializeBinaryToWriter(message: ShortCode, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ShortCode; + static deserializeBinaryFromReader(message: ShortCode, reader: jspb.BinaryReader): ShortCode; +} + +export namespace ShortCode { + export type AsObject = { + code: string, + } +} + +export class GetProgressionTypesRequest extends jspb.Message { + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetProgressionTypesRequest.AsObject; + static toObject(includeInstance: boolean, msg: GetProgressionTypesRequest): GetProgressionTypesRequest.AsObject; + static serializeBinaryToWriter(message: GetProgressionTypesRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetProgressionTypesRequest; + static deserializeBinaryFromReader(message: GetProgressionTypesRequest, reader: jspb.BinaryReader): GetProgressionTypesRequest; +} + +export namespace GetProgressionTypesRequest { + export type AsObject = { + } +} + +export class BlueprintInfo extends jspb.Message { + getBlueprinttype(): string; + setBlueprinttype(value: string): BlueprintInfo; + + getBlueprintid(): string; + setBlueprintid(value: string): BlueprintInfo; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): BlueprintInfo.AsObject; + static toObject(includeInstance: boolean, msg: BlueprintInfo): BlueprintInfo.AsObject; + static serializeBinaryToWriter(message: BlueprintInfo, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): BlueprintInfo; + static deserializeBinaryFromReader(message: BlueprintInfo, reader: jspb.BinaryReader): BlueprintInfo; +} + +export namespace BlueprintInfo { + export type AsObject = { + blueprinttype: string, + blueprintid: string, + } +} + +export class GetProgressionTypesResponse extends jspb.Message { + getEntriesList(): Array; + setEntriesList(value: Array): GetProgressionTypesResponse; + clearEntriesList(): GetProgressionTypesResponse; + addEntries(value?: ProgressionEntry, index?: number): ProgressionEntry; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetProgressionTypesResponse.AsObject; + static toObject(includeInstance: boolean, msg: GetProgressionTypesResponse): GetProgressionTypesResponse.AsObject; + static serializeBinaryToWriter(message: GetProgressionTypesResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetProgressionTypesResponse; + static deserializeBinaryFromReader(message: GetProgressionTypesResponse, reader: jspb.BinaryReader): GetProgressionTypesResponse; +} + +export namespace GetProgressionTypesResponse { + export type AsObject = { + entriesList: Array, + } +} + +export class GetScheduledBlueprintsRequest extends jspb.Message { + getProtocolversion(): string; + setProtocolversion(value: string): GetScheduledBlueprintsRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetScheduledBlueprintsRequest.AsObject; + static toObject(includeInstance: boolean, msg: GetScheduledBlueprintsRequest): GetScheduledBlueprintsRequest.AsObject; + static serializeBinaryToWriter(message: GetScheduledBlueprintsRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetScheduledBlueprintsRequest; + static deserializeBinaryFromReader(message: GetScheduledBlueprintsRequest, reader: jspb.BinaryReader): GetScheduledBlueprintsRequest; +} + +export namespace GetScheduledBlueprintsRequest { + export type AsObject = { + protocolversion: string, + } +} + +export class GetScheduledBlueprintsResponse extends jspb.Message { + getBlueprints(): BlueprintInfo | undefined; + setBlueprints(value?: BlueprintInfo): GetScheduledBlueprintsResponse; + hasBlueprints(): boolean; + clearBlueprints(): GetScheduledBlueprintsResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetScheduledBlueprintsResponse.AsObject; + static toObject(includeInstance: boolean, msg: GetScheduledBlueprintsResponse): GetScheduledBlueprintsResponse.AsObject; + static serializeBinaryToWriter(message: GetScheduledBlueprintsResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetScheduledBlueprintsResponse; + static deserializeBinaryFromReader(message: GetScheduledBlueprintsResponse, reader: jspb.BinaryReader): GetScheduledBlueprintsResponse; +} + +export namespace GetScheduledBlueprintsResponse { + export type AsObject = { + blueprints?: BlueprintInfo.AsObject, + } +} + +export class GetBlueprintsByIdResponse extends jspb.Message { + getBlueprintList(): Array; + setBlueprintList(value: Array): GetBlueprintsByIdResponse; + clearBlueprintList(): GetBlueprintsByIdResponse; + addBlueprint(value?: Blueprint, index?: number): Blueprint; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetBlueprintsByIdResponse.AsObject; + static toObject(includeInstance: boolean, msg: GetBlueprintsByIdResponse): GetBlueprintsByIdResponse.AsObject; + static serializeBinaryToWriter(message: GetBlueprintsByIdResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetBlueprintsByIdResponse; + static deserializeBinaryFromReader(message: GetBlueprintsByIdResponse, reader: jspb.BinaryReader): GetBlueprintsByIdResponse; +} + +export namespace GetBlueprintsByIdResponse { + export type AsObject = { + blueprintList: Array, + } +} + +export class GetConstraintsResponse extends jspb.Message { + getGlobalconstraints(): GlobalConstraints | undefined; + setGlobalconstraints(value?: GlobalConstraints): GetConstraintsResponse; + hasGlobalconstraints(): boolean; + clearGlobalconstraints(): GetConstraintsResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetConstraintsResponse.AsObject; + static toObject(includeInstance: boolean, msg: GetConstraintsResponse): GetConstraintsResponse.AsObject; + static serializeBinaryToWriter(message: GetConstraintsResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetConstraintsResponse; + static deserializeBinaryFromReader(message: GetConstraintsResponse, reader: jspb.BinaryReader): GetConstraintsResponse; +} + +export namespace GetConstraintsResponse { + export type AsObject = { + globalconstraints?: GlobalConstraints.AsObject, + } +} + +export class ListPlaygroundsByOwnerResponse extends jspb.Message { + getPlaygroundresponsesList(): Array; + setPlaygroundresponsesList(value: Array): ListPlaygroundsByOwnerResponse; + clearPlaygroundresponsesList(): ListPlaygroundsByOwnerResponse; + addPlaygroundresponses(value?: PlaygroundResponse, index?: number): PlaygroundResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ListPlaygroundsByOwnerResponse.AsObject; + static toObject(includeInstance: boolean, msg: ListPlaygroundsByOwnerResponse): ListPlaygroundsByOwnerResponse.AsObject; + static serializeBinaryToWriter(message: ListPlaygroundsByOwnerResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ListPlaygroundsByOwnerResponse; + static deserializeBinaryFromReader(message: ListPlaygroundsByOwnerResponse, reader: jspb.BinaryReader): ListPlaygroundsByOwnerResponse; +} + +export namespace ListPlaygroundsByOwnerResponse { + export type AsObject = { + playgroundresponsesList: Array, + } +} + +export class CreatePlaygroundRequest extends jspb.Message { + getBlueprinttype(): string; + setBlueprinttype(value: string): CreatePlaygroundRequest; + + getName(): string; + setName(value: string): CreatePlaygroundRequest; + + getDescription(): StringValue | undefined; + setDescription(value?: StringValue): CreatePlaygroundRequest; + hasDescription(): boolean; + clearDescription(): CreatePlaygroundRequest; + + getMutatorsList(): Array; + setMutatorsList(value: Array): CreatePlaygroundRequest; + clearMutatorsList(): CreatePlaygroundRequest; + addMutators(value?: Mutator, index?: number): Mutator; + + getMaprotation(): MapRotation | undefined; + setMaprotation(value?: MapRotation): CreatePlaygroundRequest; + hasMaprotation(): boolean; + clearMaprotation(): CreatePlaygroundRequest; + + getSecret(): StringValue | undefined; + setSecret(value?: StringValue): CreatePlaygroundRequest; + hasSecret(): boolean; + clearSecret(): CreatePlaygroundRequest; + + getServersettings(): GameServerSettings | undefined; + setServersettings(value?: GameServerSettings): CreatePlaygroundRequest; + hasServersettings(): boolean; + clearServersettings(): CreatePlaygroundRequest; + + getRestrictions(): Restrictions | undefined; + setRestrictions(value?: Restrictions): CreatePlaygroundRequest; + hasRestrictions(): boolean; + clearRestrictions(): CreatePlaygroundRequest; + + getOriginalmodrules(): Uint8Array | string; + getOriginalmodrules_asU8(): Uint8Array; + getOriginalmodrules_asB64(): string; + setOriginalmodrules(value: Uint8Array | string): CreatePlaygroundRequest; + + getAssetcategoriesList(): Array; + setAssetcategoriesList(value: Array): CreatePlaygroundRequest; + clearAssetcategoriesList(): CreatePlaygroundRequest; + addAssetcategories(value?: AssetCategory, index?: number): AssetCategory; + + getTeamcomposition(): TeamComposition | undefined; + setTeamcomposition(value?: TeamComposition): CreatePlaygroundRequest; + hasTeamcomposition(): boolean; + clearTeamcomposition(): CreatePlaygroundRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): CreatePlaygroundRequest.AsObject; + static toObject(includeInstance: boolean, msg: CreatePlaygroundRequest): CreatePlaygroundRequest.AsObject; + static serializeBinaryToWriter(message: CreatePlaygroundRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): CreatePlaygroundRequest; + static deserializeBinaryFromReader(message: CreatePlaygroundRequest, reader: jspb.BinaryReader): CreatePlaygroundRequest; +} + +export namespace CreatePlaygroundRequest { + export type AsObject = { + blueprinttype: string, + name: string, + description?: StringValue.AsObject, + mutatorsList: Array, + maprotation?: MapRotation.AsObject, + secret?: StringValue.AsObject, + serversettings?: GameServerSettings.AsObject, + restrictions?: Restrictions.AsObject, + originalmodrules: Uint8Array | string, + assetcategoriesList: Array, + teamcomposition?: TeamComposition.AsObject, + } +} + +export class UpdatePlaygroundRequest extends jspb.Message { + getNewplayground(): Playground | undefined; + setNewplayground(value?: Playground): UpdatePlaygroundRequest; + hasNewplayground(): boolean; + clearNewplayground(): UpdatePlaygroundRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): UpdatePlaygroundRequest.AsObject; + static toObject(includeInstance: boolean, msg: UpdatePlaygroundRequest): UpdatePlaygroundRequest.AsObject; + static serializeBinaryToWriter(message: UpdatePlaygroundRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): UpdatePlaygroundRequest; + static deserializeBinaryFromReader(message: UpdatePlaygroundRequest, reader: jspb.BinaryReader): UpdatePlaygroundRequest; +} + +export namespace UpdatePlaygroundRequest { + export type AsObject = { + newplayground?: Playground.AsObject, + } +} + +export class DeletePlaygroundRequest extends jspb.Message { + getPlaygroundid(): string; + setPlaygroundid(value: string): DeletePlaygroundRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): DeletePlaygroundRequest.AsObject; + static toObject(includeInstance: boolean, msg: DeletePlaygroundRequest): DeletePlaygroundRequest.AsObject; + static serializeBinaryToWriter(message: DeletePlaygroundRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): DeletePlaygroundRequest; + static deserializeBinaryFromReader(message: DeletePlaygroundRequest, reader: jspb.BinaryReader): DeletePlaygroundRequest; +} + +export namespace DeletePlaygroundRequest { + export type AsObject = { + playgroundid: string, + } +} + +export class GetPlaygroundRequest extends jspb.Message { + getPlaygroundid(): string; + setPlaygroundid(value: string): GetPlaygroundRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetPlaygroundRequest.AsObject; + static toObject(includeInstance: boolean, msg: GetPlaygroundRequest): GetPlaygroundRequest.AsObject; + static serializeBinaryToWriter(message: GetPlaygroundRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetPlaygroundRequest; + static deserializeBinaryFromReader(message: GetPlaygroundRequest, reader: jspb.BinaryReader): GetPlaygroundRequest; +} + +export namespace GetPlaygroundRequest { + export type AsObject = { + playgroundid: string, + } +} + +export class SharePlaygroundRequest extends jspb.Message { + getPlaygroundid(): string; + setPlaygroundid(value: string): SharePlaygroundRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): SharePlaygroundRequest.AsObject; + static toObject(includeInstance: boolean, msg: SharePlaygroundRequest): SharePlaygroundRequest.AsObject; + static serializeBinaryToWriter(message: SharePlaygroundRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): SharePlaygroundRequest; + static deserializeBinaryFromReader(message: SharePlaygroundRequest, reader: jspb.BinaryReader): SharePlaygroundRequest; +} + +export namespace SharePlaygroundRequest { + export type AsObject = { + playgroundid: string, + } +} + +export class SharePlaygroundResponse extends jspb.Message { + getShortcode(): ShortCode | undefined; + setShortcode(value?: ShortCode): SharePlaygroundResponse; + hasShortcode(): boolean; + clearShortcode(): SharePlaygroundResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): SharePlaygroundResponse.AsObject; + static toObject(includeInstance: boolean, msg: SharePlaygroundResponse): SharePlaygroundResponse.AsObject; + static serializeBinaryToWriter(message: SharePlaygroundResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): SharePlaygroundResponse; + static deserializeBinaryFromReader(message: SharePlaygroundResponse, reader: jspb.BinaryReader): SharePlaygroundResponse; +} + +export namespace SharePlaygroundResponse { + export type AsObject = { + shortcode?: ShortCode.AsObject, + } +} + +export class CreatePlaygroundResponse extends jspb.Message { + getPlaygroundresponse(): PlaygroundResponse | undefined; + setPlaygroundresponse(value?: PlaygroundResponse): CreatePlaygroundResponse; + hasPlaygroundresponse(): boolean; + clearPlaygroundresponse(): CreatePlaygroundResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): CreatePlaygroundResponse.AsObject; + static toObject(includeInstance: boolean, msg: CreatePlaygroundResponse): CreatePlaygroundResponse.AsObject; + static serializeBinaryToWriter(message: CreatePlaygroundResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): CreatePlaygroundResponse; + static deserializeBinaryFromReader(message: CreatePlaygroundResponse, reader: jspb.BinaryReader): CreatePlaygroundResponse; +} + +export namespace CreatePlaygroundResponse { + export type AsObject = { + playgroundresponse?: PlaygroundResponse.AsObject, + } +} + +export class UpdatePlaygroundResponse extends jspb.Message { + getPlaygroundresponse(): PlaygroundResponse | undefined; + setPlaygroundresponse(value?: PlaygroundResponse): UpdatePlaygroundResponse; + hasPlaygroundresponse(): boolean; + clearPlaygroundresponse(): UpdatePlaygroundResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): UpdatePlaygroundResponse.AsObject; + static toObject(includeInstance: boolean, msg: UpdatePlaygroundResponse): UpdatePlaygroundResponse.AsObject; + static serializeBinaryToWriter(message: UpdatePlaygroundResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): UpdatePlaygroundResponse; + static deserializeBinaryFromReader(message: UpdatePlaygroundResponse, reader: jspb.BinaryReader): UpdatePlaygroundResponse; +} + +export namespace UpdatePlaygroundResponse { + export type AsObject = { + playgroundresponse?: PlaygroundResponse.AsObject, + } +} + +export class DeletePlaygroundResponse extends jspb.Message { + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): DeletePlaygroundResponse.AsObject; + static toObject(includeInstance: boolean, msg: DeletePlaygroundResponse): DeletePlaygroundResponse.AsObject; + static serializeBinaryToWriter(message: DeletePlaygroundResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): DeletePlaygroundResponse; + static deserializeBinaryFromReader(message: DeletePlaygroundResponse, reader: jspb.BinaryReader): DeletePlaygroundResponse; +} + +export namespace DeletePlaygroundResponse { + export type AsObject = { + } +} + +export class PlaygroundInfoResponse extends jspb.Message { + getPlayground(): PlaygroundResponse | undefined; + setPlayground(value?: PlaygroundResponse): PlaygroundInfoResponse; + hasPlayground(): boolean; + clearPlayground(): PlaygroundInfoResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): PlaygroundInfoResponse.AsObject; + static toObject(includeInstance: boolean, msg: PlaygroundInfoResponse): PlaygroundInfoResponse.AsObject; + static serializeBinaryToWriter(message: PlaygroundInfoResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): PlaygroundInfoResponse; + static deserializeBinaryFromReader(message: PlaygroundInfoResponse, reader: jspb.BinaryReader): PlaygroundInfoResponse; +} + +export namespace PlaygroundInfoResponse { + export type AsObject = { + playground?: PlaygroundResponse.AsObject, + } +} + +export enum Platform { + UNKNOWN = 0, + PC = 1, + PS4 = 2, + XBOXONE = 3, + PS5 = 4, + XBSX = 5, + COMMON = 6, +} +export enum InputMethods { + ALL = 0, + KEYBOARD_MOUSE = 1, + GAME_CONTROLLER = 3, +} +export enum IncludeFields { + AVAILABLE_GAME_DATA = 0, + METADATA = 1, + CUSTOM_DATA = 2, + CONSTRAINTS = 3, + AVAILABLE_TAGS = 4, +} +export enum State { + ACTIVE = 0, + ARCHIVED = 1, +} +export enum Category { + CATEGORY_UNKNOWN = 0, + CATEGORY_MODE = 1, + CATEGORY_PACKAGE = 2, + CATEGORY_GENERAL = 3, +} +export enum PhantomGameState { + ENABLED = 0, + DISABLED = 1, +} +export enum CapacityType { + AI_BACKFILL = 0, + AI_STATIC = 1, +} +export enum RotationBehavior { + LOOP = 0, + MATCHMAKE = 1, + ONE_MAP = 2, +} +export enum RoundBehavior { + CONTINUE = 0, +} +export enum BalancingMethod { + UNSPECIFIED = 0, + EVEN_NUMBERS = 1, + EVEN_PERCENTAGE = 2, + FILL_IN_TEAM_ORDER = 3, +} diff --git a/src/grpc-web/proto/communitygames_pb.js b/src/grpc-web/proto/communitygames_pb.js new file mode 100644 index 0000000..6a8b462 --- /dev/null +++ b/src/grpc-web/proto/communitygames_pb.js @@ -0,0 +1,18683 @@ +// source: proto/communitygames.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! + +var jspb = require('google-protobuf'); +var goog = jspb; +var global = Function('return this')(); + +goog.exportSymbol('proto.web.communitygames.AssetCategory', null, global); +goog.exportSymbol('proto.web.communitygames.AssetCategoryBoolean', null, global); +goog.exportSymbol('proto.web.communitygames.AssetCategoryTagBooleanOverride', null, global); +goog.exportSymbol('proto.web.communitygames.AssetCategoryTagBooleanTeamOverride', null, global); +goog.exportSymbol('proto.web.communitygames.AvailableAssetCategories', null, global); +goog.exportSymbol('proto.web.communitygames.AvailableAssetCategoryTag', null, global); +goog.exportSymbol('proto.web.communitygames.AvailableGameData', null, global); +goog.exportSymbol('proto.web.communitygames.AvailableIntValue', null, global); +goog.exportSymbol('proto.web.communitygames.AvailableIntValues', null, global); +goog.exportSymbol('proto.web.communitygames.AvailableMapEntry', null, global); +goog.exportSymbol('proto.web.communitygames.AvailableMutator', null, global); +goog.exportSymbol('proto.web.communitygames.AvailableTag', null, global); +goog.exportSymbol('proto.web.communitygames.BalancingMethod', null, global); +goog.exportSymbol('proto.web.communitygames.Blueprint', null, global); +goog.exportSymbol('proto.web.communitygames.BlueprintInfo', null, global); +goog.exportSymbol('proto.web.communitygames.CapacityType', null, global); +goog.exportSymbol('proto.web.communitygames.Category', null, global); +goog.exportSymbol('proto.web.communitygames.CompatibleModRules', null, global); +goog.exportSymbol('proto.web.communitygames.CompiledRules', null, global); +goog.exportSymbol('proto.web.communitygames.Compressed', null, global); +goog.exportSymbol('proto.web.communitygames.CreatePlaygroundRequest', null, global); +goog.exportSymbol('proto.web.communitygames.CreatePlaygroundResponse', null, global); +goog.exportSymbol('proto.web.communitygames.DeletePlaygroundRequest', null, global); +goog.exportSymbol('proto.web.communitygames.DeletePlaygroundResponse', null, global); +goog.exportSymbol('proto.web.communitygames.GameServerMessage', null, global); +goog.exportSymbol('proto.web.communitygames.GameServerSettings', null, global); +goog.exportSymbol('proto.web.communitygames.GetBlueprintsByIdRequest', null, global); +goog.exportSymbol('proto.web.communitygames.GetBlueprintsByIdResponse', null, global); +goog.exportSymbol('proto.web.communitygames.GetConstraintsRequest', null, global); +goog.exportSymbol('proto.web.communitygames.GetConstraintsResponse', null, global); +goog.exportSymbol('proto.web.communitygames.GetPlaygroundRequest', null, global); +goog.exportSymbol('proto.web.communitygames.GetProgressionTypesRequest', null, global); +goog.exportSymbol('proto.web.communitygames.GetProgressionTypesResponse', null, global); +goog.exportSymbol('proto.web.communitygames.GetScheduledBlueprintsRequest', null, global); +goog.exportSymbol('proto.web.communitygames.GetScheduledBlueprintsResponse', null, global); +goog.exportSymbol('proto.web.communitygames.GlobalConstraints', null, global); +goog.exportSymbol('proto.web.communitygames.InCompatibleModRules', null, global); +goog.exportSymbol('proto.web.communitygames.IncludeFields', null, global); +goog.exportSymbol('proto.web.communitygames.InputMethodResrictions', null, global); +goog.exportSymbol('proto.web.communitygames.InputMethods', null, global); +goog.exportSymbol('proto.web.communitygames.IntRange', null, global); +goog.exportSymbol('proto.web.communitygames.InternalTeamStructure', null, global); +goog.exportSymbol('proto.web.communitygames.ListPlaygroundsByOwnerRequest', null, global); +goog.exportSymbol('proto.web.communitygames.ListPlaygroundsByOwnerResponse', null, global); +goog.exportSymbol('proto.web.communitygames.MapInfo', null, global); +goog.exportSymbol('proto.web.communitygames.MapRotation', null, global); +goog.exportSymbol('proto.web.communitygames.Metadata', null, global); +goog.exportSymbol('proto.web.communitygames.ModRulesDefinition', null, global); +goog.exportSymbol('proto.web.communitygames.Mutator', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorBoolean', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorFloat', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorInt', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorKind', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorSparseBoolean', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorSparseBooleanEntry', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorSparseFloat', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorSparseFloatEntry', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorSparseInt', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorSparseIntEntry', null, global); +goog.exportSymbol('proto.web.communitygames.MutatorString', null, global); +goog.exportSymbol('proto.web.communitygames.OriginalModRules', null, global); +goog.exportSymbol('proto.web.communitygames.PhantomGameState', null, global); +goog.exportSymbol('proto.web.communitygames.Platform', null, global); +goog.exportSymbol('proto.web.communitygames.PlatformRestrictions', null, global); +goog.exportSymbol('proto.web.communitygames.PlayerInfo', null, global); +goog.exportSymbol('proto.web.communitygames.Playground', null, global); +goog.exportSymbol('proto.web.communitygames.PlaygroundConstraints', null, global); +goog.exportSymbol('proto.web.communitygames.PlaygroundInfoResponse', null, global); +goog.exportSymbol('proto.web.communitygames.PlaygroundResponse', null, global); +goog.exportSymbol('proto.web.communitygames.ProgressionEntry', null, global); +goog.exportSymbol('proto.web.communitygames.ProgressionMode', null, global); +goog.exportSymbol('proto.web.communitygames.Resource', null, global); +goog.exportSymbol('proto.web.communitygames.ResourceLocation', null, global); +goog.exportSymbol('proto.web.communitygames.Restrictions', null, global); +goog.exportSymbol('proto.web.communitygames.RotationBehavior', null, global); +goog.exportSymbol('proto.web.communitygames.RoundBehavior', null, global); +goog.exportSymbol('proto.web.communitygames.SharePlaygroundRequest', null, global); +goog.exportSymbol('proto.web.communitygames.SharePlaygroundResponse', null, global); +goog.exportSymbol('proto.web.communitygames.ShortCode', null, global); +goog.exportSymbol('proto.web.communitygames.SparseIntEntity', null, global); +goog.exportSymbol('proto.web.communitygames.State', null, global); +goog.exportSymbol('proto.web.communitygames.StringValue', null, global); +goog.exportSymbol('proto.web.communitygames.Tag', null, global); +goog.exportSymbol('proto.web.communitygames.TeamComposition', null, global); +goog.exportSymbol('proto.web.communitygames.TeamStructure', null, global); +goog.exportSymbol('proto.web.communitygames.Timestamp', null, global); +goog.exportSymbol('proto.web.communitygames.TranslationMetadata', null, global); +goog.exportSymbol('proto.web.communitygames.Uncompressed', null, global); +goog.exportSymbol('proto.web.communitygames.UpdatePlaygroundRequest', null, global); +goog.exportSymbol('proto.web.communitygames.UpdatePlaygroundResponse', 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.web.communitygames.ProgressionEntry = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.ProgressionEntry.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.ProgressionEntry, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.ProgressionEntry.displayName = 'proto.web.communitygames.ProgressionEntry'; +} +/** + * 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.web.communitygames.TranslationMetadata = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.TranslationMetadata, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.TranslationMetadata.displayName = 'proto.web.communitygames.TranslationMetadata'; +} +/** + * 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.web.communitygames.ResourceLocation = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.ResourceLocation, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.ResourceLocation.displayName = 'proto.web.communitygames.ResourceLocation'; +} +/** + * 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.web.communitygames.Resource = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.Resource, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.Resource.displayName = 'proto.web.communitygames.Resource'; +} +/** + * 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.web.communitygames.Metadata = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.Metadata.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.Metadata, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.Metadata.displayName = 'proto.web.communitygames.Metadata'; +} +/** + * 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.web.communitygames.Tag = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.Tag, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.Tag.displayName = 'proto.web.communitygames.Tag'; +} +/** + * 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.web.communitygames.ProgressionMode = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.ProgressionMode, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.ProgressionMode.displayName = 'proto.web.communitygames.ProgressionMode'; +} +/** + * 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.web.communitygames.PlaygroundResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.PlaygroundResponse.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.PlaygroundResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.PlaygroundResponse.displayName = 'proto.web.communitygames.PlaygroundResponse'; +} +/** + * 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.web.communitygames.MapInfo = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.MapInfo, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MapInfo.displayName = 'proto.web.communitygames.MapInfo'; +} +/** + * 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.web.communitygames.MapRotation = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.MapRotation.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.MapRotation, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MapRotation.displayName = 'proto.web.communitygames.MapRotation'; +} +/** + * 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.web.communitygames.TeamStructure = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.TeamStructure, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.TeamStructure.displayName = 'proto.web.communitygames.TeamStructure'; +} +/** + * 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.web.communitygames.InternalTeamStructure = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.InternalTeamStructure, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.InternalTeamStructure.displayName = 'proto.web.communitygames.InternalTeamStructure'; +} +/** + * 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.web.communitygames.MutatorSparseFloatEntry = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.MutatorSparseFloatEntry, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorSparseFloatEntry.displayName = 'proto.web.communitygames.MutatorSparseFloatEntry'; +} +/** + * 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.web.communitygames.MutatorSparseFloat = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.MutatorSparseFloat.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.MutatorSparseFloat, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorSparseFloat.displayName = 'proto.web.communitygames.MutatorSparseFloat'; +} +/** + * 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.web.communitygames.MutatorFloat = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.MutatorFloat, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorFloat.displayName = 'proto.web.communitygames.MutatorFloat'; +} +/** + * 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.web.communitygames.MutatorBoolean = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.MutatorBoolean, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorBoolean.displayName = 'proto.web.communitygames.MutatorBoolean'; +} +/** + * 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.web.communitygames.MutatorString = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.MutatorString, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorString.displayName = 'proto.web.communitygames.MutatorString'; +} +/** + * 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.web.communitygames.MutatorInt = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.MutatorInt, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorInt.displayName = 'proto.web.communitygames.MutatorInt'; +} +/** + * 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.web.communitygames.MutatorSparseBooleanEntry = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.MutatorSparseBooleanEntry, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorSparseBooleanEntry.displayName = 'proto.web.communitygames.MutatorSparseBooleanEntry'; +} +/** + * 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.web.communitygames.MutatorSparseBoolean = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.MutatorSparseBoolean.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.MutatorSparseBoolean, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorSparseBoolean.displayName = 'proto.web.communitygames.MutatorSparseBoolean'; +} +/** + * 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.web.communitygames.SparseIntEntity = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.SparseIntEntity.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.SparseIntEntity, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.SparseIntEntity.displayName = 'proto.web.communitygames.SparseIntEntity'; +} +/** + * 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.web.communitygames.MutatorSparseIntEntry = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.MutatorSparseIntEntry, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorSparseIntEntry.displayName = 'proto.web.communitygames.MutatorSparseIntEntry'; +} +/** + * 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.web.communitygames.MutatorSparseInt = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.MutatorSparseInt, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorSparseInt.displayName = 'proto.web.communitygames.MutatorSparseInt'; +} +/** + * 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.web.communitygames.MutatorKind = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.MutatorKind, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.MutatorKind.displayName = 'proto.web.communitygames.MutatorKind'; +} +/** + * 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.web.communitygames.TeamComposition = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.TeamComposition.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.TeamComposition, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.TeamComposition.displayName = 'proto.web.communitygames.TeamComposition'; +} +/** + * 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.web.communitygames.Mutator = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.Mutator, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.Mutator.displayName = 'proto.web.communitygames.Mutator'; +} +/** + * 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.web.communitygames.Timestamp = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.Timestamp, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.Timestamp.displayName = 'proto.web.communitygames.Timestamp'; +} +/** + * 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.web.communitygames.StringValue = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.StringValue, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.StringValue.displayName = 'proto.web.communitygames.StringValue'; +} +/** + * 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.web.communitygames.GameServerMessage = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.GameServerMessage, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GameServerMessage.displayName = 'proto.web.communitygames.GameServerMessage'; +} +/** + * 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.web.communitygames.GameServerSettings = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.GameServerSettings.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.GameServerSettings, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GameServerSettings.displayName = 'proto.web.communitygames.GameServerSettings'; +} +/** + * 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.web.communitygames.PlayerInfo = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.PlayerInfo, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.PlayerInfo.displayName = 'proto.web.communitygames.PlayerInfo'; +} +/** + * 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.web.communitygames.PlatformRestrictions = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.PlatformRestrictions.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.PlatformRestrictions, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.PlatformRestrictions.displayName = 'proto.web.communitygames.PlatformRestrictions'; +} +/** + * 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.web.communitygames.InputMethodResrictions = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.InputMethodResrictions.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.InputMethodResrictions, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.InputMethodResrictions.displayName = 'proto.web.communitygames.InputMethodResrictions'; +} +/** + * 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.web.communitygames.Restrictions = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.Restrictions, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.Restrictions.displayName = 'proto.web.communitygames.Restrictions'; +} +/** + * 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.web.communitygames.Compressed = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.Compressed, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.Compressed.displayName = 'proto.web.communitygames.Compressed'; +} +/** + * 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.web.communitygames.Uncompressed = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.Uncompressed, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.Uncompressed.displayName = 'proto.web.communitygames.Uncompressed'; +} +/** + * 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.web.communitygames.CompiledRules = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.CompiledRules, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.CompiledRules.displayName = 'proto.web.communitygames.CompiledRules'; +} +/** + * 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.web.communitygames.CompatibleModRules = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.CompatibleModRules, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.CompatibleModRules.displayName = 'proto.web.communitygames.CompatibleModRules'; +} +/** + * 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.web.communitygames.InCompatibleModRules = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.InCompatibleModRules, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.InCompatibleModRules.displayName = 'proto.web.communitygames.InCompatibleModRules'; +} +/** + * 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.web.communitygames.OriginalModRules = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.OriginalModRules, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.OriginalModRules.displayName = 'proto.web.communitygames.OriginalModRules'; +} +/** + * 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.web.communitygames.AssetCategoryTagBooleanOverride = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.AssetCategoryTagBooleanOverride.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.AssetCategoryTagBooleanOverride, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AssetCategoryTagBooleanOverride.displayName = 'proto.web.communitygames.AssetCategoryTagBooleanOverride'; +} +/** + * 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.web.communitygames.AssetCategoryTagBooleanTeamOverride = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.AssetCategoryTagBooleanTeamOverride, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.displayName = 'proto.web.communitygames.AssetCategoryTagBooleanTeamOverride'; +} +/** + * 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.web.communitygames.AssetCategoryBoolean = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.AssetCategoryBoolean.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.AssetCategoryBoolean, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AssetCategoryBoolean.displayName = 'proto.web.communitygames.AssetCategoryBoolean'; +} +/** + * 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.web.communitygames.AssetCategory = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.AssetCategory, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AssetCategory.displayName = 'proto.web.communitygames.AssetCategory'; +} +/** + * 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.web.communitygames.Playground = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.Playground.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.Playground, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.Playground.displayName = 'proto.web.communitygames.Playground'; +} +/** + * 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.web.communitygames.ListPlaygroundsByOwnerRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.ListPlaygroundsByOwnerRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.ListPlaygroundsByOwnerRequest.displayName = 'proto.web.communitygames.ListPlaygroundsByOwnerRequest'; +} +/** + * 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.web.communitygames.GetConstraintsRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.GetConstraintsRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GetConstraintsRequest.displayName = 'proto.web.communitygames.GetConstraintsRequest'; +} +/** + * 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.web.communitygames.GetBlueprintsByIdRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.GetBlueprintsByIdRequest.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.GetBlueprintsByIdRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GetBlueprintsByIdRequest.displayName = 'proto.web.communitygames.GetBlueprintsByIdRequest'; +} +/** + * 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.web.communitygames.GlobalConstraints = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.GlobalConstraints, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GlobalConstraints.displayName = 'proto.web.communitygames.GlobalConstraints'; +} +/** + * 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.web.communitygames.IntRange = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.IntRange, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.IntRange.displayName = 'proto.web.communitygames.IntRange'; +} +/** + * 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.web.communitygames.AvailableIntValues = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.AvailableIntValues, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AvailableIntValues.displayName = 'proto.web.communitygames.AvailableIntValues'; +} +/** + * 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.web.communitygames.AvailableIntValue = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.AvailableIntValue, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AvailableIntValue.displayName = 'proto.web.communitygames.AvailableIntValue'; +} +/** + * 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.web.communitygames.AvailableMutator = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.AvailableMutator, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AvailableMutator.displayName = 'proto.web.communitygames.AvailableMutator'; +} +/** + * 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.web.communitygames.AvailableMapEntry = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.AvailableMapEntry.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.AvailableMapEntry, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AvailableMapEntry.displayName = 'proto.web.communitygames.AvailableMapEntry'; +} +/** + * 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.web.communitygames.AvailableTag = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.AvailableTag, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AvailableTag.displayName = 'proto.web.communitygames.AvailableTag'; +} +/** + * 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.web.communitygames.AvailableAssetCategoryTag = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.AvailableAssetCategoryTag.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.AvailableAssetCategoryTag, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AvailableAssetCategoryTag.displayName = 'proto.web.communitygames.AvailableAssetCategoryTag'; +} +/** + * 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.web.communitygames.AvailableAssetCategories = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.AvailableAssetCategories.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.AvailableAssetCategories, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AvailableAssetCategories.displayName = 'proto.web.communitygames.AvailableAssetCategories'; +} +/** + * 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.web.communitygames.PlaygroundConstraints = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.PlaygroundConstraints, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.PlaygroundConstraints.displayName = 'proto.web.communitygames.PlaygroundConstraints'; +} +/** + * 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.web.communitygames.ModRulesDefinition = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.ModRulesDefinition, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.ModRulesDefinition.displayName = 'proto.web.communitygames.ModRulesDefinition'; +} +/** + * 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.web.communitygames.AvailableGameData = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.AvailableGameData.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.AvailableGameData, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.AvailableGameData.displayName = 'proto.web.communitygames.AvailableGameData'; +} +/** + * 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.web.communitygames.Blueprint = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.Blueprint.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.Blueprint, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.Blueprint.displayName = 'proto.web.communitygames.Blueprint'; +} +/** + * 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.web.communitygames.ShortCode = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.ShortCode, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.ShortCode.displayName = 'proto.web.communitygames.ShortCode'; +} +/** + * 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.web.communitygames.GetProgressionTypesRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.GetProgressionTypesRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GetProgressionTypesRequest.displayName = 'proto.web.communitygames.GetProgressionTypesRequest'; +} +/** + * 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.web.communitygames.BlueprintInfo = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.BlueprintInfo, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.BlueprintInfo.displayName = 'proto.web.communitygames.BlueprintInfo'; +} +/** + * 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.web.communitygames.GetProgressionTypesResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.GetProgressionTypesResponse.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.GetProgressionTypesResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GetProgressionTypesResponse.displayName = 'proto.web.communitygames.GetProgressionTypesResponse'; +} +/** + * 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.web.communitygames.GetScheduledBlueprintsRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.GetScheduledBlueprintsRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GetScheduledBlueprintsRequest.displayName = 'proto.web.communitygames.GetScheduledBlueprintsRequest'; +} +/** + * 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.web.communitygames.GetScheduledBlueprintsResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.GetScheduledBlueprintsResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GetScheduledBlueprintsResponse.displayName = 'proto.web.communitygames.GetScheduledBlueprintsResponse'; +} +/** + * 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.web.communitygames.GetBlueprintsByIdResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.GetBlueprintsByIdResponse.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.GetBlueprintsByIdResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GetBlueprintsByIdResponse.displayName = 'proto.web.communitygames.GetBlueprintsByIdResponse'; +} +/** + * 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.web.communitygames.GetConstraintsResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.GetConstraintsResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GetConstraintsResponse.displayName = 'proto.web.communitygames.GetConstraintsResponse'; +} +/** + * 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.web.communitygames.ListPlaygroundsByOwnerResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.ListPlaygroundsByOwnerResponse.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.ListPlaygroundsByOwnerResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.ListPlaygroundsByOwnerResponse.displayName = 'proto.web.communitygames.ListPlaygroundsByOwnerResponse'; +} +/** + * 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.web.communitygames.CreatePlaygroundRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.communitygames.CreatePlaygroundRequest.repeatedFields_, null); +}; +goog.inherits(proto.web.communitygames.CreatePlaygroundRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.CreatePlaygroundRequest.displayName = 'proto.web.communitygames.CreatePlaygroundRequest'; +} +/** + * 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.web.communitygames.UpdatePlaygroundRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.UpdatePlaygroundRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.UpdatePlaygroundRequest.displayName = 'proto.web.communitygames.UpdatePlaygroundRequest'; +} +/** + * 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.web.communitygames.DeletePlaygroundRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.DeletePlaygroundRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.DeletePlaygroundRequest.displayName = 'proto.web.communitygames.DeletePlaygroundRequest'; +} +/** + * 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.web.communitygames.GetPlaygroundRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.GetPlaygroundRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.GetPlaygroundRequest.displayName = 'proto.web.communitygames.GetPlaygroundRequest'; +} +/** + * 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.web.communitygames.SharePlaygroundRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.SharePlaygroundRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.SharePlaygroundRequest.displayName = 'proto.web.communitygames.SharePlaygroundRequest'; +} +/** + * 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.web.communitygames.SharePlaygroundResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.SharePlaygroundResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.SharePlaygroundResponse.displayName = 'proto.web.communitygames.SharePlaygroundResponse'; +} +/** + * 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.web.communitygames.CreatePlaygroundResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.CreatePlaygroundResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.CreatePlaygroundResponse.displayName = 'proto.web.communitygames.CreatePlaygroundResponse'; +} +/** + * 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.web.communitygames.UpdatePlaygroundResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.UpdatePlaygroundResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.UpdatePlaygroundResponse.displayName = 'proto.web.communitygames.UpdatePlaygroundResponse'; +} +/** + * 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.web.communitygames.DeletePlaygroundResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.DeletePlaygroundResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.DeletePlaygroundResponse.displayName = 'proto.web.communitygames.DeletePlaygroundResponse'; +} +/** + * 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.web.communitygames.PlaygroundInfoResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.communitygames.PlaygroundInfoResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.communitygames.PlaygroundInfoResponse.displayName = 'proto.web.communitygames.PlaygroundInfoResponse'; +} + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.ProgressionEntry.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.web.communitygames.ProgressionEntry.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.ProgressionEntry.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.web.communitygames.ProgressionEntry} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ProgressionEntry.toObject = function(includeInstance, msg) { + var f, obj = { + progressionmode: jspb.Message.getFieldWithDefault(msg, 1, ""), + progressiblesList: jspb.Message.toObjectList(msg.getProgressiblesList(), + proto.web.communitygames.Mutator.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.web.communitygames.ProgressionEntry} + */ +proto.web.communitygames.ProgressionEntry.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.ProgressionEntry; + return proto.web.communitygames.ProgressionEntry.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.ProgressionEntry} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.ProgressionEntry} + */ +proto.web.communitygames.ProgressionEntry.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.setProgressionmode(value); + break; + case 2: + var value = new proto.web.communitygames.Mutator; + reader.readMessage(value,proto.web.communitygames.Mutator.deserializeBinaryFromReader); + msg.addProgressibles(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.ProgressionEntry.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.ProgressionEntry.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.ProgressionEntry} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ProgressionEntry.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getProgressionmode(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getProgressiblesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.web.communitygames.Mutator.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string progressionMode = 1; + * @return {string} + */ +proto.web.communitygames.ProgressionEntry.prototype.getProgressionmode = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.ProgressionEntry} returns this + */ +proto.web.communitygames.ProgressionEntry.prototype.setProgressionmode = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * repeated Mutator progressibles = 2; + * @return {!Array} + */ +proto.web.communitygames.ProgressionEntry.prototype.getProgressiblesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.Mutator, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.ProgressionEntry} returns this +*/ +proto.web.communitygames.ProgressionEntry.prototype.setProgressiblesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.web.communitygames.Mutator=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.Mutator} + */ +proto.web.communitygames.ProgressionEntry.prototype.addProgressibles = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.web.communitygames.Mutator, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.ProgressionEntry} returns this + */ +proto.web.communitygames.ProgressionEntry.prototype.clearProgressiblesList = function() { + return this.setProgressiblesList([]); +}; + + + + + +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.web.communitygames.TranslationMetadata.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.TranslationMetadata.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.web.communitygames.TranslationMetadata} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.TranslationMetadata.toObject = function(includeInstance, msg) { + var f, obj = { + kind: jspb.Message.getFieldWithDefault(msg, 1, ""), + translationid: 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.web.communitygames.TranslationMetadata} + */ +proto.web.communitygames.TranslationMetadata.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.TranslationMetadata; + return proto.web.communitygames.TranslationMetadata.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.TranslationMetadata} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.TranslationMetadata} + */ +proto.web.communitygames.TranslationMetadata.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.setKind(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setTranslationid(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.TranslationMetadata.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.TranslationMetadata.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.TranslationMetadata} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.TranslationMetadata.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getKind(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getTranslationid(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional string kind = 1; + * @return {string} + */ +proto.web.communitygames.TranslationMetadata.prototype.getKind = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.TranslationMetadata} returns this + */ +proto.web.communitygames.TranslationMetadata.prototype.setKind = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string translationId = 2; + * @return {string} + */ +proto.web.communitygames.TranslationMetadata.prototype.getTranslationid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.TranslationMetadata} returns this + */ +proto.web.communitygames.TranslationMetadata.prototype.setTranslationid = 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.web.communitygames.ResourceLocation.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.ResourceLocation.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.web.communitygames.ResourceLocation} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ResourceLocation.toObject = function(includeInstance, msg) { + var f, obj = { + ref: jspb.Message.getFieldWithDefault(msg, 1, ""), + url: 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.web.communitygames.ResourceLocation} + */ +proto.web.communitygames.ResourceLocation.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.ResourceLocation; + return proto.web.communitygames.ResourceLocation.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.ResourceLocation} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.ResourceLocation} + */ +proto.web.communitygames.ResourceLocation.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.setRef(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setUrl(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.ResourceLocation.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.ResourceLocation.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.ResourceLocation} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ResourceLocation.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getRef(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getUrl(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional string ref = 1; + * @return {string} + */ +proto.web.communitygames.ResourceLocation.prototype.getRef = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.ResourceLocation} returns this + */ +proto.web.communitygames.ResourceLocation.prototype.setRef = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string url = 2; + * @return {string} + */ +proto.web.communitygames.ResourceLocation.prototype.getUrl = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.ResourceLocation} returns this + */ +proto.web.communitygames.ResourceLocation.prototype.setUrl = 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.web.communitygames.Resource.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.Resource.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.web.communitygames.Resource} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Resource.toObject = function(includeInstance, msg) { + var f, obj = { + location: (f = msg.getLocation()) && proto.web.communitygames.ResourceLocation.toObject(includeInstance, f), + kind: 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.web.communitygames.Resource} + */ +proto.web.communitygames.Resource.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.Resource; + return proto.web.communitygames.Resource.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.Resource} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.Resource} + */ +proto.web.communitygames.Resource.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.ResourceLocation; + reader.readMessage(value,proto.web.communitygames.ResourceLocation.deserializeBinaryFromReader); + msg.setLocation(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setKind(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.Resource.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.Resource.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.Resource} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Resource.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getLocation(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.ResourceLocation.serializeBinaryToWriter + ); + } + f = message.getKind(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional ResourceLocation location = 1; + * @return {?proto.web.communitygames.ResourceLocation} + */ +proto.web.communitygames.Resource.prototype.getLocation = function() { + return /** @type{?proto.web.communitygames.ResourceLocation} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.ResourceLocation, 1)); +}; + + +/** + * @param {?proto.web.communitygames.ResourceLocation|undefined} value + * @return {!proto.web.communitygames.Resource} returns this +*/ +proto.web.communitygames.Resource.prototype.setLocation = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Resource} returns this + */ +proto.web.communitygames.Resource.prototype.clearLocation = function() { + return this.setLocation(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Resource.prototype.hasLocation = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional string kind = 2; + * @return {string} + */ +proto.web.communitygames.Resource.prototype.getKind = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Resource} returns this + */ +proto.web.communitygames.Resource.prototype.setKind = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.Metadata.repeatedFields_ = [1,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.web.communitygames.Metadata.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.Metadata.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.web.communitygames.Metadata} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Metadata.toObject = function(includeInstance, msg) { + var f, obj = { + translationsList: jspb.Message.toObjectList(msg.getTranslationsList(), + proto.web.communitygames.TranslationMetadata.toObject, includeInstance), + resourcesList: jspb.Message.toObjectList(msg.getResourcesList(), + proto.web.communitygames.Resource.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.web.communitygames.Metadata} + */ +proto.web.communitygames.Metadata.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.Metadata; + return proto.web.communitygames.Metadata.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.Metadata} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.Metadata} + */ +proto.web.communitygames.Metadata.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.TranslationMetadata; + reader.readMessage(value,proto.web.communitygames.TranslationMetadata.deserializeBinaryFromReader); + msg.addTranslations(value); + break; + case 2: + var value = new proto.web.communitygames.Resource; + reader.readMessage(value,proto.web.communitygames.Resource.deserializeBinaryFromReader); + msg.addResources(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.Metadata.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.Metadata.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.Metadata} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Metadata.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTranslationsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.web.communitygames.TranslationMetadata.serializeBinaryToWriter + ); + } + f = message.getResourcesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.web.communitygames.Resource.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated TranslationMetadata translations = 1; + * @return {!Array} + */ +proto.web.communitygames.Metadata.prototype.getTranslationsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.TranslationMetadata, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.Metadata} returns this +*/ +proto.web.communitygames.Metadata.prototype.setTranslationsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.web.communitygames.TranslationMetadata=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.TranslationMetadata} + */ +proto.web.communitygames.Metadata.prototype.addTranslations = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.web.communitygames.TranslationMetadata, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.Metadata} returns this + */ +proto.web.communitygames.Metadata.prototype.clearTranslationsList = function() { + return this.setTranslationsList([]); +}; + + +/** + * repeated Resource resources = 2; + * @return {!Array} + */ +proto.web.communitygames.Metadata.prototype.getResourcesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.Resource, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.Metadata} returns this +*/ +proto.web.communitygames.Metadata.prototype.setResourcesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.web.communitygames.Resource=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.Resource} + */ +proto.web.communitygames.Metadata.prototype.addResources = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.web.communitygames.Resource, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.Metadata} returns this + */ +proto.web.communitygames.Metadata.prototype.clearResourcesList = function() { + return this.setResourcesList([]); +}; + + + + + +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.web.communitygames.Tag.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.Tag.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.web.communitygames.Tag} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Tag.toObject = function(includeInstance, msg) { + var f, obj = { + id: jspb.Message.getFieldWithDefault(msg, 1, ""), + sortorder: jspb.Message.getFieldWithDefault(msg, 2, 0), + metadata: (f = msg.getMetadata()) && proto.web.communitygames.Metadata.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.web.communitygames.Tag} + */ +proto.web.communitygames.Tag.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.Tag; + return proto.web.communitygames.Tag.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.Tag} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.Tag} + */ +proto.web.communitygames.Tag.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setId(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setSortorder(value); + break; + case 3: + var value = new proto.web.communitygames.Metadata; + reader.readMessage(value,proto.web.communitygames.Metadata.deserializeBinaryFromReader); + msg.setMetadata(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.Tag.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.Tag.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.Tag} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Tag.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getId(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getSortorder(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getMetadata(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.web.communitygames.Metadata.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string id = 1; + * @return {string} + */ +proto.web.communitygames.Tag.prototype.getId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Tag} returns this + */ +proto.web.communitygames.Tag.prototype.setId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional int32 sortOrder = 2; + * @return {number} + */ +proto.web.communitygames.Tag.prototype.getSortorder = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.Tag} returns this + */ +proto.web.communitygames.Tag.prototype.setSortorder = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional Metadata metadata = 3; + * @return {?proto.web.communitygames.Metadata} + */ +proto.web.communitygames.Tag.prototype.getMetadata = function() { + return /** @type{?proto.web.communitygames.Metadata} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Metadata, 3)); +}; + + +/** + * @param {?proto.web.communitygames.Metadata|undefined} value + * @return {!proto.web.communitygames.Tag} returns this +*/ +proto.web.communitygames.Tag.prototype.setMetadata = function(value) { + return jspb.Message.setWrapperField(this, 3, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Tag} returns this + */ +proto.web.communitygames.Tag.prototype.clearMetadata = function() { + return this.setMetadata(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Tag.prototype.hasMetadata = function() { + return jspb.Message.getField(this, 3) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.ProgressionMode.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.ProgressionMode.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.web.communitygames.ProgressionMode} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ProgressionMode.toObject = function(includeInstance, msg) { + var f, obj = { + value: 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.web.communitygames.ProgressionMode} + */ +proto.web.communitygames.ProgressionMode.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.ProgressionMode; + return proto.web.communitygames.ProgressionMode.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.ProgressionMode} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.ProgressionMode} + */ +proto.web.communitygames.ProgressionMode.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.setValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.ProgressionMode.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.ProgressionMode.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.ProgressionMode} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ProgressionMode.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getValue(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string value = 1; + * @return {string} + */ +proto.web.communitygames.ProgressionMode.prototype.getValue = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.ProgressionMode} returns this + */ +proto.web.communitygames.ProgressionMode.prototype.setValue = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.PlaygroundResponse.repeatedFields_ = [3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.PlaygroundResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.PlaygroundResponse.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.web.communitygames.PlaygroundResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.PlaygroundResponse.toObject = function(includeInstance, msg) { + var f, obj = { + originalplayground: (f = msg.getOriginalplayground()) && proto.web.communitygames.Playground.toObject(includeInstance, f), + validatedplayground: (f = msg.getValidatedplayground()) && proto.web.communitygames.Playground.toObject(includeInstance, f), + tagList: jspb.Message.toObjectList(msg.getTagList(), + proto.web.communitygames.Tag.toObject, includeInstance), + progressionmode: (f = msg.getProgressionmode()) && proto.web.communitygames.ProgressionMode.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.web.communitygames.PlaygroundResponse} + */ +proto.web.communitygames.PlaygroundResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.PlaygroundResponse; + return proto.web.communitygames.PlaygroundResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.PlaygroundResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.PlaygroundResponse} + */ +proto.web.communitygames.PlaygroundResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.Playground; + reader.readMessage(value,proto.web.communitygames.Playground.deserializeBinaryFromReader); + msg.setOriginalplayground(value); + break; + case 2: + var value = new proto.web.communitygames.Playground; + reader.readMessage(value,proto.web.communitygames.Playground.deserializeBinaryFromReader); + msg.setValidatedplayground(value); + break; + case 3: + var value = new proto.web.communitygames.Tag; + reader.readMessage(value,proto.web.communitygames.Tag.deserializeBinaryFromReader); + msg.addTag(value); + break; + case 4: + var value = new proto.web.communitygames.ProgressionMode; + reader.readMessage(value,proto.web.communitygames.ProgressionMode.deserializeBinaryFromReader); + msg.setProgressionmode(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.PlaygroundResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.PlaygroundResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.PlaygroundResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.PlaygroundResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getOriginalplayground(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.Playground.serializeBinaryToWriter + ); + } + f = message.getValidatedplayground(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.Playground.serializeBinaryToWriter + ); + } + f = message.getTagList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.web.communitygames.Tag.serializeBinaryToWriter + ); + } + f = message.getProgressionmode(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.communitygames.ProgressionMode.serializeBinaryToWriter + ); + } +}; + + +/** + * optional Playground originalPlayground = 1; + * @return {?proto.web.communitygames.Playground} + */ +proto.web.communitygames.PlaygroundResponse.prototype.getOriginalplayground = function() { + return /** @type{?proto.web.communitygames.Playground} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Playground, 1)); +}; + + +/** + * @param {?proto.web.communitygames.Playground|undefined} value + * @return {!proto.web.communitygames.PlaygroundResponse} returns this +*/ +proto.web.communitygames.PlaygroundResponse.prototype.setOriginalplayground = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.PlaygroundResponse} returns this + */ +proto.web.communitygames.PlaygroundResponse.prototype.clearOriginalplayground = function() { + return this.setOriginalplayground(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.PlaygroundResponse.prototype.hasOriginalplayground = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional Playground validatedPlayground = 2; + * @return {?proto.web.communitygames.Playground} + */ +proto.web.communitygames.PlaygroundResponse.prototype.getValidatedplayground = function() { + return /** @type{?proto.web.communitygames.Playground} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Playground, 2)); +}; + + +/** + * @param {?proto.web.communitygames.Playground|undefined} value + * @return {!proto.web.communitygames.PlaygroundResponse} returns this +*/ +proto.web.communitygames.PlaygroundResponse.prototype.setValidatedplayground = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.PlaygroundResponse} returns this + */ +proto.web.communitygames.PlaygroundResponse.prototype.clearValidatedplayground = function() { + return this.setValidatedplayground(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.PlaygroundResponse.prototype.hasValidatedplayground = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * repeated Tag tag = 3; + * @return {!Array} + */ +proto.web.communitygames.PlaygroundResponse.prototype.getTagList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.Tag, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.PlaygroundResponse} returns this +*/ +proto.web.communitygames.PlaygroundResponse.prototype.setTagList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.web.communitygames.Tag=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.Tag} + */ +proto.web.communitygames.PlaygroundResponse.prototype.addTag = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.web.communitygames.Tag, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.PlaygroundResponse} returns this + */ +proto.web.communitygames.PlaygroundResponse.prototype.clearTagList = function() { + return this.setTagList([]); +}; + + +/** + * optional ProgressionMode progressionMode = 4; + * @return {?proto.web.communitygames.ProgressionMode} + */ +proto.web.communitygames.PlaygroundResponse.prototype.getProgressionmode = function() { + return /** @type{?proto.web.communitygames.ProgressionMode} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.ProgressionMode, 4)); +}; + + +/** + * @param {?proto.web.communitygames.ProgressionMode|undefined} value + * @return {!proto.web.communitygames.PlaygroundResponse} returns this +*/ +proto.web.communitygames.PlaygroundResponse.prototype.setProgressionmode = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.PlaygroundResponse} returns this + */ +proto.web.communitygames.PlaygroundResponse.prototype.clearProgressionmode = function() { + return this.setProgressionmode(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.PlaygroundResponse.prototype.hasProgressionmode = function() { + return jspb.Message.getField(this, 4) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.MapInfo.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MapInfo.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.web.communitygames.MapInfo} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MapInfo.toObject = function(includeInstance, msg) { + var f, obj = { + mapname: jspb.Message.getFieldWithDefault(msg, 1, ""), + mode: jspb.Message.getFieldWithDefault(msg, 2, ""), + gamesize: jspb.Message.getFieldWithDefault(msg, 3, 0), + rounds: jspb.Message.getFieldWithDefault(msg, 4, 0), + mutators: (f = msg.getMutators()) && proto.web.communitygames.Mutator.toObject(includeInstance, f), + location: jspb.Message.getFieldWithDefault(msg, 6, ""), + preroundsize: jspb.Message.getFieldWithDefault(msg, 7, 0), + warmupsize: jspb.Message.getFieldWithDefault(msg, 8, 0), + allowedspectators: 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.web.communitygames.MapInfo} + */ +proto.web.communitygames.MapInfo.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MapInfo; + return proto.web.communitygames.MapInfo.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MapInfo} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MapInfo} + */ +proto.web.communitygames.MapInfo.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.setMapname(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setMode(value); + break; + case 3: + var value = /** @type {number} */ (reader.readUint32()); + msg.setGamesize(value); + break; + case 4: + var value = /** @type {number} */ (reader.readUint32()); + msg.setRounds(value); + break; + case 5: + var value = new proto.web.communitygames.Mutator; + reader.readMessage(value,proto.web.communitygames.Mutator.deserializeBinaryFromReader); + msg.setMutators(value); + break; + case 6: + var value = /** @type {string} */ (reader.readString()); + msg.setLocation(value); + break; + case 7: + var value = /** @type {number} */ (reader.readUint32()); + msg.setPreroundsize(value); + break; + case 8: + var value = /** @type {number} */ (reader.readUint32()); + msg.setWarmupsize(value); + break; + case 9: + var value = /** @type {number} */ (reader.readUint32()); + msg.setAllowedspectators(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MapInfo.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MapInfo.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MapInfo} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MapInfo.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getMapname(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getMode(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getGamesize(); + if (f !== 0) { + writer.writeUint32( + 3, + f + ); + } + f = message.getRounds(); + if (f !== 0) { + writer.writeUint32( + 4, + f + ); + } + f = message.getMutators(); + if (f != null) { + writer.writeMessage( + 5, + f, + proto.web.communitygames.Mutator.serializeBinaryToWriter + ); + } + f = message.getLocation(); + if (f.length > 0) { + writer.writeString( + 6, + f + ); + } + f = message.getPreroundsize(); + if (f !== 0) { + writer.writeUint32( + 7, + f + ); + } + f = message.getWarmupsize(); + if (f !== 0) { + writer.writeUint32( + 8, + f + ); + } + f = message.getAllowedspectators(); + if (f !== 0) { + writer.writeUint32( + 9, + f + ); + } +}; + + +/** + * optional string mapname = 1; + * @return {string} + */ +proto.web.communitygames.MapInfo.prototype.getMapname = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.MapInfo} returns this + */ +proto.web.communitygames.MapInfo.prototype.setMapname = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string mode = 2; + * @return {string} + */ +proto.web.communitygames.MapInfo.prototype.getMode = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.MapInfo} returns this + */ +proto.web.communitygames.MapInfo.prototype.setMode = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional uint32 gameSize = 3; + * @return {number} + */ +proto.web.communitygames.MapInfo.prototype.getGamesize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MapInfo} returns this + */ +proto.web.communitygames.MapInfo.prototype.setGamesize = function(value) { + return jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * optional uint32 rounds = 4; + * @return {number} + */ +proto.web.communitygames.MapInfo.prototype.getRounds = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MapInfo} returns this + */ +proto.web.communitygames.MapInfo.prototype.setRounds = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); +}; + + +/** + * optional Mutator mutators = 5; + * @return {?proto.web.communitygames.Mutator} + */ +proto.web.communitygames.MapInfo.prototype.getMutators = function() { + return /** @type{?proto.web.communitygames.Mutator} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Mutator, 5)); +}; + + +/** + * @param {?proto.web.communitygames.Mutator|undefined} value + * @return {!proto.web.communitygames.MapInfo} returns this +*/ +proto.web.communitygames.MapInfo.prototype.setMutators = function(value) { + return jspb.Message.setWrapperField(this, 5, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.MapInfo} returns this + */ +proto.web.communitygames.MapInfo.prototype.clearMutators = function() { + return this.setMutators(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.MapInfo.prototype.hasMutators = function() { + return jspb.Message.getField(this, 5) != null; +}; + + +/** + * optional string location = 6; + * @return {string} + */ +proto.web.communitygames.MapInfo.prototype.getLocation = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 6, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.MapInfo} returns this + */ +proto.web.communitygames.MapInfo.prototype.setLocation = function(value) { + return jspb.Message.setProto3StringField(this, 6, value); +}; + + +/** + * optional uint32 preRoundSize = 7; + * @return {number} + */ +proto.web.communitygames.MapInfo.prototype.getPreroundsize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 7, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MapInfo} returns this + */ +proto.web.communitygames.MapInfo.prototype.setPreroundsize = function(value) { + return jspb.Message.setProto3IntField(this, 7, value); +}; + + +/** + * optional uint32 warmUpSize = 8; + * @return {number} + */ +proto.web.communitygames.MapInfo.prototype.getWarmupsize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MapInfo} returns this + */ +proto.web.communitygames.MapInfo.prototype.setWarmupsize = function(value) { + return jspb.Message.setProto3IntField(this, 8, value); +}; + + +/** + * optional uint32 allowedSpectators = 9; + * @return {number} + */ +proto.web.communitygames.MapInfo.prototype.getAllowedspectators = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 9, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MapInfo} returns this + */ +proto.web.communitygames.MapInfo.prototype.setAllowedspectators = function(value) { + return jspb.Message.setProto3IntField(this, 9, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.MapRotation.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.MapRotation.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MapRotation.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.web.communitygames.MapRotation} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MapRotation.toObject = function(includeInstance, msg) { + var f, obj = { + mapsList: jspb.Message.toObjectList(msg.getMapsList(), + proto.web.communitygames.MapInfo.toObject, includeInstance), + rotationbehavior: jspb.Message.getFieldWithDefault(msg, 2, 0), + roundbehavior: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.MapRotation} + */ +proto.web.communitygames.MapRotation.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MapRotation; + return proto.web.communitygames.MapRotation.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MapRotation} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MapRotation} + */ +proto.web.communitygames.MapRotation.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.MapInfo; + reader.readMessage(value,proto.web.communitygames.MapInfo.deserializeBinaryFromReader); + msg.addMaps(value); + break; + case 2: + var value = /** @type {!proto.web.communitygames.RotationBehavior} */ (reader.readEnum()); + msg.setRotationbehavior(value); + break; + case 3: + var value = /** @type {!proto.web.communitygames.RoundBehavior} */ (reader.readEnum()); + msg.setRoundbehavior(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MapRotation.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MapRotation.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MapRotation} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MapRotation.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getMapsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.web.communitygames.MapInfo.serializeBinaryToWriter + ); + } + f = message.getRotationbehavior(); + if (f !== 0.0) { + writer.writeEnum( + 2, + f + ); + } + f = message.getRoundbehavior(); + if (f !== 0.0) { + writer.writeEnum( + 3, + f + ); + } +}; + + +/** + * repeated MapInfo maps = 1; + * @return {!Array} + */ +proto.web.communitygames.MapRotation.prototype.getMapsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.MapInfo, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.MapRotation} returns this +*/ +proto.web.communitygames.MapRotation.prototype.setMapsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.web.communitygames.MapInfo=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.MapInfo} + */ +proto.web.communitygames.MapRotation.prototype.addMaps = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.web.communitygames.MapInfo, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.MapRotation} returns this + */ +proto.web.communitygames.MapRotation.prototype.clearMapsList = function() { + return this.setMapsList([]); +}; + + +/** + * optional RotationBehavior rotationBehavior = 2; + * @return {!proto.web.communitygames.RotationBehavior} + */ +proto.web.communitygames.MapRotation.prototype.getRotationbehavior = function() { + return /** @type {!proto.web.communitygames.RotationBehavior} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {!proto.web.communitygames.RotationBehavior} value + * @return {!proto.web.communitygames.MapRotation} returns this + */ +proto.web.communitygames.MapRotation.prototype.setRotationbehavior = function(value) { + return jspb.Message.setProto3EnumField(this, 2, value); +}; + + +/** + * optional RoundBehavior roundBehavior = 3; + * @return {!proto.web.communitygames.RoundBehavior} + */ +proto.web.communitygames.MapRotation.prototype.getRoundbehavior = function() { + return /** @type {!proto.web.communitygames.RoundBehavior} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {!proto.web.communitygames.RoundBehavior} value + * @return {!proto.web.communitygames.MapRotation} returns this + */ +proto.web.communitygames.MapRotation.prototype.setRoundbehavior = function(value) { + return jspb.Message.setProto3EnumField(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.web.communitygames.TeamStructure.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.TeamStructure.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.web.communitygames.TeamStructure} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.TeamStructure.toObject = function(includeInstance, msg) { + var f, obj = { + teamid: jspb.Message.getFieldWithDefault(msg, 1, 0), + capacity: jspb.Message.getFieldWithDefault(msg, 2, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.TeamStructure} + */ +proto.web.communitygames.TeamStructure.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.TeamStructure; + return proto.web.communitygames.TeamStructure.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.TeamStructure} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.TeamStructure} + */ +proto.web.communitygames.TeamStructure.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.setTeamid(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setCapacity(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.TeamStructure.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.TeamStructure.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.TeamStructure} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.TeamStructure.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTeamid(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getCapacity(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } +}; + + +/** + * optional int32 teamId = 1; + * @return {number} + */ +proto.web.communitygames.TeamStructure.prototype.getTeamid = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.TeamStructure} returns this + */ +proto.web.communitygames.TeamStructure.prototype.setTeamid = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional int32 capacity = 2; + * @return {number} + */ +proto.web.communitygames.TeamStructure.prototype.getCapacity = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.TeamStructure} returns this + */ +proto.web.communitygames.TeamStructure.prototype.setCapacity = function(value) { + return jspb.Message.setProto3IntField(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.web.communitygames.InternalTeamStructure.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.InternalTeamStructure.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.web.communitygames.InternalTeamStructure} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.InternalTeamStructure.toObject = function(includeInstance, msg) { + var f, obj = { + teamid: jspb.Message.getFieldWithDefault(msg, 1, 0), + capacity: jspb.Message.getFieldWithDefault(msg, 2, 0), + capacitytype: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.InternalTeamStructure} + */ +proto.web.communitygames.InternalTeamStructure.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.InternalTeamStructure; + return proto.web.communitygames.InternalTeamStructure.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.InternalTeamStructure} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.InternalTeamStructure} + */ +proto.web.communitygames.InternalTeamStructure.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.setTeamid(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setCapacity(value); + break; + case 3: + var value = /** @type {!proto.web.communitygames.CapacityType} */ (reader.readEnum()); + msg.setCapacitytype(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.InternalTeamStructure.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.InternalTeamStructure.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.InternalTeamStructure} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.InternalTeamStructure.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTeamid(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getCapacity(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getCapacitytype(); + if (f !== 0.0) { + writer.writeEnum( + 3, + f + ); + } +}; + + +/** + * optional int32 teamId = 1; + * @return {number} + */ +proto.web.communitygames.InternalTeamStructure.prototype.getTeamid = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.InternalTeamStructure} returns this + */ +proto.web.communitygames.InternalTeamStructure.prototype.setTeamid = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional int32 capacity = 2; + * @return {number} + */ +proto.web.communitygames.InternalTeamStructure.prototype.getCapacity = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.InternalTeamStructure} returns this + */ +proto.web.communitygames.InternalTeamStructure.prototype.setCapacity = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional CapacityType capacityType = 3; + * @return {!proto.web.communitygames.CapacityType} + */ +proto.web.communitygames.InternalTeamStructure.prototype.getCapacitytype = function() { + return /** @type {!proto.web.communitygames.CapacityType} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {!proto.web.communitygames.CapacityType} value + * @return {!proto.web.communitygames.InternalTeamStructure} returns this + */ +proto.web.communitygames.InternalTeamStructure.prototype.setCapacitytype = function(value) { + return jspb.Message.setProto3EnumField(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.web.communitygames.MutatorSparseFloatEntry.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorSparseFloatEntry.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.web.communitygames.MutatorSparseFloatEntry} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseFloatEntry.toObject = function(includeInstance, msg) { + var f, obj = { + index: jspb.Message.getFieldWithDefault(msg, 1, 0), + value: jspb.Message.getFloatingPointFieldWithDefault(msg, 2, 0.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.web.communitygames.MutatorSparseFloatEntry} + */ +proto.web.communitygames.MutatorSparseFloatEntry.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorSparseFloatEntry; + return proto.web.communitygames.MutatorSparseFloatEntry.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorSparseFloatEntry} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorSparseFloatEntry} + */ +proto.web.communitygames.MutatorSparseFloatEntry.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readUint32()); + msg.setIndex(value); + break; + case 2: + var value = /** @type {number} */ (reader.readFloat()); + msg.setValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorSparseFloatEntry.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorSparseFloatEntry.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorSparseFloatEntry} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseFloatEntry.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getIndex(); + if (f !== 0) { + writer.writeUint32( + 1, + f + ); + } + f = message.getValue(); + if (f !== 0.0) { + writer.writeFloat( + 2, + f + ); + } +}; + + +/** + * optional uint32 index = 1; + * @return {number} + */ +proto.web.communitygames.MutatorSparseFloatEntry.prototype.getIndex = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorSparseFloatEntry} returns this + */ +proto.web.communitygames.MutatorSparseFloatEntry.prototype.setIndex = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional float value = 2; + * @return {number} + */ +proto.web.communitygames.MutatorSparseFloatEntry.prototype.getValue = function() { + return /** @type {number} */ (jspb.Message.getFloatingPointFieldWithDefault(this, 2, 0.0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorSparseFloatEntry} returns this + */ +proto.web.communitygames.MutatorSparseFloatEntry.prototype.setValue = function(value) { + return jspb.Message.setProto3FloatField(this, 2, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.MutatorSparseFloat.repeatedFields_ = [3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.MutatorSparseFloat.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorSparseFloat.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.web.communitygames.MutatorSparseFloat} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseFloat.toObject = function(includeInstance, msg) { + var f, obj = { + defaultvalue: jspb.Message.getFloatingPointFieldWithDefault(msg, 1, 0.0), + size: jspb.Message.getFieldWithDefault(msg, 2, 0), + sparsevaluesList: jspb.Message.toObjectList(msg.getSparsevaluesList(), + proto.web.communitygames.MutatorSparseFloatEntry.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.web.communitygames.MutatorSparseFloat} + */ +proto.web.communitygames.MutatorSparseFloat.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorSparseFloat; + return proto.web.communitygames.MutatorSparseFloat.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorSparseFloat} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorSparseFloat} + */ +proto.web.communitygames.MutatorSparseFloat.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readFloat()); + msg.setDefaultvalue(value); + break; + case 2: + var value = /** @type {number} */ (reader.readUint32()); + msg.setSize(value); + break; + case 3: + var value = new proto.web.communitygames.MutatorSparseFloatEntry; + reader.readMessage(value,proto.web.communitygames.MutatorSparseFloatEntry.deserializeBinaryFromReader); + msg.addSparsevalues(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorSparseFloat.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorSparseFloat.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorSparseFloat} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseFloat.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getDefaultvalue(); + if (f !== 0.0) { + writer.writeFloat( + 1, + f + ); + } + f = message.getSize(); + if (f !== 0) { + writer.writeUint32( + 2, + f + ); + } + f = message.getSparsevaluesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.web.communitygames.MutatorSparseFloatEntry.serializeBinaryToWriter + ); + } +}; + + +/** + * optional float defaultValue = 1; + * @return {number} + */ +proto.web.communitygames.MutatorSparseFloat.prototype.getDefaultvalue = function() { + return /** @type {number} */ (jspb.Message.getFloatingPointFieldWithDefault(this, 1, 0.0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorSparseFloat} returns this + */ +proto.web.communitygames.MutatorSparseFloat.prototype.setDefaultvalue = function(value) { + return jspb.Message.setProto3FloatField(this, 1, value); +}; + + +/** + * optional uint32 size = 2; + * @return {number} + */ +proto.web.communitygames.MutatorSparseFloat.prototype.getSize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorSparseFloat} returns this + */ +proto.web.communitygames.MutatorSparseFloat.prototype.setSize = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * repeated MutatorSparseFloatEntry sparseValues = 3; + * @return {!Array} + */ +proto.web.communitygames.MutatorSparseFloat.prototype.getSparsevaluesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.MutatorSparseFloatEntry, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.MutatorSparseFloat} returns this +*/ +proto.web.communitygames.MutatorSparseFloat.prototype.setSparsevaluesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.web.communitygames.MutatorSparseFloatEntry=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.MutatorSparseFloatEntry} + */ +proto.web.communitygames.MutatorSparseFloat.prototype.addSparsevalues = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.web.communitygames.MutatorSparseFloatEntry, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.MutatorSparseFloat} returns this + */ +proto.web.communitygames.MutatorSparseFloat.prototype.clearSparsevaluesList = function() { + return this.setSparsevaluesList([]); +}; + + + + + +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.web.communitygames.MutatorFloat.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorFloat.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.web.communitygames.MutatorFloat} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorFloat.toObject = function(includeInstance, msg) { + var f, obj = { + value: jspb.Message.getFloatingPointFieldWithDefault(msg, 1, 0.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.web.communitygames.MutatorFloat} + */ +proto.web.communitygames.MutatorFloat.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorFloat; + return proto.web.communitygames.MutatorFloat.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorFloat} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorFloat} + */ +proto.web.communitygames.MutatorFloat.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readFloat()); + msg.setValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorFloat.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorFloat.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorFloat} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorFloat.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getValue(); + if (f !== 0.0) { + writer.writeFloat( + 1, + f + ); + } +}; + + +/** + * optional float value = 1; + * @return {number} + */ +proto.web.communitygames.MutatorFloat.prototype.getValue = function() { + return /** @type {number} */ (jspb.Message.getFloatingPointFieldWithDefault(this, 1, 0.0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorFloat} returns this + */ +proto.web.communitygames.MutatorFloat.prototype.setValue = function(value) { + return jspb.Message.setProto3FloatField(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.web.communitygames.MutatorBoolean.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorBoolean.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.web.communitygames.MutatorBoolean} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorBoolean.toObject = function(includeInstance, msg) { + var f, obj = { + boolvalue: jspb.Message.getBooleanFieldWithDefault(msg, 1, false) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.MutatorBoolean} + */ +proto.web.communitygames.MutatorBoolean.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorBoolean; + return proto.web.communitygames.MutatorBoolean.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorBoolean} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorBoolean} + */ +proto.web.communitygames.MutatorBoolean.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setBoolvalue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorBoolean.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorBoolean.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorBoolean} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorBoolean.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getBoolvalue(); + if (f) { + writer.writeBool( + 1, + f + ); + } +}; + + +/** + * optional bool boolValue = 1; + * @return {boolean} + */ +proto.web.communitygames.MutatorBoolean.prototype.getBoolvalue = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.web.communitygames.MutatorBoolean} returns this + */ +proto.web.communitygames.MutatorBoolean.prototype.setBoolvalue = function(value) { + return jspb.Message.setProto3BooleanField(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.web.communitygames.MutatorString.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorString.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.web.communitygames.MutatorString} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorString.toObject = function(includeInstance, msg) { + var f, obj = { + stringvalue: 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.web.communitygames.MutatorString} + */ +proto.web.communitygames.MutatorString.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorString; + return proto.web.communitygames.MutatorString.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorString} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorString} + */ +proto.web.communitygames.MutatorString.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.setStringvalue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorString.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorString.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorString} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorString.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getStringvalue(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string stringValue = 1; + * @return {string} + */ +proto.web.communitygames.MutatorString.prototype.getStringvalue = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.MutatorString} returns this + */ +proto.web.communitygames.MutatorString.prototype.setStringvalue = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.MutatorInt.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorInt.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.web.communitygames.MutatorInt} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorInt.toObject = function(includeInstance, msg) { + var f, obj = { + value: 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.web.communitygames.MutatorInt} + */ +proto.web.communitygames.MutatorInt.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorInt; + return proto.web.communitygames.MutatorInt.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorInt} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorInt} + */ +proto.web.communitygames.MutatorInt.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.setValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorInt.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorInt.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorInt} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorInt.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getValue(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } +}; + + +/** + * optional int32 value = 1; + * @return {number} + */ +proto.web.communitygames.MutatorInt.prototype.getValue = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorInt} returns this + */ +proto.web.communitygames.MutatorInt.prototype.setValue = 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.web.communitygames.MutatorSparseBooleanEntry.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorSparseBooleanEntry.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.web.communitygames.MutatorSparseBooleanEntry} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseBooleanEntry.toObject = function(includeInstance, msg) { + var f, obj = { + index: jspb.Message.getFieldWithDefault(msg, 1, 0), + value: jspb.Message.getBooleanFieldWithDefault(msg, 2, false) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.MutatorSparseBooleanEntry} + */ +proto.web.communitygames.MutatorSparseBooleanEntry.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorSparseBooleanEntry; + return proto.web.communitygames.MutatorSparseBooleanEntry.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorSparseBooleanEntry} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorSparseBooleanEntry} + */ +proto.web.communitygames.MutatorSparseBooleanEntry.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readUint32()); + msg.setIndex(value); + break; + case 2: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorSparseBooleanEntry.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorSparseBooleanEntry.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorSparseBooleanEntry} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseBooleanEntry.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getIndex(); + if (f !== 0) { + writer.writeUint32( + 1, + f + ); + } + f = message.getValue(); + if (f) { + writer.writeBool( + 2, + f + ); + } +}; + + +/** + * optional uint32 index = 1; + * @return {number} + */ +proto.web.communitygames.MutatorSparseBooleanEntry.prototype.getIndex = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorSparseBooleanEntry} returns this + */ +proto.web.communitygames.MutatorSparseBooleanEntry.prototype.setIndex = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional bool value = 2; + * @return {boolean} + */ +proto.web.communitygames.MutatorSparseBooleanEntry.prototype.getValue = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 2, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.web.communitygames.MutatorSparseBooleanEntry} returns this + */ +proto.web.communitygames.MutatorSparseBooleanEntry.prototype.setValue = function(value) { + return jspb.Message.setProto3BooleanField(this, 2, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.MutatorSparseBoolean.repeatedFields_ = [3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.MutatorSparseBoolean.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorSparseBoolean.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.web.communitygames.MutatorSparseBoolean} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseBoolean.toObject = function(includeInstance, msg) { + var f, obj = { + defaultvalue: jspb.Message.getBooleanFieldWithDefault(msg, 1, false), + size: jspb.Message.getFieldWithDefault(msg, 2, 0), + sparsevaluesList: jspb.Message.toObjectList(msg.getSparsevaluesList(), + proto.web.communitygames.MutatorSparseBooleanEntry.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.web.communitygames.MutatorSparseBoolean} + */ +proto.web.communitygames.MutatorSparseBoolean.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorSparseBoolean; + return proto.web.communitygames.MutatorSparseBoolean.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorSparseBoolean} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorSparseBoolean} + */ +proto.web.communitygames.MutatorSparseBoolean.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setDefaultvalue(value); + break; + case 2: + var value = /** @type {number} */ (reader.readUint32()); + msg.setSize(value); + break; + case 3: + var value = new proto.web.communitygames.MutatorSparseBooleanEntry; + reader.readMessage(value,proto.web.communitygames.MutatorSparseBooleanEntry.deserializeBinaryFromReader); + msg.addSparsevalues(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorSparseBoolean.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorSparseBoolean.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorSparseBoolean} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseBoolean.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getDefaultvalue(); + if (f) { + writer.writeBool( + 1, + f + ); + } + f = message.getSize(); + if (f !== 0) { + writer.writeUint32( + 2, + f + ); + } + f = message.getSparsevaluesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.web.communitygames.MutatorSparseBooleanEntry.serializeBinaryToWriter + ); + } +}; + + +/** + * optional bool defaultValue = 1; + * @return {boolean} + */ +proto.web.communitygames.MutatorSparseBoolean.prototype.getDefaultvalue = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.web.communitygames.MutatorSparseBoolean} returns this + */ +proto.web.communitygames.MutatorSparseBoolean.prototype.setDefaultvalue = function(value) { + return jspb.Message.setProto3BooleanField(this, 1, value); +}; + + +/** + * optional uint32 size = 2; + * @return {number} + */ +proto.web.communitygames.MutatorSparseBoolean.prototype.getSize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorSparseBoolean} returns this + */ +proto.web.communitygames.MutatorSparseBoolean.prototype.setSize = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * repeated MutatorSparseBooleanEntry sparseValues = 3; + * @return {!Array} + */ +proto.web.communitygames.MutatorSparseBoolean.prototype.getSparsevaluesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.MutatorSparseBooleanEntry, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.MutatorSparseBoolean} returns this +*/ +proto.web.communitygames.MutatorSparseBoolean.prototype.setSparsevaluesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.web.communitygames.MutatorSparseBooleanEntry=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.MutatorSparseBooleanEntry} + */ +proto.web.communitygames.MutatorSparseBoolean.prototype.addSparsevalues = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.web.communitygames.MutatorSparseBooleanEntry, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.MutatorSparseBoolean} returns this + */ +proto.web.communitygames.MutatorSparseBoolean.prototype.clearSparsevaluesList = function() { + return this.setSparsevaluesList([]); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.SparseIntEntity.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.SparseIntEntity.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.SparseIntEntity.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.web.communitygames.SparseIntEntity} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.SparseIntEntity.toObject = function(includeInstance, msg) { + var f, obj = { + valuesList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.SparseIntEntity} + */ +proto.web.communitygames.SparseIntEntity.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.SparseIntEntity; + return proto.web.communitygames.SparseIntEntity.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.SparseIntEntity} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.SparseIntEntity} + */ +proto.web.communitygames.SparseIntEntity.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Array} */ (reader.readPackedInt32()); + msg.setValuesList(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.SparseIntEntity.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.SparseIntEntity.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.SparseIntEntity} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.SparseIntEntity.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getValuesList(); + if (f.length > 0) { + writer.writePackedInt32( + 1, + f + ); + } +}; + + +/** + * repeated int32 values = 1; + * @return {!Array} + */ +proto.web.communitygames.SparseIntEntity.prototype.getValuesList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.SparseIntEntity} returns this + */ +proto.web.communitygames.SparseIntEntity.prototype.setValuesList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {number} value + * @param {number=} opt_index + * @return {!proto.web.communitygames.SparseIntEntity} returns this + */ +proto.web.communitygames.SparseIntEntity.prototype.addValues = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.SparseIntEntity} returns this + */ +proto.web.communitygames.SparseIntEntity.prototype.clearValuesList = function() { + return this.setValuesList([]); +}; + + + + + +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.web.communitygames.MutatorSparseIntEntry.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorSparseIntEntry.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.web.communitygames.MutatorSparseIntEntry} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseIntEntry.toObject = function(includeInstance, msg) { + var f, obj = { + index: jspb.Message.getFieldWithDefault(msg, 1, 0), + value: jspb.Message.getFieldWithDefault(msg, 2, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.MutatorSparseIntEntry} + */ +proto.web.communitygames.MutatorSparseIntEntry.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorSparseIntEntry; + return proto.web.communitygames.MutatorSparseIntEntry.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorSparseIntEntry} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorSparseIntEntry} + */ +proto.web.communitygames.MutatorSparseIntEntry.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readUint32()); + msg.setIndex(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorSparseIntEntry.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorSparseIntEntry.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorSparseIntEntry} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseIntEntry.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getIndex(); + if (f !== 0) { + writer.writeUint32( + 1, + f + ); + } + f = message.getValue(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } +}; + + +/** + * optional uint32 index = 1; + * @return {number} + */ +proto.web.communitygames.MutatorSparseIntEntry.prototype.getIndex = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorSparseIntEntry} returns this + */ +proto.web.communitygames.MutatorSparseIntEntry.prototype.setIndex = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional int32 value = 2; + * @return {number} + */ +proto.web.communitygames.MutatorSparseIntEntry.prototype.getValue = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorSparseIntEntry} returns this + */ +proto.web.communitygames.MutatorSparseIntEntry.prototype.setValue = function(value) { + return jspb.Message.setProto3IntField(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.web.communitygames.MutatorSparseInt.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorSparseInt.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.web.communitygames.MutatorSparseInt} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseInt.toObject = function(includeInstance, msg) { + var f, obj = { + defaultvalue: jspb.Message.getFieldWithDefault(msg, 1, 0), + size: jspb.Message.getFieldWithDefault(msg, 2, 0), + sparsevalues: (f = msg.getSparsevalues()) && proto.web.communitygames.MutatorSparseIntEntry.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.web.communitygames.MutatorSparseInt} + */ +proto.web.communitygames.MutatorSparseInt.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorSparseInt; + return proto.web.communitygames.MutatorSparseInt.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorSparseInt} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorSparseInt} + */ +proto.web.communitygames.MutatorSparseInt.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.setDefaultvalue(value); + break; + case 2: + var value = /** @type {number} */ (reader.readUint32()); + msg.setSize(value); + break; + case 3: + var value = new proto.web.communitygames.MutatorSparseIntEntry; + reader.readMessage(value,proto.web.communitygames.MutatorSparseIntEntry.deserializeBinaryFromReader); + msg.setSparsevalues(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorSparseInt.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorSparseInt.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorSparseInt} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorSparseInt.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getDefaultvalue(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getSize(); + if (f !== 0) { + writer.writeUint32( + 2, + f + ); + } + f = message.getSparsevalues(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.web.communitygames.MutatorSparseIntEntry.serializeBinaryToWriter + ); + } +}; + + +/** + * optional int32 defaultValue = 1; + * @return {number} + */ +proto.web.communitygames.MutatorSparseInt.prototype.getDefaultvalue = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorSparseInt} returns this + */ +proto.web.communitygames.MutatorSparseInt.prototype.setDefaultvalue = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional uint32 size = 2; + * @return {number} + */ +proto.web.communitygames.MutatorSparseInt.prototype.getSize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.MutatorSparseInt} returns this + */ +proto.web.communitygames.MutatorSparseInt.prototype.setSize = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional MutatorSparseIntEntry sparseValues = 3; + * @return {?proto.web.communitygames.MutatorSparseIntEntry} + */ +proto.web.communitygames.MutatorSparseInt.prototype.getSparsevalues = function() { + return /** @type{?proto.web.communitygames.MutatorSparseIntEntry} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MutatorSparseIntEntry, 3)); +}; + + +/** + * @param {?proto.web.communitygames.MutatorSparseIntEntry|undefined} value + * @return {!proto.web.communitygames.MutatorSparseInt} returns this +*/ +proto.web.communitygames.MutatorSparseInt.prototype.setSparsevalues = function(value) { + return jspb.Message.setWrapperField(this, 3, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.MutatorSparseInt} returns this + */ +proto.web.communitygames.MutatorSparseInt.prototype.clearSparsevalues = function() { + return this.setSparsevalues(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.MutatorSparseInt.prototype.hasSparsevalues = function() { + return jspb.Message.getField(this, 3) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.MutatorKind.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.MutatorKind.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.web.communitygames.MutatorKind} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorKind.toObject = function(includeInstance, msg) { + var f, obj = { + mutatorboolean: (f = msg.getMutatorboolean()) && proto.web.communitygames.MutatorBoolean.toObject(includeInstance, f), + mutatorstring: (f = msg.getMutatorstring()) && proto.web.communitygames.MutatorString.toObject(includeInstance, f), + mutatorfloat: (f = msg.getMutatorfloat()) && proto.web.communitygames.MutatorFloat.toObject(includeInstance, f), + mutatorint: (f = msg.getMutatorint()) && proto.web.communitygames.MutatorInt.toObject(includeInstance, f), + mutatorsparseboolean: (f = msg.getMutatorsparseboolean()) && proto.web.communitygames.MutatorSparseBoolean.toObject(includeInstance, f), + mutatorsparseint: (f = msg.getMutatorsparseint()) && proto.web.communitygames.MutatorSparseInt.toObject(includeInstance, f), + mutatorsparsefloat: (f = msg.getMutatorsparsefloat()) && proto.web.communitygames.MutatorSparseFloat.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.web.communitygames.MutatorKind} + */ +proto.web.communitygames.MutatorKind.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.MutatorKind; + return proto.web.communitygames.MutatorKind.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.MutatorKind} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.MutatorKind} + */ +proto.web.communitygames.MutatorKind.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.MutatorBoolean; + reader.readMessage(value,proto.web.communitygames.MutatorBoolean.deserializeBinaryFromReader); + msg.setMutatorboolean(value); + break; + case 4: + var value = new proto.web.communitygames.MutatorString; + reader.readMessage(value,proto.web.communitygames.MutatorString.deserializeBinaryFromReader); + msg.setMutatorstring(value); + break; + case 5: + var value = new proto.web.communitygames.MutatorFloat; + reader.readMessage(value,proto.web.communitygames.MutatorFloat.deserializeBinaryFromReader); + msg.setMutatorfloat(value); + break; + case 6: + var value = new proto.web.communitygames.MutatorInt; + reader.readMessage(value,proto.web.communitygames.MutatorInt.deserializeBinaryFromReader); + msg.setMutatorint(value); + break; + case 7: + var value = new proto.web.communitygames.MutatorSparseBoolean; + reader.readMessage(value,proto.web.communitygames.MutatorSparseBoolean.deserializeBinaryFromReader); + msg.setMutatorsparseboolean(value); + break; + case 8: + var value = new proto.web.communitygames.MutatorSparseInt; + reader.readMessage(value,proto.web.communitygames.MutatorSparseInt.deserializeBinaryFromReader); + msg.setMutatorsparseint(value); + break; + case 9: + var value = new proto.web.communitygames.MutatorSparseFloat; + reader.readMessage(value,proto.web.communitygames.MutatorSparseFloat.deserializeBinaryFromReader); + msg.setMutatorsparsefloat(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.MutatorKind.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.MutatorKind.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.MutatorKind} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.MutatorKind.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getMutatorboolean(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.MutatorBoolean.serializeBinaryToWriter + ); + } + f = message.getMutatorstring(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.communitygames.MutatorString.serializeBinaryToWriter + ); + } + f = message.getMutatorfloat(); + if (f != null) { + writer.writeMessage( + 5, + f, + proto.web.communitygames.MutatorFloat.serializeBinaryToWriter + ); + } + f = message.getMutatorint(); + if (f != null) { + writer.writeMessage( + 6, + f, + proto.web.communitygames.MutatorInt.serializeBinaryToWriter + ); + } + f = message.getMutatorsparseboolean(); + if (f != null) { + writer.writeMessage( + 7, + f, + proto.web.communitygames.MutatorSparseBoolean.serializeBinaryToWriter + ); + } + f = message.getMutatorsparseint(); + if (f != null) { + writer.writeMessage( + 8, + f, + proto.web.communitygames.MutatorSparseInt.serializeBinaryToWriter + ); + } + f = message.getMutatorsparsefloat(); + if (f != null) { + writer.writeMessage( + 9, + f, + proto.web.communitygames.MutatorSparseFloat.serializeBinaryToWriter + ); + } +}; + + +/** + * optional MutatorBoolean mutatorBoolean = 1; + * @return {?proto.web.communitygames.MutatorBoolean} + */ +proto.web.communitygames.MutatorKind.prototype.getMutatorboolean = function() { + return /** @type{?proto.web.communitygames.MutatorBoolean} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MutatorBoolean, 1)); +}; + + +/** + * @param {?proto.web.communitygames.MutatorBoolean|undefined} value + * @return {!proto.web.communitygames.MutatorKind} returns this +*/ +proto.web.communitygames.MutatorKind.prototype.setMutatorboolean = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.MutatorKind} returns this + */ +proto.web.communitygames.MutatorKind.prototype.clearMutatorboolean = function() { + return this.setMutatorboolean(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.MutatorKind.prototype.hasMutatorboolean = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional MutatorString mutatorString = 4; + * @return {?proto.web.communitygames.MutatorString} + */ +proto.web.communitygames.MutatorKind.prototype.getMutatorstring = function() { + return /** @type{?proto.web.communitygames.MutatorString} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MutatorString, 4)); +}; + + +/** + * @param {?proto.web.communitygames.MutatorString|undefined} value + * @return {!proto.web.communitygames.MutatorKind} returns this +*/ +proto.web.communitygames.MutatorKind.prototype.setMutatorstring = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.MutatorKind} returns this + */ +proto.web.communitygames.MutatorKind.prototype.clearMutatorstring = function() { + return this.setMutatorstring(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.MutatorKind.prototype.hasMutatorstring = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +/** + * optional MutatorFloat mutatorFloat = 5; + * @return {?proto.web.communitygames.MutatorFloat} + */ +proto.web.communitygames.MutatorKind.prototype.getMutatorfloat = function() { + return /** @type{?proto.web.communitygames.MutatorFloat} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MutatorFloat, 5)); +}; + + +/** + * @param {?proto.web.communitygames.MutatorFloat|undefined} value + * @return {!proto.web.communitygames.MutatorKind} returns this +*/ +proto.web.communitygames.MutatorKind.prototype.setMutatorfloat = function(value) { + return jspb.Message.setWrapperField(this, 5, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.MutatorKind} returns this + */ +proto.web.communitygames.MutatorKind.prototype.clearMutatorfloat = function() { + return this.setMutatorfloat(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.MutatorKind.prototype.hasMutatorfloat = function() { + return jspb.Message.getField(this, 5) != null; +}; + + +/** + * optional MutatorInt mutatorInt = 6; + * @return {?proto.web.communitygames.MutatorInt} + */ +proto.web.communitygames.MutatorKind.prototype.getMutatorint = function() { + return /** @type{?proto.web.communitygames.MutatorInt} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MutatorInt, 6)); +}; + + +/** + * @param {?proto.web.communitygames.MutatorInt|undefined} value + * @return {!proto.web.communitygames.MutatorKind} returns this +*/ +proto.web.communitygames.MutatorKind.prototype.setMutatorint = function(value) { + return jspb.Message.setWrapperField(this, 6, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.MutatorKind} returns this + */ +proto.web.communitygames.MutatorKind.prototype.clearMutatorint = function() { + return this.setMutatorint(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.MutatorKind.prototype.hasMutatorint = function() { + return jspb.Message.getField(this, 6) != null; +}; + + +/** + * optional MutatorSparseBoolean mutatorSparseBoolean = 7; + * @return {?proto.web.communitygames.MutatorSparseBoolean} + */ +proto.web.communitygames.MutatorKind.prototype.getMutatorsparseboolean = function() { + return /** @type{?proto.web.communitygames.MutatorSparseBoolean} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MutatorSparseBoolean, 7)); +}; + + +/** + * @param {?proto.web.communitygames.MutatorSparseBoolean|undefined} value + * @return {!proto.web.communitygames.MutatorKind} returns this +*/ +proto.web.communitygames.MutatorKind.prototype.setMutatorsparseboolean = function(value) { + return jspb.Message.setWrapperField(this, 7, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.MutatorKind} returns this + */ +proto.web.communitygames.MutatorKind.prototype.clearMutatorsparseboolean = function() { + return this.setMutatorsparseboolean(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.MutatorKind.prototype.hasMutatorsparseboolean = function() { + return jspb.Message.getField(this, 7) != null; +}; + + +/** + * optional MutatorSparseInt mutatorSparseInt = 8; + * @return {?proto.web.communitygames.MutatorSparseInt} + */ +proto.web.communitygames.MutatorKind.prototype.getMutatorsparseint = function() { + return /** @type{?proto.web.communitygames.MutatorSparseInt} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MutatorSparseInt, 8)); +}; + + +/** + * @param {?proto.web.communitygames.MutatorSparseInt|undefined} value + * @return {!proto.web.communitygames.MutatorKind} returns this +*/ +proto.web.communitygames.MutatorKind.prototype.setMutatorsparseint = function(value) { + return jspb.Message.setWrapperField(this, 8, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.MutatorKind} returns this + */ +proto.web.communitygames.MutatorKind.prototype.clearMutatorsparseint = function() { + return this.setMutatorsparseint(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.MutatorKind.prototype.hasMutatorsparseint = function() { + return jspb.Message.getField(this, 8) != null; +}; + + +/** + * optional MutatorSparseFloat mutatorSparseFloat = 9; + * @return {?proto.web.communitygames.MutatorSparseFloat} + */ +proto.web.communitygames.MutatorKind.prototype.getMutatorsparsefloat = function() { + return /** @type{?proto.web.communitygames.MutatorSparseFloat} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MutatorSparseFloat, 9)); +}; + + +/** + * @param {?proto.web.communitygames.MutatorSparseFloat|undefined} value + * @return {!proto.web.communitygames.MutatorKind} returns this +*/ +proto.web.communitygames.MutatorKind.prototype.setMutatorsparsefloat = function(value) { + return jspb.Message.setWrapperField(this, 9, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.MutatorKind} returns this + */ +proto.web.communitygames.MutatorKind.prototype.clearMutatorsparsefloat = function() { + return this.setMutatorsparsefloat(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.MutatorKind.prototype.hasMutatorsparsefloat = function() { + return jspb.Message.getField(this, 9) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.TeamComposition.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.web.communitygames.TeamComposition.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.TeamComposition.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.web.communitygames.TeamComposition} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.TeamComposition.toObject = function(includeInstance, msg) { + var f, obj = { + teams: (f = msg.getTeams()) && proto.web.communitygames.TeamStructure.toObject(includeInstance, f), + internalteamsList: jspb.Message.toObjectList(msg.getInternalteamsList(), + proto.web.communitygames.InternalTeamStructure.toObject, includeInstance), + balancingmethod: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.TeamComposition} + */ +proto.web.communitygames.TeamComposition.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.TeamComposition; + return proto.web.communitygames.TeamComposition.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.TeamComposition} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.TeamComposition} + */ +proto.web.communitygames.TeamComposition.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.TeamStructure; + reader.readMessage(value,proto.web.communitygames.TeamStructure.deserializeBinaryFromReader); + msg.setTeams(value); + break; + case 2: + var value = new proto.web.communitygames.InternalTeamStructure; + reader.readMessage(value,proto.web.communitygames.InternalTeamStructure.deserializeBinaryFromReader); + msg.addInternalteams(value); + break; + case 3: + var value = /** @type {!proto.web.communitygames.BalancingMethod} */ (reader.readEnum()); + msg.setBalancingmethod(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.TeamComposition.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.TeamComposition.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.TeamComposition} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.TeamComposition.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTeams(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.TeamStructure.serializeBinaryToWriter + ); + } + f = message.getInternalteamsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.web.communitygames.InternalTeamStructure.serializeBinaryToWriter + ); + } + f = message.getBalancingmethod(); + if (f !== 0.0) { + writer.writeEnum( + 3, + f + ); + } +}; + + +/** + * optional TeamStructure teams = 1; + * @return {?proto.web.communitygames.TeamStructure} + */ +proto.web.communitygames.TeamComposition.prototype.getTeams = function() { + return /** @type{?proto.web.communitygames.TeamStructure} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.TeamStructure, 1)); +}; + + +/** + * @param {?proto.web.communitygames.TeamStructure|undefined} value + * @return {!proto.web.communitygames.TeamComposition} returns this +*/ +proto.web.communitygames.TeamComposition.prototype.setTeams = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.TeamComposition} returns this + */ +proto.web.communitygames.TeamComposition.prototype.clearTeams = function() { + return this.setTeams(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.TeamComposition.prototype.hasTeams = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * repeated InternalTeamStructure internalTeams = 2; + * @return {!Array} + */ +proto.web.communitygames.TeamComposition.prototype.getInternalteamsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.InternalTeamStructure, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.TeamComposition} returns this +*/ +proto.web.communitygames.TeamComposition.prototype.setInternalteamsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.web.communitygames.InternalTeamStructure=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.InternalTeamStructure} + */ +proto.web.communitygames.TeamComposition.prototype.addInternalteams = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.web.communitygames.InternalTeamStructure, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.TeamComposition} returns this + */ +proto.web.communitygames.TeamComposition.prototype.clearInternalteamsList = function() { + return this.setInternalteamsList([]); +}; + + +/** + * optional BalancingMethod balancingMethod = 3; + * @return {!proto.web.communitygames.BalancingMethod} + */ +proto.web.communitygames.TeamComposition.prototype.getBalancingmethod = function() { + return /** @type {!proto.web.communitygames.BalancingMethod} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {!proto.web.communitygames.BalancingMethod} value + * @return {!proto.web.communitygames.TeamComposition} returns this + */ +proto.web.communitygames.TeamComposition.prototype.setBalancingmethod = function(value) { + return jspb.Message.setProto3EnumField(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.web.communitygames.Mutator.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.Mutator.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.web.communitygames.Mutator} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Mutator.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + category: jspb.Message.getFieldWithDefault(msg, 2, ""), + kind: (f = msg.getKind()) && proto.web.communitygames.MutatorKind.toObject(includeInstance, f), + id: jspb.Message.getFieldWithDefault(msg, 4, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.Mutator} + */ +proto.web.communitygames.Mutator.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.Mutator; + return proto.web.communitygames.Mutator.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.Mutator} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.Mutator} + */ +proto.web.communitygames.Mutator.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.setCategory(value); + break; + case 3: + var value = new proto.web.communitygames.MutatorKind; + reader.readMessage(value,proto.web.communitygames.MutatorKind.deserializeBinaryFromReader); + msg.setKind(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setId(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.Mutator.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.Mutator.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.Mutator} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Mutator.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getCategory(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getKind(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.web.communitygames.MutatorKind.serializeBinaryToWriter + ); + } + f = message.getId(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.web.communitygames.Mutator.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Mutator} returns this + */ +proto.web.communitygames.Mutator.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string category = 2; + * @return {string} + */ +proto.web.communitygames.Mutator.prototype.getCategory = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Mutator} returns this + */ +proto.web.communitygames.Mutator.prototype.setCategory = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional MutatorKind kind = 3; + * @return {?proto.web.communitygames.MutatorKind} + */ +proto.web.communitygames.Mutator.prototype.getKind = function() { + return /** @type{?proto.web.communitygames.MutatorKind} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MutatorKind, 3)); +}; + + +/** + * @param {?proto.web.communitygames.MutatorKind|undefined} value + * @return {!proto.web.communitygames.Mutator} returns this +*/ +proto.web.communitygames.Mutator.prototype.setKind = function(value) { + return jspb.Message.setWrapperField(this, 3, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Mutator} returns this + */ +proto.web.communitygames.Mutator.prototype.clearKind = function() { + return this.setKind(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Mutator.prototype.hasKind = function() { + return jspb.Message.getField(this, 3) != null; +}; + + +/** + * optional string id = 4; + * @return {string} + */ +proto.web.communitygames.Mutator.prototype.getId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Mutator} returns this + */ +proto.web.communitygames.Mutator.prototype.setId = function(value) { + return jspb.Message.setProto3StringField(this, 4, 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.web.communitygames.Timestamp.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.Timestamp.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.web.communitygames.Timestamp} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Timestamp.toObject = function(includeInstance, msg) { + var f, obj = { + seconds: jspb.Message.getFieldWithDefault(msg, 1, "0"), + nanos: jspb.Message.getFieldWithDefault(msg, 2, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.Timestamp} + */ +proto.web.communitygames.Timestamp.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.Timestamp; + return proto.web.communitygames.Timestamp.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.Timestamp} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.Timestamp} + */ +proto.web.communitygames.Timestamp.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readInt64String()); + msg.setSeconds(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setNanos(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.Timestamp.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.Timestamp.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.Timestamp} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Timestamp.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getSeconds(); + if (parseInt(f, 10) !== 0) { + writer.writeInt64String( + 1, + f + ); + } + f = message.getNanos(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } +}; + + +/** + * optional int64 seconds = 1; + * @return {string} + */ +proto.web.communitygames.Timestamp.prototype.getSeconds = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "0")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Timestamp} returns this + */ +proto.web.communitygames.Timestamp.prototype.setSeconds = function(value) { + return jspb.Message.setProto3StringIntField(this, 1, value); +}; + + +/** + * optional int32 nanos = 2; + * @return {number} + */ +proto.web.communitygames.Timestamp.prototype.getNanos = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.Timestamp} returns this + */ +proto.web.communitygames.Timestamp.prototype.setNanos = function(value) { + return jspb.Message.setProto3IntField(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.web.communitygames.StringValue.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.StringValue.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.web.communitygames.StringValue} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.StringValue.toObject = function(includeInstance, msg) { + var f, obj = { + value: 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.web.communitygames.StringValue} + */ +proto.web.communitygames.StringValue.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.StringValue; + return proto.web.communitygames.StringValue.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.StringValue} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.StringValue} + */ +proto.web.communitygames.StringValue.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.setValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.StringValue.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.StringValue.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.StringValue} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.StringValue.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getValue(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string value = 1; + * @return {string} + */ +proto.web.communitygames.StringValue.prototype.getValue = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.StringValue} returns this + */ +proto.web.communitygames.StringValue.prototype.setValue = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.GameServerMessage.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GameServerMessage.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.web.communitygames.GameServerMessage} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GameServerMessage.toObject = function(includeInstance, msg) { + var f, obj = { + kind: jspb.Message.getFieldWithDefault(msg, 1, ""), + text: 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.web.communitygames.GameServerMessage} + */ +proto.web.communitygames.GameServerMessage.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GameServerMessage; + return proto.web.communitygames.GameServerMessage.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GameServerMessage} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GameServerMessage} + */ +proto.web.communitygames.GameServerMessage.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.setKind(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setText(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GameServerMessage.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GameServerMessage.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GameServerMessage} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GameServerMessage.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getKind(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getText(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional string kind = 1; + * @return {string} + */ +proto.web.communitygames.GameServerMessage.prototype.getKind = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.GameServerMessage} returns this + */ +proto.web.communitygames.GameServerMessage.prototype.setKind = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string text = 2; + * @return {string} + */ +proto.web.communitygames.GameServerMessage.prototype.getText = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.GameServerMessage} returns this + */ +proto.web.communitygames.GameServerMessage.prototype.setText = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.GameServerSettings.repeatedFields_ = [3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.GameServerSettings.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GameServerSettings.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.web.communitygames.GameServerSettings} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GameServerSettings.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + description: (f = msg.getDescription()) && proto.web.communitygames.StringValue.toObject(includeInstance, f), + gameservermessageList: jspb.Message.toObjectList(msg.getGameservermessageList(), + proto.web.communitygames.GameServerMessage.toObject, includeInstance), + configname: (f = msg.getConfigname()) && proto.web.communitygames.StringValue.toObject(includeInstance, f), + configdescription: (f = msg.getConfigdescription()) && proto.web.communitygames.StringValue.toObject(includeInstance, f), + phantomgamestate: 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.web.communitygames.GameServerSettings} + */ +proto.web.communitygames.GameServerSettings.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GameServerSettings; + return proto.web.communitygames.GameServerSettings.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GameServerSettings} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GameServerSettings} + */ +proto.web.communitygames.GameServerSettings.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 proto.web.communitygames.StringValue; + reader.readMessage(value,proto.web.communitygames.StringValue.deserializeBinaryFromReader); + msg.setDescription(value); + break; + case 3: + var value = new proto.web.communitygames.GameServerMessage; + reader.readMessage(value,proto.web.communitygames.GameServerMessage.deserializeBinaryFromReader); + msg.addGameservermessage(value); + break; + case 4: + var value = new proto.web.communitygames.StringValue; + reader.readMessage(value,proto.web.communitygames.StringValue.deserializeBinaryFromReader); + msg.setConfigname(value); + break; + case 5: + var value = new proto.web.communitygames.StringValue; + reader.readMessage(value,proto.web.communitygames.StringValue.deserializeBinaryFromReader); + msg.setConfigdescription(value); + break; + case 6: + var value = /** @type {!proto.web.communitygames.PhantomGameState} */ (reader.readEnum()); + msg.setPhantomgamestate(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GameServerSettings.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GameServerSettings.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GameServerSettings} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GameServerSettings.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getDescription(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.StringValue.serializeBinaryToWriter + ); + } + f = message.getGameservermessageList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.web.communitygames.GameServerMessage.serializeBinaryToWriter + ); + } + f = message.getConfigname(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.communitygames.StringValue.serializeBinaryToWriter + ); + } + f = message.getConfigdescription(); + if (f != null) { + writer.writeMessage( + 5, + f, + proto.web.communitygames.StringValue.serializeBinaryToWriter + ); + } + f = message.getPhantomgamestate(); + if (f !== 0.0) { + writer.writeEnum( + 6, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.web.communitygames.GameServerSettings.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.GameServerSettings} returns this + */ +proto.web.communitygames.GameServerSettings.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional StringValue description = 2; + * @return {?proto.web.communitygames.StringValue} + */ +proto.web.communitygames.GameServerSettings.prototype.getDescription = function() { + return /** @type{?proto.web.communitygames.StringValue} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.StringValue, 2)); +}; + + +/** + * @param {?proto.web.communitygames.StringValue|undefined} value + * @return {!proto.web.communitygames.GameServerSettings} returns this +*/ +proto.web.communitygames.GameServerSettings.prototype.setDescription = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.GameServerSettings} returns this + */ +proto.web.communitygames.GameServerSettings.prototype.clearDescription = function() { + return this.setDescription(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.GameServerSettings.prototype.hasDescription = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * repeated GameServerMessage gameServerMessage = 3; + * @return {!Array} + */ +proto.web.communitygames.GameServerSettings.prototype.getGameservermessageList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.GameServerMessage, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.GameServerSettings} returns this +*/ +proto.web.communitygames.GameServerSettings.prototype.setGameservermessageList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.web.communitygames.GameServerMessage=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.GameServerMessage} + */ +proto.web.communitygames.GameServerSettings.prototype.addGameservermessage = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.web.communitygames.GameServerMessage, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.GameServerSettings} returns this + */ +proto.web.communitygames.GameServerSettings.prototype.clearGameservermessageList = function() { + return this.setGameservermessageList([]); +}; + + +/** + * optional StringValue configName = 4; + * @return {?proto.web.communitygames.StringValue} + */ +proto.web.communitygames.GameServerSettings.prototype.getConfigname = function() { + return /** @type{?proto.web.communitygames.StringValue} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.StringValue, 4)); +}; + + +/** + * @param {?proto.web.communitygames.StringValue|undefined} value + * @return {!proto.web.communitygames.GameServerSettings} returns this +*/ +proto.web.communitygames.GameServerSettings.prototype.setConfigname = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.GameServerSettings} returns this + */ +proto.web.communitygames.GameServerSettings.prototype.clearConfigname = function() { + return this.setConfigname(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.GameServerSettings.prototype.hasConfigname = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +/** + * optional StringValue ConfigDescription = 5; + * @return {?proto.web.communitygames.StringValue} + */ +proto.web.communitygames.GameServerSettings.prototype.getConfigdescription = function() { + return /** @type{?proto.web.communitygames.StringValue} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.StringValue, 5)); +}; + + +/** + * @param {?proto.web.communitygames.StringValue|undefined} value + * @return {!proto.web.communitygames.GameServerSettings} returns this +*/ +proto.web.communitygames.GameServerSettings.prototype.setConfigdescription = function(value) { + return jspb.Message.setWrapperField(this, 5, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.GameServerSettings} returns this + */ +proto.web.communitygames.GameServerSettings.prototype.clearConfigdescription = function() { + return this.setConfigdescription(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.GameServerSettings.prototype.hasConfigdescription = function() { + return jspb.Message.getField(this, 5) != null; +}; + + +/** + * optional PhantomGameState phantomGameState = 6; + * @return {!proto.web.communitygames.PhantomGameState} + */ +proto.web.communitygames.GameServerSettings.prototype.getPhantomgamestate = function() { + return /** @type {!proto.web.communitygames.PhantomGameState} */ (jspb.Message.getFieldWithDefault(this, 6, 0)); +}; + + +/** + * @param {!proto.web.communitygames.PhantomGameState} value + * @return {!proto.web.communitygames.GameServerSettings} returns this + */ +proto.web.communitygames.GameServerSettings.prototype.setPhantomgamestate = function(value) { + return jspb.Message.setProto3EnumField(this, 6, 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.web.communitygames.PlayerInfo.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.PlayerInfo.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.web.communitygames.PlayerInfo} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.PlayerInfo.toObject = function(includeInstance, msg) { + var f, obj = { + nucleusid: jspb.Message.getFieldWithDefault(msg, 1, "0"), + personaid: jspb.Message.getFieldWithDefault(msg, 2, "0"), + platformid: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.PlayerInfo} + */ +proto.web.communitygames.PlayerInfo.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.PlayerInfo; + return proto.web.communitygames.PlayerInfo.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.PlayerInfo} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.PlayerInfo} + */ +proto.web.communitygames.PlayerInfo.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readUint64String()); + msg.setNucleusid(value); + break; + case 2: + var value = /** @type {string} */ (reader.readUint64String()); + msg.setPersonaid(value); + break; + case 3: + var value = /** @type {!proto.web.communitygames.Platform} */ (reader.readEnum()); + msg.setPlatformid(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.PlayerInfo.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.PlayerInfo.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.PlayerInfo} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.PlayerInfo.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getNucleusid(); + if (parseInt(f, 10) !== 0) { + writer.writeUint64String( + 1, + f + ); + } + f = message.getPersonaid(); + if (parseInt(f, 10) !== 0) { + writer.writeUint64String( + 2, + f + ); + } + f = message.getPlatformid(); + if (f !== 0.0) { + writer.writeEnum( + 3, + f + ); + } +}; + + +/** + * optional uint64 nucleusId = 1; + * @return {string} + */ +proto.web.communitygames.PlayerInfo.prototype.getNucleusid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "0")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.PlayerInfo} returns this + */ +proto.web.communitygames.PlayerInfo.prototype.setNucleusid = function(value) { + return jspb.Message.setProto3StringIntField(this, 1, value); +}; + + +/** + * optional uint64 personaId = 2; + * @return {string} + */ +proto.web.communitygames.PlayerInfo.prototype.getPersonaid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "0")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.PlayerInfo} returns this + */ +proto.web.communitygames.PlayerInfo.prototype.setPersonaid = function(value) { + return jspb.Message.setProto3StringIntField(this, 2, value); +}; + + +/** + * optional Platform platformId = 3; + * @return {!proto.web.communitygames.Platform} + */ +proto.web.communitygames.PlayerInfo.prototype.getPlatformid = function() { + return /** @type {!proto.web.communitygames.Platform} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {!proto.web.communitygames.Platform} value + * @return {!proto.web.communitygames.PlayerInfo} returns this + */ +proto.web.communitygames.PlayerInfo.prototype.setPlatformid = function(value) { + return jspb.Message.setProto3EnumField(this, 3, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.PlatformRestrictions.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.PlatformRestrictions.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.PlatformRestrictions.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.web.communitygames.PlatformRestrictions} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.PlatformRestrictions.toObject = function(includeInstance, msg) { + var f, obj = { + platformsList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.PlatformRestrictions} + */ +proto.web.communitygames.PlatformRestrictions.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.PlatformRestrictions; + return proto.web.communitygames.PlatformRestrictions.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.PlatformRestrictions} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.PlatformRestrictions} + */ +proto.web.communitygames.PlatformRestrictions.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Array} */ (reader.readPackedEnum()); + msg.setPlatformsList(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.PlatformRestrictions.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.PlatformRestrictions.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.PlatformRestrictions} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.PlatformRestrictions.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPlatformsList(); + if (f.length > 0) { + writer.writePackedEnum( + 1, + f + ); + } +}; + + +/** + * repeated Platform platforms = 1; + * @return {!Array} + */ +proto.web.communitygames.PlatformRestrictions.prototype.getPlatformsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.PlatformRestrictions} returns this + */ +proto.web.communitygames.PlatformRestrictions.prototype.setPlatformsList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {!proto.web.communitygames.Platform} value + * @param {number=} opt_index + * @return {!proto.web.communitygames.PlatformRestrictions} returns this + */ +proto.web.communitygames.PlatformRestrictions.prototype.addPlatforms = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.PlatformRestrictions} returns this + */ +proto.web.communitygames.PlatformRestrictions.prototype.clearPlatformsList = function() { + return this.setPlatformsList([]); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.InputMethodResrictions.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.InputMethodResrictions.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.InputMethodResrictions.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.web.communitygames.InputMethodResrictions} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.InputMethodResrictions.toObject = function(includeInstance, msg) { + var f, obj = { + inputmethodsList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.InputMethodResrictions} + */ +proto.web.communitygames.InputMethodResrictions.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.InputMethodResrictions; + return proto.web.communitygames.InputMethodResrictions.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.InputMethodResrictions} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.InputMethodResrictions} + */ +proto.web.communitygames.InputMethodResrictions.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Array} */ (reader.readPackedEnum()); + msg.setInputmethodsList(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.InputMethodResrictions.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.InputMethodResrictions.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.InputMethodResrictions} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.InputMethodResrictions.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getInputmethodsList(); + if (f.length > 0) { + writer.writePackedEnum( + 1, + f + ); + } +}; + + +/** + * repeated InputMethods inputMethods = 1; + * @return {!Array} + */ +proto.web.communitygames.InputMethodResrictions.prototype.getInputmethodsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.InputMethodResrictions} returns this + */ +proto.web.communitygames.InputMethodResrictions.prototype.setInputmethodsList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {!proto.web.communitygames.InputMethods} value + * @param {number=} opt_index + * @return {!proto.web.communitygames.InputMethodResrictions} returns this + */ +proto.web.communitygames.InputMethodResrictions.prototype.addInputmethods = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.InputMethodResrictions} returns this + */ +proto.web.communitygames.InputMethodResrictions.prototype.clearInputmethodsList = function() { + return this.setInputmethodsList([]); +}; + + + + + +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.web.communitygames.Restrictions.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.Restrictions.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.web.communitygames.Restrictions} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Restrictions.toObject = function(includeInstance, msg) { + var f, obj = { + platformrestrictions: (f = msg.getPlatformrestrictions()) && proto.web.communitygames.PlatformRestrictions.toObject(includeInstance, f), + inputmethodresctrictions: (f = msg.getInputmethodresctrictions()) && proto.web.communitygames.InputMethodResrictions.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.web.communitygames.Restrictions} + */ +proto.web.communitygames.Restrictions.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.Restrictions; + return proto.web.communitygames.Restrictions.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.Restrictions} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.Restrictions} + */ +proto.web.communitygames.Restrictions.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.PlatformRestrictions; + reader.readMessage(value,proto.web.communitygames.PlatformRestrictions.deserializeBinaryFromReader); + msg.setPlatformrestrictions(value); + break; + case 2: + var value = new proto.web.communitygames.InputMethodResrictions; + reader.readMessage(value,proto.web.communitygames.InputMethodResrictions.deserializeBinaryFromReader); + msg.setInputmethodresctrictions(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.Restrictions.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.Restrictions.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.Restrictions} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Restrictions.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPlatformrestrictions(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.PlatformRestrictions.serializeBinaryToWriter + ); + } + f = message.getInputmethodresctrictions(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.InputMethodResrictions.serializeBinaryToWriter + ); + } +}; + + +/** + * optional PlatformRestrictions platformRestrictions = 1; + * @return {?proto.web.communitygames.PlatformRestrictions} + */ +proto.web.communitygames.Restrictions.prototype.getPlatformrestrictions = function() { + return /** @type{?proto.web.communitygames.PlatformRestrictions} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.PlatformRestrictions, 1)); +}; + + +/** + * @param {?proto.web.communitygames.PlatformRestrictions|undefined} value + * @return {!proto.web.communitygames.Restrictions} returns this +*/ +proto.web.communitygames.Restrictions.prototype.setPlatformrestrictions = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Restrictions} returns this + */ +proto.web.communitygames.Restrictions.prototype.clearPlatformrestrictions = function() { + return this.setPlatformrestrictions(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Restrictions.prototype.hasPlatformrestrictions = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional InputMethodResrictions inputMethodResctrictions = 2; + * @return {?proto.web.communitygames.InputMethodResrictions} + */ +proto.web.communitygames.Restrictions.prototype.getInputmethodresctrictions = function() { + return /** @type{?proto.web.communitygames.InputMethodResrictions} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.InputMethodResrictions, 2)); +}; + + +/** + * @param {?proto.web.communitygames.InputMethodResrictions|undefined} value + * @return {!proto.web.communitygames.Restrictions} returns this +*/ +proto.web.communitygames.Restrictions.prototype.setInputmethodresctrictions = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Restrictions} returns this + */ +proto.web.communitygames.Restrictions.prototype.clearInputmethodresctrictions = function() { + return this.setInputmethodresctrictions(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Restrictions.prototype.hasInputmethodresctrictions = 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.web.communitygames.Compressed.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.Compressed.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.web.communitygames.Compressed} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Compressed.toObject = function(includeInstance, msg) { + var f, obj = { + compiledmodrules: msg.getCompiledmodrules_asB64(), + rulesversion: jspb.Message.getFieldWithDefault(msg, 2, 0), + inflatedsize: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.Compressed} + */ +proto.web.communitygames.Compressed.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.Compressed; + return proto.web.communitygames.Compressed.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.Compressed} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.Compressed} + */ +proto.web.communitygames.Compressed.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setCompiledmodrules(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setRulesversion(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setInflatedsize(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.Compressed.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.Compressed.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.Compressed} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Compressed.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getCompiledmodrules_asU8(); + if (f.length > 0) { + writer.writeBytes( + 1, + f + ); + } + f = message.getRulesversion(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getInflatedsize(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } +}; + + +/** + * optional bytes compiledModRules = 1; + * @return {!(string|Uint8Array)} + */ +proto.web.communitygames.Compressed.prototype.getCompiledmodrules = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * optional bytes compiledModRules = 1; + * This is a type-conversion wrapper around `getCompiledmodrules()` + * @return {string} + */ +proto.web.communitygames.Compressed.prototype.getCompiledmodrules_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getCompiledmodrules())); +}; + + +/** + * optional bytes compiledModRules = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getCompiledmodrules()` + * @return {!Uint8Array} + */ +proto.web.communitygames.Compressed.prototype.getCompiledmodrules_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getCompiledmodrules())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.web.communitygames.Compressed} returns this + */ +proto.web.communitygames.Compressed.prototype.setCompiledmodrules = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); +}; + + +/** + * optional int32 rulesVersion = 2; + * @return {number} + */ +proto.web.communitygames.Compressed.prototype.getRulesversion = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.Compressed} returns this + */ +proto.web.communitygames.Compressed.prototype.setRulesversion = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional int32 inflatedSize = 3; + * @return {number} + */ +proto.web.communitygames.Compressed.prototype.getInflatedsize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.Compressed} returns this + */ +proto.web.communitygames.Compressed.prototype.setInflatedsize = function(value) { + return jspb.Message.setProto3IntField(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.web.communitygames.Uncompressed.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.Uncompressed.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.web.communitygames.Uncompressed} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Uncompressed.toObject = function(includeInstance, msg) { + var f, obj = { + compiledmodrules: msg.getCompiledmodrules_asB64(), + rulesversion: jspb.Message.getFieldWithDefault(msg, 2, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.Uncompressed} + */ +proto.web.communitygames.Uncompressed.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.Uncompressed; + return proto.web.communitygames.Uncompressed.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.Uncompressed} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.Uncompressed} + */ +proto.web.communitygames.Uncompressed.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setCompiledmodrules(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setRulesversion(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.Uncompressed.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.Uncompressed.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.Uncompressed} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Uncompressed.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getCompiledmodrules_asU8(); + if (f.length > 0) { + writer.writeBytes( + 1, + f + ); + } + f = message.getRulesversion(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } +}; + + +/** + * optional bytes compiledModRules = 1; + * @return {!(string|Uint8Array)} + */ +proto.web.communitygames.Uncompressed.prototype.getCompiledmodrules = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * optional bytes compiledModRules = 1; + * This is a type-conversion wrapper around `getCompiledmodrules()` + * @return {string} + */ +proto.web.communitygames.Uncompressed.prototype.getCompiledmodrules_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getCompiledmodrules())); +}; + + +/** + * optional bytes compiledModRules = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getCompiledmodrules()` + * @return {!Uint8Array} + */ +proto.web.communitygames.Uncompressed.prototype.getCompiledmodrules_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getCompiledmodrules())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.web.communitygames.Uncompressed} returns this + */ +proto.web.communitygames.Uncompressed.prototype.setCompiledmodrules = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); +}; + + +/** + * optional int32 rulesVersion = 2; + * @return {number} + */ +proto.web.communitygames.Uncompressed.prototype.getRulesversion = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.Uncompressed} returns this + */ +proto.web.communitygames.Uncompressed.prototype.setRulesversion = function(value) { + return jspb.Message.setProto3IntField(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.web.communitygames.CompiledRules.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.CompiledRules.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.web.communitygames.CompiledRules} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.CompiledRules.toObject = function(includeInstance, msg) { + var f, obj = { + uncompressed: (f = msg.getUncompressed()) && proto.web.communitygames.Uncompressed.toObject(includeInstance, f), + compressed: (f = msg.getCompressed()) && proto.web.communitygames.Compressed.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.web.communitygames.CompiledRules} + */ +proto.web.communitygames.CompiledRules.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.CompiledRules; + return proto.web.communitygames.CompiledRules.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.CompiledRules} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.CompiledRules} + */ +proto.web.communitygames.CompiledRules.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.Uncompressed; + reader.readMessage(value,proto.web.communitygames.Uncompressed.deserializeBinaryFromReader); + msg.setUncompressed(value); + break; + case 2: + var value = new proto.web.communitygames.Compressed; + reader.readMessage(value,proto.web.communitygames.Compressed.deserializeBinaryFromReader); + msg.setCompressed(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.CompiledRules.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.CompiledRules.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.CompiledRules} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.CompiledRules.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getUncompressed(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.Uncompressed.serializeBinaryToWriter + ); + } + f = message.getCompressed(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.Compressed.serializeBinaryToWriter + ); + } +}; + + +/** + * optional Uncompressed uncompressed = 1; + * @return {?proto.web.communitygames.Uncompressed} + */ +proto.web.communitygames.CompiledRules.prototype.getUncompressed = function() { + return /** @type{?proto.web.communitygames.Uncompressed} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Uncompressed, 1)); +}; + + +/** + * @param {?proto.web.communitygames.Uncompressed|undefined} value + * @return {!proto.web.communitygames.CompiledRules} returns this +*/ +proto.web.communitygames.CompiledRules.prototype.setUncompressed = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.CompiledRules} returns this + */ +proto.web.communitygames.CompiledRules.prototype.clearUncompressed = function() { + return this.setUncompressed(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.CompiledRules.prototype.hasUncompressed = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional Compressed compressed = 2; + * @return {?proto.web.communitygames.Compressed} + */ +proto.web.communitygames.CompiledRules.prototype.getCompressed = function() { + return /** @type{?proto.web.communitygames.Compressed} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Compressed, 2)); +}; + + +/** + * @param {?proto.web.communitygames.Compressed|undefined} value + * @return {!proto.web.communitygames.CompiledRules} returns this +*/ +proto.web.communitygames.CompiledRules.prototype.setCompressed = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.CompiledRules} returns this + */ +proto.web.communitygames.CompiledRules.prototype.clearCompressed = function() { + return this.setCompressed(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.CompiledRules.prototype.hasCompressed = 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.web.communitygames.CompatibleModRules.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.CompatibleModRules.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.web.communitygames.CompatibleModRules} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.CompatibleModRules.toObject = function(includeInstance, msg) { + var f, obj = { + rules: msg.getRules_asB64(), + rulesversion: jspb.Message.getFieldWithDefault(msg, 3, 0), + compiled: (f = msg.getCompiled()) && proto.web.communitygames.CompiledRules.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.web.communitygames.CompatibleModRules} + */ +proto.web.communitygames.CompatibleModRules.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.CompatibleModRules; + return proto.web.communitygames.CompatibleModRules.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.CompatibleModRules} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.CompatibleModRules} + */ +proto.web.communitygames.CompatibleModRules.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setRules(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setRulesversion(value); + break; + case 4: + var value = new proto.web.communitygames.CompiledRules; + reader.readMessage(value,proto.web.communitygames.CompiledRules.deserializeBinaryFromReader); + msg.setCompiled(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.CompatibleModRules.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.CompatibleModRules.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.CompatibleModRules} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.CompatibleModRules.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getRules_asU8(); + if (f.length > 0) { + writer.writeBytes( + 1, + f + ); + } + f = message.getRulesversion(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } + f = message.getCompiled(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.communitygames.CompiledRules.serializeBinaryToWriter + ); + } +}; + + +/** + * optional bytes rules = 1; + * @return {!(string|Uint8Array)} + */ +proto.web.communitygames.CompatibleModRules.prototype.getRules = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * optional bytes rules = 1; + * This is a type-conversion wrapper around `getRules()` + * @return {string} + */ +proto.web.communitygames.CompatibleModRules.prototype.getRules_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getRules())); +}; + + +/** + * optional bytes rules = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getRules()` + * @return {!Uint8Array} + */ +proto.web.communitygames.CompatibleModRules.prototype.getRules_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getRules())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.web.communitygames.CompatibleModRules} returns this + */ +proto.web.communitygames.CompatibleModRules.prototype.setRules = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); +}; + + +/** + * optional int32 rulesVersion = 3; + * @return {number} + */ +proto.web.communitygames.CompatibleModRules.prototype.getRulesversion = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.CompatibleModRules} returns this + */ +proto.web.communitygames.CompatibleModRules.prototype.setRulesversion = function(value) { + return jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * optional CompiledRules compiled = 4; + * @return {?proto.web.communitygames.CompiledRules} + */ +proto.web.communitygames.CompatibleModRules.prototype.getCompiled = function() { + return /** @type{?proto.web.communitygames.CompiledRules} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.CompiledRules, 4)); +}; + + +/** + * @param {?proto.web.communitygames.CompiledRules|undefined} value + * @return {!proto.web.communitygames.CompatibleModRules} returns this +*/ +proto.web.communitygames.CompatibleModRules.prototype.setCompiled = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.CompatibleModRules} returns this + */ +proto.web.communitygames.CompatibleModRules.prototype.clearCompiled = function() { + return this.setCompiled(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.CompatibleModRules.prototype.hasCompiled = function() { + return jspb.Message.getField(this, 4) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.InCompatibleModRules.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.InCompatibleModRules.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.web.communitygames.InCompatibleModRules} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.InCompatibleModRules.toObject = function(includeInstance, msg) { + var f, obj = { + rules: msg.getRules_asB64(), + rulesversion: jspb.Message.getFieldWithDefault(msg, 2, 0), + blueprintrulesversion: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.InCompatibleModRules} + */ +proto.web.communitygames.InCompatibleModRules.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.InCompatibleModRules; + return proto.web.communitygames.InCompatibleModRules.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.InCompatibleModRules} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.InCompatibleModRules} + */ +proto.web.communitygames.InCompatibleModRules.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setRules(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setRulesversion(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setBlueprintrulesversion(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.InCompatibleModRules.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.InCompatibleModRules.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.InCompatibleModRules} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.InCompatibleModRules.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getRules_asU8(); + if (f.length > 0) { + writer.writeBytes( + 1, + f + ); + } + f = message.getRulesversion(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getBlueprintrulesversion(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } +}; + + +/** + * optional bytes rules = 1; + * @return {!(string|Uint8Array)} + */ +proto.web.communitygames.InCompatibleModRules.prototype.getRules = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * optional bytes rules = 1; + * This is a type-conversion wrapper around `getRules()` + * @return {string} + */ +proto.web.communitygames.InCompatibleModRules.prototype.getRules_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getRules())); +}; + + +/** + * optional bytes rules = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getRules()` + * @return {!Uint8Array} + */ +proto.web.communitygames.InCompatibleModRules.prototype.getRules_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getRules())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.web.communitygames.InCompatibleModRules} returns this + */ +proto.web.communitygames.InCompatibleModRules.prototype.setRules = function(value) { + return jspb.Message.setProto3BytesField(this, 1, value); +}; + + +/** + * optional int32 rulesVersion = 2; + * @return {number} + */ +proto.web.communitygames.InCompatibleModRules.prototype.getRulesversion = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.InCompatibleModRules} returns this + */ +proto.web.communitygames.InCompatibleModRules.prototype.setRulesversion = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional int32 blueprintRulesVersion = 3; + * @return {number} + */ +proto.web.communitygames.InCompatibleModRules.prototype.getBlueprintrulesversion = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.InCompatibleModRules} returns this + */ +proto.web.communitygames.InCompatibleModRules.prototype.setBlueprintrulesversion = function(value) { + return jspb.Message.setProto3IntField(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.web.communitygames.OriginalModRules.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.OriginalModRules.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.web.communitygames.OriginalModRules} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.OriginalModRules.toObject = function(includeInstance, msg) { + var f, obj = { + compatiblerules: (f = msg.getCompatiblerules()) && proto.web.communitygames.CompatibleModRules.toObject(includeInstance, f), + incompatiblerules: (f = msg.getIncompatiblerules()) && proto.web.communitygames.InCompatibleModRules.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.web.communitygames.OriginalModRules} + */ +proto.web.communitygames.OriginalModRules.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.OriginalModRules; + return proto.web.communitygames.OriginalModRules.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.OriginalModRules} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.OriginalModRules} + */ +proto.web.communitygames.OriginalModRules.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.CompatibleModRules; + reader.readMessage(value,proto.web.communitygames.CompatibleModRules.deserializeBinaryFromReader); + msg.setCompatiblerules(value); + break; + case 2: + var value = new proto.web.communitygames.InCompatibleModRules; + reader.readMessage(value,proto.web.communitygames.InCompatibleModRules.deserializeBinaryFromReader); + msg.setIncompatiblerules(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.OriginalModRules.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.OriginalModRules.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.OriginalModRules} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.OriginalModRules.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getCompatiblerules(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.CompatibleModRules.serializeBinaryToWriter + ); + } + f = message.getIncompatiblerules(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.InCompatibleModRules.serializeBinaryToWriter + ); + } +}; + + +/** + * optional CompatibleModRules compatibleRules = 1; + * @return {?proto.web.communitygames.CompatibleModRules} + */ +proto.web.communitygames.OriginalModRules.prototype.getCompatiblerules = function() { + return /** @type{?proto.web.communitygames.CompatibleModRules} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.CompatibleModRules, 1)); +}; + + +/** + * @param {?proto.web.communitygames.CompatibleModRules|undefined} value + * @return {!proto.web.communitygames.OriginalModRules} returns this +*/ +proto.web.communitygames.OriginalModRules.prototype.setCompatiblerules = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.OriginalModRules} returns this + */ +proto.web.communitygames.OriginalModRules.prototype.clearCompatiblerules = function() { + return this.setCompatiblerules(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.OriginalModRules.prototype.hasCompatiblerules = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional InCompatibleModRules incompatibleRules = 2; + * @return {?proto.web.communitygames.InCompatibleModRules} + */ +proto.web.communitygames.OriginalModRules.prototype.getIncompatiblerules = function() { + return /** @type{?proto.web.communitygames.InCompatibleModRules} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.InCompatibleModRules, 2)); +}; + + +/** + * @param {?proto.web.communitygames.InCompatibleModRules|undefined} value + * @return {!proto.web.communitygames.OriginalModRules} returns this +*/ +proto.web.communitygames.OriginalModRules.prototype.setIncompatiblerules = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.OriginalModRules} returns this + */ +proto.web.communitygames.OriginalModRules.prototype.clearIncompatiblerules = function() { + return this.setIncompatiblerules(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.OriginalModRules.prototype.hasIncompatiblerules = function() { + return jspb.Message.getField(this, 2) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AssetCategoryTagBooleanOverride.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.web.communitygames.AssetCategoryTagBooleanOverride} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.toObject = function(includeInstance, msg) { + var f, obj = { + assetcategorytagsList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f, + value: jspb.Message.getBooleanFieldWithDefault(msg, 2, false) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.AssetCategoryTagBooleanOverride} + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AssetCategoryTagBooleanOverride; + return proto.web.communitygames.AssetCategoryTagBooleanOverride.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AssetCategoryTagBooleanOverride} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AssetCategoryTagBooleanOverride} + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.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.addAssetcategorytags(value); + break; + case 2: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AssetCategoryTagBooleanOverride.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AssetCategoryTagBooleanOverride} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getAssetcategorytagsList(); + if (f.length > 0) { + writer.writeRepeatedString( + 1, + f + ); + } + f = message.getValue(); + if (f) { + writer.writeBool( + 2, + f + ); + } +}; + + +/** + * repeated string assetCategoryTags = 1; + * @return {!Array} + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.prototype.getAssetcategorytagsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.AssetCategoryTagBooleanOverride} returns this + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.prototype.setAssetcategorytagsList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {string} value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AssetCategoryTagBooleanOverride} returns this + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.prototype.addAssetcategorytags = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.AssetCategoryTagBooleanOverride} returns this + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.prototype.clearAssetcategorytagsList = function() { + return this.setAssetcategorytagsList([]); +}; + + +/** + * optional bool value = 2; + * @return {boolean} + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.prototype.getValue = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 2, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.web.communitygames.AssetCategoryTagBooleanOverride} returns this + */ +proto.web.communitygames.AssetCategoryTagBooleanOverride.prototype.setValue = function(value) { + return jspb.Message.setProto3BooleanField(this, 2, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.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.web.communitygames.AssetCategoryTagBooleanTeamOverride} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.toObject = function(includeInstance, msg) { + var f, obj = { + assetcategorytagsList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f, + value: jspb.Message.getBooleanFieldWithDefault(msg, 2, false), + teamid: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride} + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AssetCategoryTagBooleanTeamOverride; + return proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride} + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.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.addAssetcategorytags(value); + break; + case 2: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setValue(value); + break; + case 3: + var value = /** @type {number} */ (reader.readUint32()); + msg.setTeamid(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getAssetcategorytagsList(); + if (f.length > 0) { + writer.writeRepeatedString( + 1, + f + ); + } + f = message.getValue(); + if (f) { + writer.writeBool( + 2, + f + ); + } + f = message.getTeamid(); + if (f !== 0) { + writer.writeUint32( + 3, + f + ); + } +}; + + +/** + * repeated string assetCategoryTags = 1; + * @return {!Array} + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.prototype.getAssetcategorytagsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride} returns this + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.prototype.setAssetcategorytagsList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {string} value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride} returns this + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.prototype.addAssetcategorytags = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride} returns this + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.prototype.clearAssetcategorytagsList = function() { + return this.setAssetcategorytagsList([]); +}; + + +/** + * optional bool value = 2; + * @return {boolean} + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.prototype.getValue = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 2, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride} returns this + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.prototype.setValue = function(value) { + return jspb.Message.setProto3BooleanField(this, 2, value); +}; + + +/** + * optional uint32 teamId = 3; + * @return {number} + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.prototype.getTeamid = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride} returns this + */ +proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.prototype.setTeamid = function(value) { + return jspb.Message.setProto3IntField(this, 3, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.AssetCategoryBoolean.repeatedFields_ = [3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.AssetCategoryBoolean.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AssetCategoryBoolean.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.web.communitygames.AssetCategoryBoolean} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AssetCategoryBoolean.toObject = function(includeInstance, msg) { + var f, obj = { + defaultvalue: jspb.Message.getBooleanFieldWithDefault(msg, 1, false), + overrides: (f = msg.getOverrides()) && proto.web.communitygames.AssetCategoryTagBooleanOverride.toObject(includeInstance, f), + teamoverridesList: jspb.Message.toObjectList(msg.getTeamoverridesList(), + proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.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.web.communitygames.AssetCategoryBoolean} + */ +proto.web.communitygames.AssetCategoryBoolean.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AssetCategoryBoolean; + return proto.web.communitygames.AssetCategoryBoolean.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AssetCategoryBoolean} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AssetCategoryBoolean} + */ +proto.web.communitygames.AssetCategoryBoolean.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setDefaultvalue(value); + break; + case 2: + var value = new proto.web.communitygames.AssetCategoryTagBooleanOverride; + reader.readMessage(value,proto.web.communitygames.AssetCategoryTagBooleanOverride.deserializeBinaryFromReader); + msg.setOverrides(value); + break; + case 3: + var value = new proto.web.communitygames.AssetCategoryTagBooleanTeamOverride; + reader.readMessage(value,proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.deserializeBinaryFromReader); + msg.addTeamoverrides(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AssetCategoryBoolean.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AssetCategoryBoolean.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AssetCategoryBoolean} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AssetCategoryBoolean.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getDefaultvalue(); + if (f) { + writer.writeBool( + 1, + f + ); + } + f = message.getOverrides(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.AssetCategoryTagBooleanOverride.serializeBinaryToWriter + ); + } + f = message.getTeamoverridesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.web.communitygames.AssetCategoryTagBooleanTeamOverride.serializeBinaryToWriter + ); + } +}; + + +/** + * optional bool defaultValue = 1; + * @return {boolean} + */ +proto.web.communitygames.AssetCategoryBoolean.prototype.getDefaultvalue = function() { + return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false)); +}; + + +/** + * @param {boolean} value + * @return {!proto.web.communitygames.AssetCategoryBoolean} returns this + */ +proto.web.communitygames.AssetCategoryBoolean.prototype.setDefaultvalue = function(value) { + return jspb.Message.setProto3BooleanField(this, 1, value); +}; + + +/** + * optional AssetCategoryTagBooleanOverride overrides = 2; + * @return {?proto.web.communitygames.AssetCategoryTagBooleanOverride} + */ +proto.web.communitygames.AssetCategoryBoolean.prototype.getOverrides = function() { + return /** @type{?proto.web.communitygames.AssetCategoryTagBooleanOverride} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.AssetCategoryTagBooleanOverride, 2)); +}; + + +/** + * @param {?proto.web.communitygames.AssetCategoryTagBooleanOverride|undefined} value + * @return {!proto.web.communitygames.AssetCategoryBoolean} returns this +*/ +proto.web.communitygames.AssetCategoryBoolean.prototype.setOverrides = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AssetCategoryBoolean} returns this + */ +proto.web.communitygames.AssetCategoryBoolean.prototype.clearOverrides = function() { + return this.setOverrides(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AssetCategoryBoolean.prototype.hasOverrides = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * repeated AssetCategoryTagBooleanTeamOverride teamOverrides = 3; + * @return {!Array} + */ +proto.web.communitygames.AssetCategoryBoolean.prototype.getTeamoverridesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.AssetCategoryTagBooleanTeamOverride, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.AssetCategoryBoolean} returns this +*/ +proto.web.communitygames.AssetCategoryBoolean.prototype.setTeamoverridesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AssetCategoryTagBooleanTeamOverride} + */ +proto.web.communitygames.AssetCategoryBoolean.prototype.addTeamoverrides = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.web.communitygames.AssetCategoryTagBooleanTeamOverride, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.AssetCategoryBoolean} returns this + */ +proto.web.communitygames.AssetCategoryBoolean.prototype.clearTeamoverridesList = function() { + return this.setTeamoverridesList([]); +}; + + + + + +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.web.communitygames.AssetCategory.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AssetCategory.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.web.communitygames.AssetCategory} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AssetCategory.toObject = function(includeInstance, msg) { + var f, obj = { + tagid: jspb.Message.getFieldWithDefault(msg, 1, ""), + pb_boolean: (f = msg.getBoolean()) && proto.web.communitygames.AssetCategoryBoolean.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.web.communitygames.AssetCategory} + */ +proto.web.communitygames.AssetCategory.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AssetCategory; + return proto.web.communitygames.AssetCategory.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AssetCategory} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AssetCategory} + */ +proto.web.communitygames.AssetCategory.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.setTagid(value); + break; + case 2: + var value = new proto.web.communitygames.AssetCategoryBoolean; + reader.readMessage(value,proto.web.communitygames.AssetCategoryBoolean.deserializeBinaryFromReader); + msg.setBoolean(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AssetCategory.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AssetCategory.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AssetCategory} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AssetCategory.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTagid(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getBoolean(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.AssetCategoryBoolean.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string tagId = 1; + * @return {string} + */ +proto.web.communitygames.AssetCategory.prototype.getTagid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.AssetCategory} returns this + */ +proto.web.communitygames.AssetCategory.prototype.setTagid = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional AssetCategoryBoolean boolean = 2; + * @return {?proto.web.communitygames.AssetCategoryBoolean} + */ +proto.web.communitygames.AssetCategory.prototype.getBoolean = function() { + return /** @type{?proto.web.communitygames.AssetCategoryBoolean} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.AssetCategoryBoolean, 2)); +}; + + +/** + * @param {?proto.web.communitygames.AssetCategoryBoolean|undefined} value + * @return {!proto.web.communitygames.AssetCategory} returns this +*/ +proto.web.communitygames.AssetCategory.prototype.setBoolean = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AssetCategory} returns this + */ +proto.web.communitygames.AssetCategory.prototype.clearBoolean = function() { + return this.setBoolean(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AssetCategory.prototype.hasBoolean = function() { + return jspb.Message.getField(this, 2) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.Playground.repeatedFields_ = [6,17]; + + + +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.web.communitygames.Playground.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.Playground.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.web.communitygames.Playground} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Playground.toObject = function(includeInstance, msg) { + var f, obj = { + playgroundid: jspb.Message.getFieldWithDefault(msg, 1, ""), + blueprinttype: jspb.Message.getFieldWithDefault(msg, 3, ""), + name: jspb.Message.getFieldWithDefault(msg, 4, ""), + description: jspb.Message.getFieldWithDefault(msg, 5, ""), + mutatorsList: jspb.Message.toObjectList(msg.getMutatorsList(), + proto.web.communitygames.Mutator.toObject, includeInstance), + maprotation: (f = msg.getMaprotation()) && proto.web.communitygames.MapRotation.toObject(includeInstance, f), + state: jspb.Message.getFieldWithDefault(msg, 8, 0), + checksum: jspb.Message.getFieldWithDefault(msg, 9, ""), + secret: jspb.Message.getFieldWithDefault(msg, 10, ""), + createdat: (f = msg.getCreatedat()) && proto.web.communitygames.Timestamp.toObject(includeInstance, f), + updatedat: (f = msg.getUpdatedat()) && proto.web.communitygames.Timestamp.toObject(includeInstance, f), + serversettings: (f = msg.getServersettings()) && proto.web.communitygames.GameServerSettings.toObject(includeInstance, f), + owner: (f = msg.getOwner()) && proto.web.communitygames.PlayerInfo.toObject(includeInstance, f), + restrictions: (f = msg.getRestrictions()) && proto.web.communitygames.Restrictions.toObject(includeInstance, f), + modrules: (f = msg.getModrules()) && proto.web.communitygames.OriginalModRules.toObject(includeInstance, f), + assetcategoriesList: jspb.Message.toObjectList(msg.getAssetcategoriesList(), + proto.web.communitygames.AssetCategory.toObject, includeInstance), + teamcomposition: (f = msg.getTeamcomposition()) && proto.web.communitygames.TeamComposition.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.web.communitygames.Playground} + */ +proto.web.communitygames.Playground.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.Playground; + return proto.web.communitygames.Playground.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.Playground} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.Playground} + */ +proto.web.communitygames.Playground.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.setPlaygroundid(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setBlueprinttype(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 5: + var value = /** @type {string} */ (reader.readString()); + msg.setDescription(value); + break; + case 6: + var value = new proto.web.communitygames.Mutator; + reader.readMessage(value,proto.web.communitygames.Mutator.deserializeBinaryFromReader); + msg.addMutators(value); + break; + case 7: + var value = new proto.web.communitygames.MapRotation; + reader.readMessage(value,proto.web.communitygames.MapRotation.deserializeBinaryFromReader); + msg.setMaprotation(value); + break; + case 8: + var value = /** @type {!proto.web.communitygames.State} */ (reader.readEnum()); + msg.setState(value); + break; + case 9: + var value = /** @type {string} */ (reader.readString()); + msg.setChecksum(value); + break; + case 10: + var value = /** @type {string} */ (reader.readString()); + msg.setSecret(value); + break; + case 11: + var value = new proto.web.communitygames.Timestamp; + reader.readMessage(value,proto.web.communitygames.Timestamp.deserializeBinaryFromReader); + msg.setCreatedat(value); + break; + case 12: + var value = new proto.web.communitygames.Timestamp; + reader.readMessage(value,proto.web.communitygames.Timestamp.deserializeBinaryFromReader); + msg.setUpdatedat(value); + break; + case 13: + var value = new proto.web.communitygames.GameServerSettings; + reader.readMessage(value,proto.web.communitygames.GameServerSettings.deserializeBinaryFromReader); + msg.setServersettings(value); + break; + case 14: + var value = new proto.web.communitygames.PlayerInfo; + reader.readMessage(value,proto.web.communitygames.PlayerInfo.deserializeBinaryFromReader); + msg.setOwner(value); + break; + case 15: + var value = new proto.web.communitygames.Restrictions; + reader.readMessage(value,proto.web.communitygames.Restrictions.deserializeBinaryFromReader); + msg.setRestrictions(value); + break; + case 16: + var value = new proto.web.communitygames.OriginalModRules; + reader.readMessage(value,proto.web.communitygames.OriginalModRules.deserializeBinaryFromReader); + msg.setModrules(value); + break; + case 17: + var value = new proto.web.communitygames.AssetCategory; + reader.readMessage(value,proto.web.communitygames.AssetCategory.deserializeBinaryFromReader); + msg.addAssetcategories(value); + break; + case 18: + var value = new proto.web.communitygames.TeamComposition; + reader.readMessage(value,proto.web.communitygames.TeamComposition.deserializeBinaryFromReader); + msg.setTeamcomposition(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.Playground.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.Playground.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.Playground} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Playground.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPlaygroundid(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getBlueprinttype(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } + f = message.getDescription(); + if (f.length > 0) { + writer.writeString( + 5, + f + ); + } + f = message.getMutatorsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 6, + f, + proto.web.communitygames.Mutator.serializeBinaryToWriter + ); + } + f = message.getMaprotation(); + if (f != null) { + writer.writeMessage( + 7, + f, + proto.web.communitygames.MapRotation.serializeBinaryToWriter + ); + } + f = message.getState(); + if (f !== 0.0) { + writer.writeEnum( + 8, + f + ); + } + f = message.getChecksum(); + if (f.length > 0) { + writer.writeString( + 9, + f + ); + } + f = message.getSecret(); + if (f.length > 0) { + writer.writeString( + 10, + f + ); + } + f = message.getCreatedat(); + if (f != null) { + writer.writeMessage( + 11, + f, + proto.web.communitygames.Timestamp.serializeBinaryToWriter + ); + } + f = message.getUpdatedat(); + if (f != null) { + writer.writeMessage( + 12, + f, + proto.web.communitygames.Timestamp.serializeBinaryToWriter + ); + } + f = message.getServersettings(); + if (f != null) { + writer.writeMessage( + 13, + f, + proto.web.communitygames.GameServerSettings.serializeBinaryToWriter + ); + } + f = message.getOwner(); + if (f != null) { + writer.writeMessage( + 14, + f, + proto.web.communitygames.PlayerInfo.serializeBinaryToWriter + ); + } + f = message.getRestrictions(); + if (f != null) { + writer.writeMessage( + 15, + f, + proto.web.communitygames.Restrictions.serializeBinaryToWriter + ); + } + f = message.getModrules(); + if (f != null) { + writer.writeMessage( + 16, + f, + proto.web.communitygames.OriginalModRules.serializeBinaryToWriter + ); + } + f = message.getAssetcategoriesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 17, + f, + proto.web.communitygames.AssetCategory.serializeBinaryToWriter + ); + } + f = message.getTeamcomposition(); + if (f != null) { + writer.writeMessage( + 18, + f, + proto.web.communitygames.TeamComposition.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string playgroundId = 1; + * @return {string} + */ +proto.web.communitygames.Playground.prototype.getPlaygroundid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.setPlaygroundid = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string blueprintType = 3; + * @return {string} + */ +proto.web.communitygames.Playground.prototype.getBlueprinttype = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.setBlueprinttype = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional string name = 4; + * @return {string} + */ +proto.web.communitygames.Playground.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * optional string description = 5; + * @return {string} + */ +proto.web.communitygames.Playground.prototype.getDescription = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.setDescription = function(value) { + return jspb.Message.setProto3StringField(this, 5, value); +}; + + +/** + * repeated Mutator mutators = 6; + * @return {!Array} + */ +proto.web.communitygames.Playground.prototype.getMutatorsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.Mutator, 6)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.Playground} returns this +*/ +proto.web.communitygames.Playground.prototype.setMutatorsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 6, value); +}; + + +/** + * @param {!proto.web.communitygames.Mutator=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.Mutator} + */ +proto.web.communitygames.Playground.prototype.addMutators = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 6, opt_value, proto.web.communitygames.Mutator, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.clearMutatorsList = function() { + return this.setMutatorsList([]); +}; + + +/** + * optional MapRotation mapRotation = 7; + * @return {?proto.web.communitygames.MapRotation} + */ +proto.web.communitygames.Playground.prototype.getMaprotation = function() { + return /** @type{?proto.web.communitygames.MapRotation} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MapRotation, 7)); +}; + + +/** + * @param {?proto.web.communitygames.MapRotation|undefined} value + * @return {!proto.web.communitygames.Playground} returns this +*/ +proto.web.communitygames.Playground.prototype.setMaprotation = function(value) { + return jspb.Message.setWrapperField(this, 7, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.clearMaprotation = function() { + return this.setMaprotation(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Playground.prototype.hasMaprotation = function() { + return jspb.Message.getField(this, 7) != null; +}; + + +/** + * optional State state = 8; + * @return {!proto.web.communitygames.State} + */ +proto.web.communitygames.Playground.prototype.getState = function() { + return /** @type {!proto.web.communitygames.State} */ (jspb.Message.getFieldWithDefault(this, 8, 0)); +}; + + +/** + * @param {!proto.web.communitygames.State} value + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.setState = function(value) { + return jspb.Message.setProto3EnumField(this, 8, value); +}; + + +/** + * optional string checksum = 9; + * @return {string} + */ +proto.web.communitygames.Playground.prototype.getChecksum = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 9, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.setChecksum = function(value) { + return jspb.Message.setProto3StringField(this, 9, value); +}; + + +/** + * optional string secret = 10; + * @return {string} + */ +proto.web.communitygames.Playground.prototype.getSecret = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 10, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.setSecret = function(value) { + return jspb.Message.setProto3StringField(this, 10, value); +}; + + +/** + * optional Timestamp createdAt = 11; + * @return {?proto.web.communitygames.Timestamp} + */ +proto.web.communitygames.Playground.prototype.getCreatedat = function() { + return /** @type{?proto.web.communitygames.Timestamp} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Timestamp, 11)); +}; + + +/** + * @param {?proto.web.communitygames.Timestamp|undefined} value + * @return {!proto.web.communitygames.Playground} returns this +*/ +proto.web.communitygames.Playground.prototype.setCreatedat = function(value) { + return jspb.Message.setWrapperField(this, 11, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.clearCreatedat = function() { + return this.setCreatedat(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Playground.prototype.hasCreatedat = function() { + return jspb.Message.getField(this, 11) != null; +}; + + +/** + * optional Timestamp updatedAt = 12; + * @return {?proto.web.communitygames.Timestamp} + */ +proto.web.communitygames.Playground.prototype.getUpdatedat = function() { + return /** @type{?proto.web.communitygames.Timestamp} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Timestamp, 12)); +}; + + +/** + * @param {?proto.web.communitygames.Timestamp|undefined} value + * @return {!proto.web.communitygames.Playground} returns this +*/ +proto.web.communitygames.Playground.prototype.setUpdatedat = function(value) { + return jspb.Message.setWrapperField(this, 12, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.clearUpdatedat = function() { + return this.setUpdatedat(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Playground.prototype.hasUpdatedat = function() { + return jspb.Message.getField(this, 12) != null; +}; + + +/** + * optional GameServerSettings serverSettings = 13; + * @return {?proto.web.communitygames.GameServerSettings} + */ +proto.web.communitygames.Playground.prototype.getServersettings = function() { + return /** @type{?proto.web.communitygames.GameServerSettings} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.GameServerSettings, 13)); +}; + + +/** + * @param {?proto.web.communitygames.GameServerSettings|undefined} value + * @return {!proto.web.communitygames.Playground} returns this +*/ +proto.web.communitygames.Playground.prototype.setServersettings = function(value) { + return jspb.Message.setWrapperField(this, 13, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.clearServersettings = function() { + return this.setServersettings(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Playground.prototype.hasServersettings = function() { + return jspb.Message.getField(this, 13) != null; +}; + + +/** + * optional PlayerInfo owner = 14; + * @return {?proto.web.communitygames.PlayerInfo} + */ +proto.web.communitygames.Playground.prototype.getOwner = function() { + return /** @type{?proto.web.communitygames.PlayerInfo} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.PlayerInfo, 14)); +}; + + +/** + * @param {?proto.web.communitygames.PlayerInfo|undefined} value + * @return {!proto.web.communitygames.Playground} returns this +*/ +proto.web.communitygames.Playground.prototype.setOwner = function(value) { + return jspb.Message.setWrapperField(this, 14, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.clearOwner = function() { + return this.setOwner(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Playground.prototype.hasOwner = function() { + return jspb.Message.getField(this, 14) != null; +}; + + +/** + * optional Restrictions restrictions = 15; + * @return {?proto.web.communitygames.Restrictions} + */ +proto.web.communitygames.Playground.prototype.getRestrictions = function() { + return /** @type{?proto.web.communitygames.Restrictions} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Restrictions, 15)); +}; + + +/** + * @param {?proto.web.communitygames.Restrictions|undefined} value + * @return {!proto.web.communitygames.Playground} returns this +*/ +proto.web.communitygames.Playground.prototype.setRestrictions = function(value) { + return jspb.Message.setWrapperField(this, 15, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.clearRestrictions = function() { + return this.setRestrictions(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Playground.prototype.hasRestrictions = function() { + return jspb.Message.getField(this, 15) != null; +}; + + +/** + * optional OriginalModRules modRules = 16; + * @return {?proto.web.communitygames.OriginalModRules} + */ +proto.web.communitygames.Playground.prototype.getModrules = function() { + return /** @type{?proto.web.communitygames.OriginalModRules} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.OriginalModRules, 16)); +}; + + +/** + * @param {?proto.web.communitygames.OriginalModRules|undefined} value + * @return {!proto.web.communitygames.Playground} returns this +*/ +proto.web.communitygames.Playground.prototype.setModrules = function(value) { + return jspb.Message.setWrapperField(this, 16, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.clearModrules = function() { + return this.setModrules(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Playground.prototype.hasModrules = function() { + return jspb.Message.getField(this, 16) != null; +}; + + +/** + * repeated AssetCategory assetCategories = 17; + * @return {!Array} + */ +proto.web.communitygames.Playground.prototype.getAssetcategoriesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.AssetCategory, 17)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.Playground} returns this +*/ +proto.web.communitygames.Playground.prototype.setAssetcategoriesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 17, value); +}; + + +/** + * @param {!proto.web.communitygames.AssetCategory=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AssetCategory} + */ +proto.web.communitygames.Playground.prototype.addAssetcategories = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 17, opt_value, proto.web.communitygames.AssetCategory, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.clearAssetcategoriesList = function() { + return this.setAssetcategoriesList([]); +}; + + +/** + * optional TeamComposition teamComposition = 18; + * @return {?proto.web.communitygames.TeamComposition} + */ +proto.web.communitygames.Playground.prototype.getTeamcomposition = function() { + return /** @type{?proto.web.communitygames.TeamComposition} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.TeamComposition, 18)); +}; + + +/** + * @param {?proto.web.communitygames.TeamComposition|undefined} value + * @return {!proto.web.communitygames.Playground} returns this +*/ +proto.web.communitygames.Playground.prototype.setTeamcomposition = function(value) { + return jspb.Message.setWrapperField(this, 18, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Playground} returns this + */ +proto.web.communitygames.Playground.prototype.clearTeamcomposition = function() { + return this.setTeamcomposition(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Playground.prototype.hasTeamcomposition = function() { + return jspb.Message.getField(this, 18) != 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.web.communitygames.ListPlaygroundsByOwnerRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.ListPlaygroundsByOwnerRequest.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.web.communitygames.ListPlaygroundsByOwnerRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ListPlaygroundsByOwnerRequest.toObject = function(includeInstance, msg) { + var f, obj = { + blueprinttype: jspb.Message.getFieldWithDefault(msg, 1, ""), + protocolversion: 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.web.communitygames.ListPlaygroundsByOwnerRequest} + */ +proto.web.communitygames.ListPlaygroundsByOwnerRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.ListPlaygroundsByOwnerRequest; + return proto.web.communitygames.ListPlaygroundsByOwnerRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.ListPlaygroundsByOwnerRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.ListPlaygroundsByOwnerRequest} + */ +proto.web.communitygames.ListPlaygroundsByOwnerRequest.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.setBlueprinttype(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setProtocolversion(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.ListPlaygroundsByOwnerRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.ListPlaygroundsByOwnerRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.ListPlaygroundsByOwnerRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ListPlaygroundsByOwnerRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getBlueprinttype(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getProtocolversion(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional string blueprintType = 1; + * @return {string} + */ +proto.web.communitygames.ListPlaygroundsByOwnerRequest.prototype.getBlueprinttype = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.ListPlaygroundsByOwnerRequest} returns this + */ +proto.web.communitygames.ListPlaygroundsByOwnerRequest.prototype.setBlueprinttype = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string protocolVersion = 2; + * @return {string} + */ +proto.web.communitygames.ListPlaygroundsByOwnerRequest.prototype.getProtocolversion = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.ListPlaygroundsByOwnerRequest} returns this + */ +proto.web.communitygames.ListPlaygroundsByOwnerRequest.prototype.setProtocolversion = 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.web.communitygames.GetConstraintsRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GetConstraintsRequest.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.web.communitygames.GetConstraintsRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetConstraintsRequest.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.GetConstraintsRequest} + */ +proto.web.communitygames.GetConstraintsRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GetConstraintsRequest; + return proto.web.communitygames.GetConstraintsRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GetConstraintsRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GetConstraintsRequest} + */ +proto.web.communitygames.GetConstraintsRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GetConstraintsRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GetConstraintsRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GetConstraintsRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetConstraintsRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.GetBlueprintsByIdRequest.repeatedFields_ = [1,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.web.communitygames.GetBlueprintsByIdRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GetBlueprintsByIdRequest.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.web.communitygames.GetBlueprintsByIdRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetBlueprintsByIdRequest.toObject = function(includeInstance, msg) { + var f, obj = { + blueprintidsList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f, + includefieldsList: (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.web.communitygames.GetBlueprintsByIdRequest} + */ +proto.web.communitygames.GetBlueprintsByIdRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GetBlueprintsByIdRequest; + return proto.web.communitygames.GetBlueprintsByIdRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GetBlueprintsByIdRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GetBlueprintsByIdRequest} + */ +proto.web.communitygames.GetBlueprintsByIdRequest.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.addBlueprintids(value); + break; + case 2: + var value = /** @type {!Array} */ (reader.readPackedEnum()); + msg.setIncludefieldsList(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GetBlueprintsByIdRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GetBlueprintsByIdRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GetBlueprintsByIdRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetBlueprintsByIdRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getBlueprintidsList(); + if (f.length > 0) { + writer.writeRepeatedString( + 1, + f + ); + } + f = message.getIncludefieldsList(); + if (f.length > 0) { + writer.writePackedEnum( + 2, + f + ); + } +}; + + +/** + * repeated string blueprintIds = 1; + * @return {!Array} + */ +proto.web.communitygames.GetBlueprintsByIdRequest.prototype.getBlueprintidsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.GetBlueprintsByIdRequest} returns this + */ +proto.web.communitygames.GetBlueprintsByIdRequest.prototype.setBlueprintidsList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {string} value + * @param {number=} opt_index + * @return {!proto.web.communitygames.GetBlueprintsByIdRequest} returns this + */ +proto.web.communitygames.GetBlueprintsByIdRequest.prototype.addBlueprintids = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.GetBlueprintsByIdRequest} returns this + */ +proto.web.communitygames.GetBlueprintsByIdRequest.prototype.clearBlueprintidsList = function() { + return this.setBlueprintidsList([]); +}; + + +/** + * repeated IncludeFields includeFields = 2; + * @return {!Array} + */ +proto.web.communitygames.GetBlueprintsByIdRequest.prototype.getIncludefieldsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.GetBlueprintsByIdRequest} returns this + */ +proto.web.communitygames.GetBlueprintsByIdRequest.prototype.setIncludefieldsList = function(value) { + return jspb.Message.setField(this, 2, value || []); +}; + + +/** + * @param {!proto.web.communitygames.IncludeFields} value + * @param {number=} opt_index + * @return {!proto.web.communitygames.GetBlueprintsByIdRequest} returns this + */ +proto.web.communitygames.GetBlueprintsByIdRequest.prototype.addIncludefields = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 2, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.GetBlueprintsByIdRequest} returns this + */ +proto.web.communitygames.GetBlueprintsByIdRequest.prototype.clearIncludefieldsList = function() { + return this.setIncludefieldsList([]); +}; + + + + + +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.web.communitygames.GlobalConstraints.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GlobalConstraints.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.web.communitygames.GlobalConstraints} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GlobalConstraints.toObject = function(includeInstance, msg) { + var f, obj = { + maxplaygroundsperplayer: jspb.Message.getFieldWithDefault(msg, 1, 0), + maxgameserversperplayer: jspb.Message.getFieldWithDefault(msg, 2, 0), + maxfollowedhostslistsize: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.GlobalConstraints} + */ +proto.web.communitygames.GlobalConstraints.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GlobalConstraints; + return proto.web.communitygames.GlobalConstraints.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GlobalConstraints} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GlobalConstraints} + */ +proto.web.communitygames.GlobalConstraints.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.setMaxplaygroundsperplayer(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setMaxgameserversperplayer(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setMaxfollowedhostslistsize(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GlobalConstraints.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GlobalConstraints.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GlobalConstraints} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GlobalConstraints.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getMaxplaygroundsperplayer(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getMaxgameserversperplayer(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getMaxfollowedhostslistsize(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } +}; + + +/** + * optional int32 maxPlaygroundsPerPlayer = 1; + * @return {number} + */ +proto.web.communitygames.GlobalConstraints.prototype.getMaxplaygroundsperplayer = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.GlobalConstraints} returns this + */ +proto.web.communitygames.GlobalConstraints.prototype.setMaxplaygroundsperplayer = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional int32 maxGameServersPerPlayer = 2; + * @return {number} + */ +proto.web.communitygames.GlobalConstraints.prototype.getMaxgameserversperplayer = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.GlobalConstraints} returns this + */ +proto.web.communitygames.GlobalConstraints.prototype.setMaxgameserversperplayer = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional int32 maxFollowedHostsListSize = 3; + * @return {number} + */ +proto.web.communitygames.GlobalConstraints.prototype.getMaxfollowedhostslistsize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.GlobalConstraints} returns this + */ +proto.web.communitygames.GlobalConstraints.prototype.setMaxfollowedhostslistsize = function(value) { + return jspb.Message.setProto3IntField(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.web.communitygames.IntRange.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.IntRange.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.web.communitygames.IntRange} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.IntRange.toObject = function(includeInstance, msg) { + var f, obj = { + minvalue: jspb.Message.getFieldWithDefault(msg, 1, 0), + maxvalue: jspb.Message.getFieldWithDefault(msg, 2, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.IntRange} + */ +proto.web.communitygames.IntRange.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.IntRange; + return proto.web.communitygames.IntRange.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.IntRange} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.IntRange} + */ +proto.web.communitygames.IntRange.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.setMinvalue(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setMaxvalue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.IntRange.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.IntRange.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.IntRange} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.IntRange.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getMinvalue(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getMaxvalue(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } +}; + + +/** + * optional int32 minValue = 1; + * @return {number} + */ +proto.web.communitygames.IntRange.prototype.getMinvalue = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.IntRange} returns this + */ +proto.web.communitygames.IntRange.prototype.setMinvalue = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional int32 maxValue = 2; + * @return {number} + */ +proto.web.communitygames.IntRange.prototype.getMaxvalue = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.IntRange} returns this + */ +proto.web.communitygames.IntRange.prototype.setMaxvalue = function(value) { + return jspb.Message.setProto3IntField(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.web.communitygames.AvailableIntValues.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AvailableIntValues.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.web.communitygames.AvailableIntValues} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableIntValues.toObject = function(includeInstance, msg) { + var f, obj = { + range: (f = msg.getRange()) && proto.web.communitygames.IntRange.toObject(includeInstance, f), + sparsevalues: (f = msg.getSparsevalues()) && proto.web.communitygames.SparseIntEntity.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.web.communitygames.AvailableIntValues} + */ +proto.web.communitygames.AvailableIntValues.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AvailableIntValues; + return proto.web.communitygames.AvailableIntValues.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AvailableIntValues} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AvailableIntValues} + */ +proto.web.communitygames.AvailableIntValues.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.IntRange; + reader.readMessage(value,proto.web.communitygames.IntRange.deserializeBinaryFromReader); + msg.setRange(value); + break; + case 2: + var value = new proto.web.communitygames.SparseIntEntity; + reader.readMessage(value,proto.web.communitygames.SparseIntEntity.deserializeBinaryFromReader); + msg.setSparsevalues(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AvailableIntValues.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AvailableIntValues.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AvailableIntValues} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableIntValues.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getRange(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.IntRange.serializeBinaryToWriter + ); + } + f = message.getSparsevalues(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.SparseIntEntity.serializeBinaryToWriter + ); + } +}; + + +/** + * optional IntRange range = 1; + * @return {?proto.web.communitygames.IntRange} + */ +proto.web.communitygames.AvailableIntValues.prototype.getRange = function() { + return /** @type{?proto.web.communitygames.IntRange} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.IntRange, 1)); +}; + + +/** + * @param {?proto.web.communitygames.IntRange|undefined} value + * @return {!proto.web.communitygames.AvailableIntValues} returns this +*/ +proto.web.communitygames.AvailableIntValues.prototype.setRange = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableIntValues} returns this + */ +proto.web.communitygames.AvailableIntValues.prototype.clearRange = function() { + return this.setRange(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableIntValues.prototype.hasRange = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional SparseIntEntity sparseValues = 2; + * @return {?proto.web.communitygames.SparseIntEntity} + */ +proto.web.communitygames.AvailableIntValues.prototype.getSparsevalues = function() { + return /** @type{?proto.web.communitygames.SparseIntEntity} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.SparseIntEntity, 2)); +}; + + +/** + * @param {?proto.web.communitygames.SparseIntEntity|undefined} value + * @return {!proto.web.communitygames.AvailableIntValues} returns this +*/ +proto.web.communitygames.AvailableIntValues.prototype.setSparsevalues = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableIntValues} returns this + */ +proto.web.communitygames.AvailableIntValues.prototype.clearSparsevalues = function() { + return this.setSparsevalues(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableIntValues.prototype.hasSparsevalues = 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.web.communitygames.AvailableIntValue.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AvailableIntValue.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.web.communitygames.AvailableIntValue} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableIntValue.toObject = function(includeInstance, msg) { + var f, obj = { + defaultvalue: jspb.Message.getFieldWithDefault(msg, 1, 0), + availablevalues: (f = msg.getAvailablevalues()) && proto.web.communitygames.AvailableIntValues.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.web.communitygames.AvailableIntValue} + */ +proto.web.communitygames.AvailableIntValue.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AvailableIntValue; + return proto.web.communitygames.AvailableIntValue.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AvailableIntValue} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AvailableIntValue} + */ +proto.web.communitygames.AvailableIntValue.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.setDefaultvalue(value); + break; + case 2: + var value = new proto.web.communitygames.AvailableIntValues; + reader.readMessage(value,proto.web.communitygames.AvailableIntValues.deserializeBinaryFromReader); + msg.setAvailablevalues(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AvailableIntValue.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AvailableIntValue.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AvailableIntValue} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableIntValue.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getDefaultvalue(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getAvailablevalues(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.AvailableIntValues.serializeBinaryToWriter + ); + } +}; + + +/** + * optional int32 defaultValue = 1; + * @return {number} + */ +proto.web.communitygames.AvailableIntValue.prototype.getDefaultvalue = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.AvailableIntValue} returns this + */ +proto.web.communitygames.AvailableIntValue.prototype.setDefaultvalue = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional AvailableIntValues availableValues = 2; + * @return {?proto.web.communitygames.AvailableIntValues} + */ +proto.web.communitygames.AvailableIntValue.prototype.getAvailablevalues = function() { + return /** @type{?proto.web.communitygames.AvailableIntValues} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.AvailableIntValues, 2)); +}; + + +/** + * @param {?proto.web.communitygames.AvailableIntValues|undefined} value + * @return {!proto.web.communitygames.AvailableIntValue} returns this +*/ +proto.web.communitygames.AvailableIntValue.prototype.setAvailablevalues = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableIntValue} returns this + */ +proto.web.communitygames.AvailableIntValue.prototype.clearAvailablevalues = function() { + return this.setAvailablevalues(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableIntValue.prototype.hasAvailablevalues = 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.web.communitygames.AvailableMutator.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AvailableMutator.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.web.communitygames.AvailableMutator} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableMutator.toObject = function(includeInstance, msg) { + var f, obj = { + name: jspb.Message.getFieldWithDefault(msg, 1, ""), + category: jspb.Message.getFieldWithDefault(msg, 2, ""), + metadata: (f = msg.getMetadata()) && proto.web.communitygames.Metadata.toObject(includeInstance, f), + id: jspb.Message.getFieldWithDefault(msg, 5, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.AvailableMutator} + */ +proto.web.communitygames.AvailableMutator.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AvailableMutator; + return proto.web.communitygames.AvailableMutator.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AvailableMutator} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AvailableMutator} + */ +proto.web.communitygames.AvailableMutator.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.setCategory(value); + break; + case 4: + var value = new proto.web.communitygames.Metadata; + reader.readMessage(value,proto.web.communitygames.Metadata.deserializeBinaryFromReader); + msg.setMetadata(value); + break; + case 5: + var value = /** @type {string} */ (reader.readString()); + msg.setId(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AvailableMutator.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AvailableMutator.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AvailableMutator} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableMutator.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getCategory(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getMetadata(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.communitygames.Metadata.serializeBinaryToWriter + ); + } + f = message.getId(); + if (f.length > 0) { + writer.writeString( + 5, + f + ); + } +}; + + +/** + * optional string name = 1; + * @return {string} + */ +proto.web.communitygames.AvailableMutator.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.AvailableMutator} returns this + */ +proto.web.communitygames.AvailableMutator.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string category = 2; + * @return {string} + */ +proto.web.communitygames.AvailableMutator.prototype.getCategory = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.AvailableMutator} returns this + */ +proto.web.communitygames.AvailableMutator.prototype.setCategory = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional Metadata metadata = 4; + * @return {?proto.web.communitygames.Metadata} + */ +proto.web.communitygames.AvailableMutator.prototype.getMetadata = function() { + return /** @type{?proto.web.communitygames.Metadata} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Metadata, 4)); +}; + + +/** + * @param {?proto.web.communitygames.Metadata|undefined} value + * @return {!proto.web.communitygames.AvailableMutator} returns this +*/ +proto.web.communitygames.AvailableMutator.prototype.setMetadata = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableMutator} returns this + */ +proto.web.communitygames.AvailableMutator.prototype.clearMetadata = function() { + return this.setMetadata(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableMutator.prototype.hasMetadata = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +/** + * optional string id = 5; + * @return {string} + */ +proto.web.communitygames.AvailableMutator.prototype.getId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.AvailableMutator} returns this + */ +proto.web.communitygames.AvailableMutator.prototype.setId = function(value) { + return jspb.Message.setProto3StringField(this, 5, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.AvailableMapEntry.repeatedFields_ = [9,10]; + + + +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.web.communitygames.AvailableMapEntry.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AvailableMapEntry.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.web.communitygames.AvailableMapEntry} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableMapEntry.toObject = function(includeInstance, msg) { + var f, obj = { + levelname: jspb.Message.getFieldWithDefault(msg, 1, ""), + gamemode: jspb.Message.getFieldWithDefault(msg, 2, ""), + levellocation: jspb.Message.getFieldWithDefault(msg, 3, ""), + gamesize: (f = msg.getGamesize()) && proto.web.communitygames.AvailableIntValue.toObject(includeInstance, f), + rounds: (f = msg.getRounds()) && proto.web.communitygames.AvailableIntValue.toObject(includeInstance, f), + preroundsize: (f = msg.getPreroundsize()) && proto.web.communitygames.AvailableIntValue.toObject(includeInstance, f), + warmupsize: (f = msg.getWarmupsize()) && proto.web.communitygames.AvailableIntValue.toObject(includeInstance, f), + allowedspectators: (f = msg.getAllowedspectators()) && proto.web.communitygames.AvailableIntValue.toObject(includeInstance, f), + mutatorsList: jspb.Message.toObjectList(msg.getMutatorsList(), + proto.web.communitygames.AvailableMutator.toObject, includeInstance), + metadataList: jspb.Message.toObjectList(msg.getMetadataList(), + proto.web.communitygames.Metadata.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.web.communitygames.AvailableMapEntry} + */ +proto.web.communitygames.AvailableMapEntry.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AvailableMapEntry; + return proto.web.communitygames.AvailableMapEntry.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AvailableMapEntry} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AvailableMapEntry} + */ +proto.web.communitygames.AvailableMapEntry.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.setLevelname(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setGamemode(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setLevellocation(value); + break; + case 4: + var value = new proto.web.communitygames.AvailableIntValue; + reader.readMessage(value,proto.web.communitygames.AvailableIntValue.deserializeBinaryFromReader); + msg.setGamesize(value); + break; + case 5: + var value = new proto.web.communitygames.AvailableIntValue; + reader.readMessage(value,proto.web.communitygames.AvailableIntValue.deserializeBinaryFromReader); + msg.setRounds(value); + break; + case 6: + var value = new proto.web.communitygames.AvailableIntValue; + reader.readMessage(value,proto.web.communitygames.AvailableIntValue.deserializeBinaryFromReader); + msg.setPreroundsize(value); + break; + case 7: + var value = new proto.web.communitygames.AvailableIntValue; + reader.readMessage(value,proto.web.communitygames.AvailableIntValue.deserializeBinaryFromReader); + msg.setWarmupsize(value); + break; + case 8: + var value = new proto.web.communitygames.AvailableIntValue; + reader.readMessage(value,proto.web.communitygames.AvailableIntValue.deserializeBinaryFromReader); + msg.setAllowedspectators(value); + break; + case 9: + var value = new proto.web.communitygames.AvailableMutator; + reader.readMessage(value,proto.web.communitygames.AvailableMutator.deserializeBinaryFromReader); + msg.addMutators(value); + break; + case 10: + var value = new proto.web.communitygames.Metadata; + reader.readMessage(value,proto.web.communitygames.Metadata.deserializeBinaryFromReader); + msg.addMetadata(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AvailableMapEntry.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AvailableMapEntry.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AvailableMapEntry} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableMapEntry.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getLevelname(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getGamemode(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getLevellocation(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getGamesize(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.communitygames.AvailableIntValue.serializeBinaryToWriter + ); + } + f = message.getRounds(); + if (f != null) { + writer.writeMessage( + 5, + f, + proto.web.communitygames.AvailableIntValue.serializeBinaryToWriter + ); + } + f = message.getPreroundsize(); + if (f != null) { + writer.writeMessage( + 6, + f, + proto.web.communitygames.AvailableIntValue.serializeBinaryToWriter + ); + } + f = message.getWarmupsize(); + if (f != null) { + writer.writeMessage( + 7, + f, + proto.web.communitygames.AvailableIntValue.serializeBinaryToWriter + ); + } + f = message.getAllowedspectators(); + if (f != null) { + writer.writeMessage( + 8, + f, + proto.web.communitygames.AvailableIntValue.serializeBinaryToWriter + ); + } + f = message.getMutatorsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 9, + f, + proto.web.communitygames.AvailableMutator.serializeBinaryToWriter + ); + } + f = message.getMetadataList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 10, + f, + proto.web.communitygames.Metadata.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string levelName = 1; + * @return {string} + */ +proto.web.communitygames.AvailableMapEntry.prototype.getLevelname = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.AvailableMapEntry} returns this + */ +proto.web.communitygames.AvailableMapEntry.prototype.setLevelname = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string gameMode = 2; + * @return {string} + */ +proto.web.communitygames.AvailableMapEntry.prototype.getGamemode = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.AvailableMapEntry} returns this + */ +proto.web.communitygames.AvailableMapEntry.prototype.setGamemode = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string levelLocation = 3; + * @return {string} + */ +proto.web.communitygames.AvailableMapEntry.prototype.getLevellocation = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.AvailableMapEntry} returns this + */ +proto.web.communitygames.AvailableMapEntry.prototype.setLevellocation = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional AvailableIntValue gameSize = 4; + * @return {?proto.web.communitygames.AvailableIntValue} + */ +proto.web.communitygames.AvailableMapEntry.prototype.getGamesize = function() { + return /** @type{?proto.web.communitygames.AvailableIntValue} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.AvailableIntValue, 4)); +}; + + +/** + * @param {?proto.web.communitygames.AvailableIntValue|undefined} value + * @return {!proto.web.communitygames.AvailableMapEntry} returns this +*/ +proto.web.communitygames.AvailableMapEntry.prototype.setGamesize = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableMapEntry} returns this + */ +proto.web.communitygames.AvailableMapEntry.prototype.clearGamesize = function() { + return this.setGamesize(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableMapEntry.prototype.hasGamesize = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +/** + * optional AvailableIntValue rounds = 5; + * @return {?proto.web.communitygames.AvailableIntValue} + */ +proto.web.communitygames.AvailableMapEntry.prototype.getRounds = function() { + return /** @type{?proto.web.communitygames.AvailableIntValue} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.AvailableIntValue, 5)); +}; + + +/** + * @param {?proto.web.communitygames.AvailableIntValue|undefined} value + * @return {!proto.web.communitygames.AvailableMapEntry} returns this +*/ +proto.web.communitygames.AvailableMapEntry.prototype.setRounds = function(value) { + return jspb.Message.setWrapperField(this, 5, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableMapEntry} returns this + */ +proto.web.communitygames.AvailableMapEntry.prototype.clearRounds = function() { + return this.setRounds(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableMapEntry.prototype.hasRounds = function() { + return jspb.Message.getField(this, 5) != null; +}; + + +/** + * optional AvailableIntValue preRoundSize = 6; + * @return {?proto.web.communitygames.AvailableIntValue} + */ +proto.web.communitygames.AvailableMapEntry.prototype.getPreroundsize = function() { + return /** @type{?proto.web.communitygames.AvailableIntValue} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.AvailableIntValue, 6)); +}; + + +/** + * @param {?proto.web.communitygames.AvailableIntValue|undefined} value + * @return {!proto.web.communitygames.AvailableMapEntry} returns this +*/ +proto.web.communitygames.AvailableMapEntry.prototype.setPreroundsize = function(value) { + return jspb.Message.setWrapperField(this, 6, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableMapEntry} returns this + */ +proto.web.communitygames.AvailableMapEntry.prototype.clearPreroundsize = function() { + return this.setPreroundsize(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableMapEntry.prototype.hasPreroundsize = function() { + return jspb.Message.getField(this, 6) != null; +}; + + +/** + * optional AvailableIntValue warmUpSize = 7; + * @return {?proto.web.communitygames.AvailableIntValue} + */ +proto.web.communitygames.AvailableMapEntry.prototype.getWarmupsize = function() { + return /** @type{?proto.web.communitygames.AvailableIntValue} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.AvailableIntValue, 7)); +}; + + +/** + * @param {?proto.web.communitygames.AvailableIntValue|undefined} value + * @return {!proto.web.communitygames.AvailableMapEntry} returns this +*/ +proto.web.communitygames.AvailableMapEntry.prototype.setWarmupsize = function(value) { + return jspb.Message.setWrapperField(this, 7, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableMapEntry} returns this + */ +proto.web.communitygames.AvailableMapEntry.prototype.clearWarmupsize = function() { + return this.setWarmupsize(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableMapEntry.prototype.hasWarmupsize = function() { + return jspb.Message.getField(this, 7) != null; +}; + + +/** + * optional AvailableIntValue allowedSpectators = 8; + * @return {?proto.web.communitygames.AvailableIntValue} + */ +proto.web.communitygames.AvailableMapEntry.prototype.getAllowedspectators = function() { + return /** @type{?proto.web.communitygames.AvailableIntValue} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.AvailableIntValue, 8)); +}; + + +/** + * @param {?proto.web.communitygames.AvailableIntValue|undefined} value + * @return {!proto.web.communitygames.AvailableMapEntry} returns this +*/ +proto.web.communitygames.AvailableMapEntry.prototype.setAllowedspectators = function(value) { + return jspb.Message.setWrapperField(this, 8, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableMapEntry} returns this + */ +proto.web.communitygames.AvailableMapEntry.prototype.clearAllowedspectators = function() { + return this.setAllowedspectators(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableMapEntry.prototype.hasAllowedspectators = function() { + return jspb.Message.getField(this, 8) != null; +}; + + +/** + * repeated AvailableMutator mutators = 9; + * @return {!Array} + */ +proto.web.communitygames.AvailableMapEntry.prototype.getMutatorsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.AvailableMutator, 9)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.AvailableMapEntry} returns this +*/ +proto.web.communitygames.AvailableMapEntry.prototype.setMutatorsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 9, value); +}; + + +/** + * @param {!proto.web.communitygames.AvailableMutator=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AvailableMutator} + */ +proto.web.communitygames.AvailableMapEntry.prototype.addMutators = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 9, opt_value, proto.web.communitygames.AvailableMutator, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.AvailableMapEntry} returns this + */ +proto.web.communitygames.AvailableMapEntry.prototype.clearMutatorsList = function() { + return this.setMutatorsList([]); +}; + + +/** + * repeated Metadata metadata = 10; + * @return {!Array} + */ +proto.web.communitygames.AvailableMapEntry.prototype.getMetadataList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.Metadata, 10)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.AvailableMapEntry} returns this +*/ +proto.web.communitygames.AvailableMapEntry.prototype.setMetadataList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 10, value); +}; + + +/** + * @param {!proto.web.communitygames.Metadata=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.Metadata} + */ +proto.web.communitygames.AvailableMapEntry.prototype.addMetadata = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 10, opt_value, proto.web.communitygames.Metadata, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.AvailableMapEntry} returns this + */ +proto.web.communitygames.AvailableMapEntry.prototype.clearMetadataList = function() { + return this.setMetadataList([]); +}; + + + + + +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.web.communitygames.AvailableTag.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AvailableTag.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.web.communitygames.AvailableTag} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableTag.toObject = function(includeInstance, msg) { + var f, obj = { + id: jspb.Message.getFieldWithDefault(msg, 1, ""), + metadata: (f = msg.getMetadata()) && proto.web.communitygames.Metadata.toObject(includeInstance, f), + category: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.AvailableTag} + */ +proto.web.communitygames.AvailableTag.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AvailableTag; + return proto.web.communitygames.AvailableTag.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AvailableTag} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AvailableTag} + */ +proto.web.communitygames.AvailableTag.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setId(value); + break; + case 2: + var value = new proto.web.communitygames.Metadata; + reader.readMessage(value,proto.web.communitygames.Metadata.deserializeBinaryFromReader); + msg.setMetadata(value); + break; + case 3: + var value = /** @type {!proto.web.communitygames.Category} */ (reader.readEnum()); + msg.setCategory(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AvailableTag.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AvailableTag.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AvailableTag} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableTag.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getId(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getMetadata(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.Metadata.serializeBinaryToWriter + ); + } + f = message.getCategory(); + if (f !== 0.0) { + writer.writeEnum( + 3, + f + ); + } +}; + + +/** + * optional string id = 1; + * @return {string} + */ +proto.web.communitygames.AvailableTag.prototype.getId = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.AvailableTag} returns this + */ +proto.web.communitygames.AvailableTag.prototype.setId = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional Metadata metadata = 2; + * @return {?proto.web.communitygames.Metadata} + */ +proto.web.communitygames.AvailableTag.prototype.getMetadata = function() { + return /** @type{?proto.web.communitygames.Metadata} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Metadata, 2)); +}; + + +/** + * @param {?proto.web.communitygames.Metadata|undefined} value + * @return {!proto.web.communitygames.AvailableTag} returns this +*/ +proto.web.communitygames.AvailableTag.prototype.setMetadata = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableTag} returns this + */ +proto.web.communitygames.AvailableTag.prototype.clearMetadata = function() { + return this.setMetadata(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableTag.prototype.hasMetadata = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * optional Category category = 3; + * @return {!proto.web.communitygames.Category} + */ +proto.web.communitygames.AvailableTag.prototype.getCategory = function() { + return /** @type {!proto.web.communitygames.Category} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {!proto.web.communitygames.Category} value + * @return {!proto.web.communitygames.AvailableTag} returns this + */ +proto.web.communitygames.AvailableTag.prototype.setCategory = function(value) { + return jspb.Message.setProto3EnumField(this, 3, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.AvailableAssetCategoryTag.repeatedFields_ = [3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AvailableAssetCategoryTag.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.web.communitygames.AvailableAssetCategoryTag} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableAssetCategoryTag.toObject = function(includeInstance, msg) { + var f, obj = { + tagid: jspb.Message.getFieldWithDefault(msg, 1, ""), + name: jspb.Message.getFieldWithDefault(msg, 2, ""), + childrentagsList: (f = jspb.Message.getRepeatedField(msg, 3)) == null ? undefined : f, + metadata: (f = msg.getMetadata()) && proto.web.communitygames.Metadata.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.web.communitygames.AvailableAssetCategoryTag} + */ +proto.web.communitygames.AvailableAssetCategoryTag.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AvailableAssetCategoryTag; + return proto.web.communitygames.AvailableAssetCategoryTag.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AvailableAssetCategoryTag} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AvailableAssetCategoryTag} + */ +proto.web.communitygames.AvailableAssetCategoryTag.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.setTagid(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.addChildrentags(value); + break; + case 4: + var value = new proto.web.communitygames.Metadata; + reader.readMessage(value,proto.web.communitygames.Metadata.deserializeBinaryFromReader); + msg.setMetadata(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AvailableAssetCategoryTag.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AvailableAssetCategoryTag} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableAssetCategoryTag.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTagid(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getChildrentagsList(); + if (f.length > 0) { + writer.writeRepeatedString( + 3, + f + ); + } + f = message.getMetadata(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.communitygames.Metadata.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string tagId = 1; + * @return {string} + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.getTagid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.AvailableAssetCategoryTag} returns this + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.setTagid = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string name = 2; + * @return {string} + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.AvailableAssetCategoryTag} returns this + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * repeated string childrenTags = 3; + * @return {!Array} + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.getChildrentagsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.AvailableAssetCategoryTag} returns this + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.setChildrentagsList = function(value) { + return jspb.Message.setField(this, 3, value || []); +}; + + +/** + * @param {string} value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AvailableAssetCategoryTag} returns this + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.addChildrentags = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 3, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.AvailableAssetCategoryTag} returns this + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.clearChildrentagsList = function() { + return this.setChildrentagsList([]); +}; + + +/** + * optional Metadata metadata = 4; + * @return {?proto.web.communitygames.Metadata} + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.getMetadata = function() { + return /** @type{?proto.web.communitygames.Metadata} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Metadata, 4)); +}; + + +/** + * @param {?proto.web.communitygames.Metadata|undefined} value + * @return {!proto.web.communitygames.AvailableAssetCategoryTag} returns this +*/ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.setMetadata = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableAssetCategoryTag} returns this + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.clearMetadata = function() { + return this.setMetadata(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableAssetCategoryTag.prototype.hasMetadata = function() { + return jspb.Message.getField(this, 4) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.AvailableAssetCategories.repeatedFields_ = [1,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.web.communitygames.AvailableAssetCategories.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AvailableAssetCategories.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.web.communitygames.AvailableAssetCategories} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableAssetCategories.toObject = function(includeInstance, msg) { + var f, obj = { + roottagsList: jspb.Message.toObjectList(msg.getRoottagsList(), + proto.web.communitygames.AvailableAssetCategoryTag.toObject, includeInstance), + tagsList: jspb.Message.toObjectList(msg.getTagsList(), + proto.web.communitygames.AvailableAssetCategoryTag.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.web.communitygames.AvailableAssetCategories} + */ +proto.web.communitygames.AvailableAssetCategories.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AvailableAssetCategories; + return proto.web.communitygames.AvailableAssetCategories.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AvailableAssetCategories} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AvailableAssetCategories} + */ +proto.web.communitygames.AvailableAssetCategories.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.AvailableAssetCategoryTag; + reader.readMessage(value,proto.web.communitygames.AvailableAssetCategoryTag.deserializeBinaryFromReader); + msg.addRoottags(value); + break; + case 2: + var value = new proto.web.communitygames.AvailableAssetCategoryTag; + reader.readMessage(value,proto.web.communitygames.AvailableAssetCategoryTag.deserializeBinaryFromReader); + msg.addTags(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AvailableAssetCategories.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AvailableAssetCategories.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AvailableAssetCategories} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableAssetCategories.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getRoottagsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.web.communitygames.AvailableAssetCategoryTag.serializeBinaryToWriter + ); + } + f = message.getTagsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.web.communitygames.AvailableAssetCategoryTag.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated AvailableAssetCategoryTag rootTags = 1; + * @return {!Array} + */ +proto.web.communitygames.AvailableAssetCategories.prototype.getRoottagsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.AvailableAssetCategoryTag, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.AvailableAssetCategories} returns this +*/ +proto.web.communitygames.AvailableAssetCategories.prototype.setRoottagsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.web.communitygames.AvailableAssetCategoryTag=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AvailableAssetCategoryTag} + */ +proto.web.communitygames.AvailableAssetCategories.prototype.addRoottags = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.web.communitygames.AvailableAssetCategoryTag, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.AvailableAssetCategories} returns this + */ +proto.web.communitygames.AvailableAssetCategories.prototype.clearRoottagsList = function() { + return this.setRoottagsList([]); +}; + + +/** + * repeated AvailableAssetCategoryTag tags = 2; + * @return {!Array} + */ +proto.web.communitygames.AvailableAssetCategories.prototype.getTagsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.AvailableAssetCategoryTag, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.AvailableAssetCategories} returns this +*/ +proto.web.communitygames.AvailableAssetCategories.prototype.setTagsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.web.communitygames.AvailableAssetCategoryTag=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AvailableAssetCategoryTag} + */ +proto.web.communitygames.AvailableAssetCategories.prototype.addTags = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.web.communitygames.AvailableAssetCategoryTag, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.AvailableAssetCategories} returns this + */ +proto.web.communitygames.AvailableAssetCategories.prototype.clearTagsList = function() { + return this.setTagsList([]); +}; + + + + + +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.web.communitygames.PlaygroundConstraints.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.PlaygroundConstraints.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.web.communitygames.PlaygroundConstraints} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.PlaygroundConstraints.toObject = function(includeInstance, msg) { + var f, obj = { + maxnamesize: jspb.Message.getFieldWithDefault(msg, 1, 0), + maxdescriptionsize: jspb.Message.getFieldWithDefault(msg, 2, 0), + maxsecretsize: jspb.Message.getFieldWithDefault(msg, 3, 0), + maxmapsinrotation: jspb.Message.getFieldWithDefault(msg, 4, 0), + maxmutators: jspb.Message.getFieldWithDefault(msg, 5, 0), + maxconfignamesize: jspb.Message.getFieldWithDefault(msg, 6, 0), + maxconfigdescriptionsize: jspb.Message.getFieldWithDefault(msg, 7, 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.web.communitygames.PlaygroundConstraints} + */ +proto.web.communitygames.PlaygroundConstraints.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.PlaygroundConstraints; + return proto.web.communitygames.PlaygroundConstraints.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.PlaygroundConstraints} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.PlaygroundConstraints} + */ +proto.web.communitygames.PlaygroundConstraints.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.setMaxnamesize(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setMaxdescriptionsize(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setMaxsecretsize(value); + break; + case 4: + var value = /** @type {number} */ (reader.readInt32()); + msg.setMaxmapsinrotation(value); + break; + case 5: + var value = /** @type {number} */ (reader.readInt32()); + msg.setMaxmutators(value); + break; + case 6: + var value = /** @type {number} */ (reader.readInt32()); + msg.setMaxconfignamesize(value); + break; + case 7: + var value = /** @type {number} */ (reader.readInt32()); + msg.setMaxconfigdescriptionsize(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.PlaygroundConstraints.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.PlaygroundConstraints.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.PlaygroundConstraints} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.PlaygroundConstraints.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getMaxnamesize(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getMaxdescriptionsize(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } + f = message.getMaxsecretsize(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } + f = message.getMaxmapsinrotation(); + if (f !== 0) { + writer.writeInt32( + 4, + f + ); + } + f = message.getMaxmutators(); + if (f !== 0) { + writer.writeInt32( + 5, + f + ); + } + f = message.getMaxconfignamesize(); + if (f !== 0) { + writer.writeInt32( + 6, + f + ); + } + f = message.getMaxconfigdescriptionsize(); + if (f !== 0) { + writer.writeInt32( + 7, + f + ); + } +}; + + +/** + * optional int32 maxNameSize = 1; + * @return {number} + */ +proto.web.communitygames.PlaygroundConstraints.prototype.getMaxnamesize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.PlaygroundConstraints} returns this + */ +proto.web.communitygames.PlaygroundConstraints.prototype.setMaxnamesize = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional int32 maxDescriptionSize = 2; + * @return {number} + */ +proto.web.communitygames.PlaygroundConstraints.prototype.getMaxdescriptionsize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.PlaygroundConstraints} returns this + */ +proto.web.communitygames.PlaygroundConstraints.prototype.setMaxdescriptionsize = function(value) { + return jspb.Message.setProto3IntField(this, 2, value); +}; + + +/** + * optional int32 maxSecretSize = 3; + * @return {number} + */ +proto.web.communitygames.PlaygroundConstraints.prototype.getMaxsecretsize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.PlaygroundConstraints} returns this + */ +proto.web.communitygames.PlaygroundConstraints.prototype.setMaxsecretsize = function(value) { + return jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * optional int32 maxMapsInRotation = 4; + * @return {number} + */ +proto.web.communitygames.PlaygroundConstraints.prototype.getMaxmapsinrotation = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.PlaygroundConstraints} returns this + */ +proto.web.communitygames.PlaygroundConstraints.prototype.setMaxmapsinrotation = function(value) { + return jspb.Message.setProto3IntField(this, 4, value); +}; + + +/** + * optional int32 maxMutators = 5; + * @return {number} + */ +proto.web.communitygames.PlaygroundConstraints.prototype.getMaxmutators = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.PlaygroundConstraints} returns this + */ +proto.web.communitygames.PlaygroundConstraints.prototype.setMaxmutators = function(value) { + return jspb.Message.setProto3IntField(this, 5, value); +}; + + +/** + * optional int32 maxConfigNameSize = 6; + * @return {number} + */ +proto.web.communitygames.PlaygroundConstraints.prototype.getMaxconfignamesize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 6, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.PlaygroundConstraints} returns this + */ +proto.web.communitygames.PlaygroundConstraints.prototype.setMaxconfignamesize = function(value) { + return jspb.Message.setProto3IntField(this, 6, value); +}; + + +/** + * optional int32 maxConfigDescriptionSize = 7; + * @return {number} + */ +proto.web.communitygames.PlaygroundConstraints.prototype.getMaxconfigdescriptionsize = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 7, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.PlaygroundConstraints} returns this + */ +proto.web.communitygames.PlaygroundConstraints.prototype.setMaxconfigdescriptionsize = function(value) { + return jspb.Message.setProto3IntField(this, 7, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.ModRulesDefinition.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.ModRulesDefinition.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.web.communitygames.ModRulesDefinition} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ModRulesDefinition.toObject = function(includeInstance, msg) { + var f, obj = { + rulesversion: jspb.Message.getFieldWithDefault(msg, 1, 0), + modbuilder: msg.getModbuilder_asB64() + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.ModRulesDefinition} + */ +proto.web.communitygames.ModRulesDefinition.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.ModRulesDefinition; + return proto.web.communitygames.ModRulesDefinition.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.ModRulesDefinition} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.ModRulesDefinition} + */ +proto.web.communitygames.ModRulesDefinition.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.setRulesversion(value); + break; + case 2: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setModbuilder(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.ModRulesDefinition.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.ModRulesDefinition.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.ModRulesDefinition} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ModRulesDefinition.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getRulesversion(); + if (f !== 0) { + writer.writeInt32( + 1, + f + ); + } + f = message.getModbuilder_asU8(); + if (f.length > 0) { + writer.writeBytes( + 2, + f + ); + } +}; + + +/** + * optional int32 rulesVersion = 1; + * @return {number} + */ +proto.web.communitygames.ModRulesDefinition.prototype.getRulesversion = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.communitygames.ModRulesDefinition} returns this + */ +proto.web.communitygames.ModRulesDefinition.prototype.setRulesversion = function(value) { + return jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional bytes modBuilder = 2; + * @return {!(string|Uint8Array)} + */ +proto.web.communitygames.ModRulesDefinition.prototype.getModbuilder = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes modBuilder = 2; + * This is a type-conversion wrapper around `getModbuilder()` + * @return {string} + */ +proto.web.communitygames.ModRulesDefinition.prototype.getModbuilder_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getModbuilder())); +}; + + +/** + * optional bytes modBuilder = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getModbuilder()` + * @return {!Uint8Array} + */ +proto.web.communitygames.ModRulesDefinition.prototype.getModbuilder_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getModbuilder())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.web.communitygames.ModRulesDefinition} returns this + */ +proto.web.communitygames.ModRulesDefinition.prototype.setModbuilder = function(value) { + return jspb.Message.setProto3BytesField(this, 2, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.AvailableGameData.repeatedFields_ = [1,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.web.communitygames.AvailableGameData.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.AvailableGameData.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.web.communitygames.AvailableGameData} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableGameData.toObject = function(includeInstance, msg) { + var f, obj = { + mutatorsList: jspb.Message.toObjectList(msg.getMutatorsList(), + proto.web.communitygames.AvailableMutator.toObject, includeInstance), + mapsList: jspb.Message.toObjectList(msg.getMapsList(), + proto.web.communitygames.AvailableMapEntry.toObject, includeInstance), + modrules: (f = msg.getModrules()) && proto.web.communitygames.ModRulesDefinition.toObject(includeInstance, f), + assetcategories: (f = msg.getAssetcategories()) && proto.web.communitygames.AvailableAssetCategories.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.web.communitygames.AvailableGameData} + */ +proto.web.communitygames.AvailableGameData.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.AvailableGameData; + return proto.web.communitygames.AvailableGameData.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.AvailableGameData} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.AvailableGameData} + */ +proto.web.communitygames.AvailableGameData.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.AvailableMutator; + reader.readMessage(value,proto.web.communitygames.AvailableMutator.deserializeBinaryFromReader); + msg.addMutators(value); + break; + case 2: + var value = new proto.web.communitygames.AvailableMapEntry; + reader.readMessage(value,proto.web.communitygames.AvailableMapEntry.deserializeBinaryFromReader); + msg.addMaps(value); + break; + case 4: + var value = new proto.web.communitygames.ModRulesDefinition; + reader.readMessage(value,proto.web.communitygames.ModRulesDefinition.deserializeBinaryFromReader); + msg.setModrules(value); + break; + case 5: + var value = new proto.web.communitygames.AvailableAssetCategories; + reader.readMessage(value,proto.web.communitygames.AvailableAssetCategories.deserializeBinaryFromReader); + msg.setAssetcategories(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.AvailableGameData.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.AvailableGameData.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.AvailableGameData} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.AvailableGameData.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getMutatorsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.web.communitygames.AvailableMutator.serializeBinaryToWriter + ); + } + f = message.getMapsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.web.communitygames.AvailableMapEntry.serializeBinaryToWriter + ); + } + f = message.getModrules(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.communitygames.ModRulesDefinition.serializeBinaryToWriter + ); + } + f = message.getAssetcategories(); + if (f != null) { + writer.writeMessage( + 5, + f, + proto.web.communitygames.AvailableAssetCategories.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated AvailableMutator mutators = 1; + * @return {!Array} + */ +proto.web.communitygames.AvailableGameData.prototype.getMutatorsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.AvailableMutator, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.AvailableGameData} returns this +*/ +proto.web.communitygames.AvailableGameData.prototype.setMutatorsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.web.communitygames.AvailableMutator=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AvailableMutator} + */ +proto.web.communitygames.AvailableGameData.prototype.addMutators = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.web.communitygames.AvailableMutator, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.AvailableGameData} returns this + */ +proto.web.communitygames.AvailableGameData.prototype.clearMutatorsList = function() { + return this.setMutatorsList([]); +}; + + +/** + * repeated AvailableMapEntry maps = 2; + * @return {!Array} + */ +proto.web.communitygames.AvailableGameData.prototype.getMapsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.AvailableMapEntry, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.AvailableGameData} returns this +*/ +proto.web.communitygames.AvailableGameData.prototype.setMapsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.web.communitygames.AvailableMapEntry=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AvailableMapEntry} + */ +proto.web.communitygames.AvailableGameData.prototype.addMaps = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.web.communitygames.AvailableMapEntry, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.AvailableGameData} returns this + */ +proto.web.communitygames.AvailableGameData.prototype.clearMapsList = function() { + return this.setMapsList([]); +}; + + +/** + * optional ModRulesDefinition modRules = 4; + * @return {?proto.web.communitygames.ModRulesDefinition} + */ +proto.web.communitygames.AvailableGameData.prototype.getModrules = function() { + return /** @type{?proto.web.communitygames.ModRulesDefinition} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.ModRulesDefinition, 4)); +}; + + +/** + * @param {?proto.web.communitygames.ModRulesDefinition|undefined} value + * @return {!proto.web.communitygames.AvailableGameData} returns this +*/ +proto.web.communitygames.AvailableGameData.prototype.setModrules = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableGameData} returns this + */ +proto.web.communitygames.AvailableGameData.prototype.clearModrules = function() { + return this.setModrules(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableGameData.prototype.hasModrules = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +/** + * optional AvailableAssetCategories assetCategories = 5; + * @return {?proto.web.communitygames.AvailableAssetCategories} + */ +proto.web.communitygames.AvailableGameData.prototype.getAssetcategories = function() { + return /** @type{?proto.web.communitygames.AvailableAssetCategories} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.AvailableAssetCategories, 5)); +}; + + +/** + * @param {?proto.web.communitygames.AvailableAssetCategories|undefined} value + * @return {!proto.web.communitygames.AvailableGameData} returns this +*/ +proto.web.communitygames.AvailableGameData.prototype.setAssetcategories = function(value) { + return jspb.Message.setWrapperField(this, 5, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.AvailableGameData} returns this + */ +proto.web.communitygames.AvailableGameData.prototype.clearAssetcategories = function() { + return this.setAssetcategories(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.AvailableGameData.prototype.hasAssetcategories = function() { + return jspb.Message.getField(this, 5) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.Blueprint.repeatedFields_ = [7]; + + + +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.web.communitygames.Blueprint.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.Blueprint.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.web.communitygames.Blueprint} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Blueprint.toObject = function(includeInstance, msg) { + var f, obj = { + blueprinttype: jspb.Message.getFieldWithDefault(msg, 1, ""), + name: jspb.Message.getFieldWithDefault(msg, 2, ""), + availablegamedata: (f = msg.getAvailablegamedata()) && proto.web.communitygames.AvailableGameData.toObject(includeInstance, f), + metadata: (f = msg.getMetadata()) && proto.web.communitygames.Metadata.toObject(includeInstance, f), + customdata: msg.getCustomdata_asB64(), + playgroundconstraints: (f = msg.getPlaygroundconstraints()) && proto.web.communitygames.PlaygroundConstraints.toObject(includeInstance, f), + availabletagsList: jspb.Message.toObjectList(msg.getAvailabletagsList(), + proto.web.communitygames.AvailableTag.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.web.communitygames.Blueprint} + */ +proto.web.communitygames.Blueprint.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.Blueprint; + return proto.web.communitygames.Blueprint.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.Blueprint} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.Blueprint} + */ +proto.web.communitygames.Blueprint.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.setBlueprinttype(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 3: + var value = new proto.web.communitygames.AvailableGameData; + reader.readMessage(value,proto.web.communitygames.AvailableGameData.deserializeBinaryFromReader); + msg.setAvailablegamedata(value); + break; + case 4: + var value = new proto.web.communitygames.Metadata; + reader.readMessage(value,proto.web.communitygames.Metadata.deserializeBinaryFromReader); + msg.setMetadata(value); + break; + case 5: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setCustomdata(value); + break; + case 6: + var value = new proto.web.communitygames.PlaygroundConstraints; + reader.readMessage(value,proto.web.communitygames.PlaygroundConstraints.deserializeBinaryFromReader); + msg.setPlaygroundconstraints(value); + break; + case 7: + var value = new proto.web.communitygames.AvailableTag; + reader.readMessage(value,proto.web.communitygames.AvailableTag.deserializeBinaryFromReader); + msg.addAvailabletags(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.Blueprint.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.Blueprint.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.Blueprint} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.Blueprint.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getBlueprinttype(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getAvailablegamedata(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.web.communitygames.AvailableGameData.serializeBinaryToWriter + ); + } + f = message.getMetadata(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.communitygames.Metadata.serializeBinaryToWriter + ); + } + f = message.getCustomdata_asU8(); + if (f.length > 0) { + writer.writeBytes( + 5, + f + ); + } + f = message.getPlaygroundconstraints(); + if (f != null) { + writer.writeMessage( + 6, + f, + proto.web.communitygames.PlaygroundConstraints.serializeBinaryToWriter + ); + } + f = message.getAvailabletagsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 7, + f, + proto.web.communitygames.AvailableTag.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string blueprintType = 1; + * @return {string} + */ +proto.web.communitygames.Blueprint.prototype.getBlueprinttype = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Blueprint} returns this + */ +proto.web.communitygames.Blueprint.prototype.setBlueprinttype = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string name = 2; + * @return {string} + */ +proto.web.communitygames.Blueprint.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.Blueprint} returns this + */ +proto.web.communitygames.Blueprint.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional AvailableGameData availableGameData = 3; + * @return {?proto.web.communitygames.AvailableGameData} + */ +proto.web.communitygames.Blueprint.prototype.getAvailablegamedata = function() { + return /** @type{?proto.web.communitygames.AvailableGameData} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.AvailableGameData, 3)); +}; + + +/** + * @param {?proto.web.communitygames.AvailableGameData|undefined} value + * @return {!proto.web.communitygames.Blueprint} returns this +*/ +proto.web.communitygames.Blueprint.prototype.setAvailablegamedata = function(value) { + return jspb.Message.setWrapperField(this, 3, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Blueprint} returns this + */ +proto.web.communitygames.Blueprint.prototype.clearAvailablegamedata = function() { + return this.setAvailablegamedata(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Blueprint.prototype.hasAvailablegamedata = function() { + return jspb.Message.getField(this, 3) != null; +}; + + +/** + * optional Metadata metadata = 4; + * @return {?proto.web.communitygames.Metadata} + */ +proto.web.communitygames.Blueprint.prototype.getMetadata = function() { + return /** @type{?proto.web.communitygames.Metadata} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Metadata, 4)); +}; + + +/** + * @param {?proto.web.communitygames.Metadata|undefined} value + * @return {!proto.web.communitygames.Blueprint} returns this +*/ +proto.web.communitygames.Blueprint.prototype.setMetadata = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Blueprint} returns this + */ +proto.web.communitygames.Blueprint.prototype.clearMetadata = function() { + return this.setMetadata(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Blueprint.prototype.hasMetadata = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +/** + * optional bytes customData = 5; + * @return {!(string|Uint8Array)} + */ +proto.web.communitygames.Blueprint.prototype.getCustomdata = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +}; + + +/** + * optional bytes customData = 5; + * This is a type-conversion wrapper around `getCustomdata()` + * @return {string} + */ +proto.web.communitygames.Blueprint.prototype.getCustomdata_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getCustomdata())); +}; + + +/** + * optional bytes customData = 5; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getCustomdata()` + * @return {!Uint8Array} + */ +proto.web.communitygames.Blueprint.prototype.getCustomdata_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getCustomdata())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.web.communitygames.Blueprint} returns this + */ +proto.web.communitygames.Blueprint.prototype.setCustomdata = function(value) { + return jspb.Message.setProto3BytesField(this, 5, value); +}; + + +/** + * optional PlaygroundConstraints playgroundConstraints = 6; + * @return {?proto.web.communitygames.PlaygroundConstraints} + */ +proto.web.communitygames.Blueprint.prototype.getPlaygroundconstraints = function() { + return /** @type{?proto.web.communitygames.PlaygroundConstraints} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.PlaygroundConstraints, 6)); +}; + + +/** + * @param {?proto.web.communitygames.PlaygroundConstraints|undefined} value + * @return {!proto.web.communitygames.Blueprint} returns this +*/ +proto.web.communitygames.Blueprint.prototype.setPlaygroundconstraints = function(value) { + return jspb.Message.setWrapperField(this, 6, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.Blueprint} returns this + */ +proto.web.communitygames.Blueprint.prototype.clearPlaygroundconstraints = function() { + return this.setPlaygroundconstraints(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.Blueprint.prototype.hasPlaygroundconstraints = function() { + return jspb.Message.getField(this, 6) != null; +}; + + +/** + * repeated AvailableTag availableTags = 7; + * @return {!Array} + */ +proto.web.communitygames.Blueprint.prototype.getAvailabletagsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.AvailableTag, 7)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.Blueprint} returns this +*/ +proto.web.communitygames.Blueprint.prototype.setAvailabletagsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 7, value); +}; + + +/** + * @param {!proto.web.communitygames.AvailableTag=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AvailableTag} + */ +proto.web.communitygames.Blueprint.prototype.addAvailabletags = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 7, opt_value, proto.web.communitygames.AvailableTag, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.Blueprint} returns this + */ +proto.web.communitygames.Blueprint.prototype.clearAvailabletagsList = function() { + return this.setAvailabletagsList([]); +}; + + + + + +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.web.communitygames.ShortCode.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.ShortCode.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.web.communitygames.ShortCode} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ShortCode.toObject = function(includeInstance, msg) { + var f, obj = { + code: 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.web.communitygames.ShortCode} + */ +proto.web.communitygames.ShortCode.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.ShortCode; + return proto.web.communitygames.ShortCode.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.ShortCode} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.ShortCode} + */ +proto.web.communitygames.ShortCode.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.setCode(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.ShortCode.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.ShortCode.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.ShortCode} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ShortCode.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getCode(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string code = 1; + * @return {string} + */ +proto.web.communitygames.ShortCode.prototype.getCode = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.ShortCode} returns this + */ +proto.web.communitygames.ShortCode.prototype.setCode = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.GetProgressionTypesRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GetProgressionTypesRequest.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.web.communitygames.GetProgressionTypesRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetProgressionTypesRequest.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.GetProgressionTypesRequest} + */ +proto.web.communitygames.GetProgressionTypesRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GetProgressionTypesRequest; + return proto.web.communitygames.GetProgressionTypesRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GetProgressionTypesRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GetProgressionTypesRequest} + */ +proto.web.communitygames.GetProgressionTypesRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GetProgressionTypesRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GetProgressionTypesRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GetProgressionTypesRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetProgressionTypesRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.BlueprintInfo.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.BlueprintInfo.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.web.communitygames.BlueprintInfo} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.BlueprintInfo.toObject = function(includeInstance, msg) { + var f, obj = { + blueprinttype: jspb.Message.getFieldWithDefault(msg, 1, ""), + blueprintid: 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.web.communitygames.BlueprintInfo} + */ +proto.web.communitygames.BlueprintInfo.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.BlueprintInfo; + return proto.web.communitygames.BlueprintInfo.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.BlueprintInfo} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.BlueprintInfo} + */ +proto.web.communitygames.BlueprintInfo.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.setBlueprinttype(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setBlueprintid(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.BlueprintInfo.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.BlueprintInfo.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.BlueprintInfo} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.BlueprintInfo.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getBlueprinttype(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getBlueprintid(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional string blueprintType = 1; + * @return {string} + */ +proto.web.communitygames.BlueprintInfo.prototype.getBlueprinttype = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.BlueprintInfo} returns this + */ +proto.web.communitygames.BlueprintInfo.prototype.setBlueprinttype = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string blueprintId = 2; + * @return {string} + */ +proto.web.communitygames.BlueprintInfo.prototype.getBlueprintid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.BlueprintInfo} returns this + */ +proto.web.communitygames.BlueprintInfo.prototype.setBlueprintid = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.GetProgressionTypesResponse.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.GetProgressionTypesResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GetProgressionTypesResponse.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.web.communitygames.GetProgressionTypesResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetProgressionTypesResponse.toObject = function(includeInstance, msg) { + var f, obj = { + entriesList: jspb.Message.toObjectList(msg.getEntriesList(), + proto.web.communitygames.ProgressionEntry.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.web.communitygames.GetProgressionTypesResponse} + */ +proto.web.communitygames.GetProgressionTypesResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GetProgressionTypesResponse; + return proto.web.communitygames.GetProgressionTypesResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GetProgressionTypesResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GetProgressionTypesResponse} + */ +proto.web.communitygames.GetProgressionTypesResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.ProgressionEntry; + reader.readMessage(value,proto.web.communitygames.ProgressionEntry.deserializeBinaryFromReader); + msg.addEntries(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GetProgressionTypesResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GetProgressionTypesResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GetProgressionTypesResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetProgressionTypesResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getEntriesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.web.communitygames.ProgressionEntry.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated ProgressionEntry entries = 1; + * @return {!Array} + */ +proto.web.communitygames.GetProgressionTypesResponse.prototype.getEntriesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.ProgressionEntry, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.GetProgressionTypesResponse} returns this +*/ +proto.web.communitygames.GetProgressionTypesResponse.prototype.setEntriesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.web.communitygames.ProgressionEntry=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.ProgressionEntry} + */ +proto.web.communitygames.GetProgressionTypesResponse.prototype.addEntries = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.web.communitygames.ProgressionEntry, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.GetProgressionTypesResponse} returns this + */ +proto.web.communitygames.GetProgressionTypesResponse.prototype.clearEntriesList = function() { + return this.setEntriesList([]); +}; + + + + + +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.web.communitygames.GetScheduledBlueprintsRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GetScheduledBlueprintsRequest.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.web.communitygames.GetScheduledBlueprintsRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetScheduledBlueprintsRequest.toObject = function(includeInstance, msg) { + var f, obj = { + protocolversion: 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.web.communitygames.GetScheduledBlueprintsRequest} + */ +proto.web.communitygames.GetScheduledBlueprintsRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GetScheduledBlueprintsRequest; + return proto.web.communitygames.GetScheduledBlueprintsRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GetScheduledBlueprintsRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GetScheduledBlueprintsRequest} + */ +proto.web.communitygames.GetScheduledBlueprintsRequest.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.setProtocolversion(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GetScheduledBlueprintsRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GetScheduledBlueprintsRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GetScheduledBlueprintsRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetScheduledBlueprintsRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getProtocolversion(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string protocolVersion = 1; + * @return {string} + */ +proto.web.communitygames.GetScheduledBlueprintsRequest.prototype.getProtocolversion = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.GetScheduledBlueprintsRequest} returns this + */ +proto.web.communitygames.GetScheduledBlueprintsRequest.prototype.setProtocolversion = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.GetScheduledBlueprintsResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GetScheduledBlueprintsResponse.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.web.communitygames.GetScheduledBlueprintsResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetScheduledBlueprintsResponse.toObject = function(includeInstance, msg) { + var f, obj = { + blueprints: (f = msg.getBlueprints()) && proto.web.communitygames.BlueprintInfo.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.web.communitygames.GetScheduledBlueprintsResponse} + */ +proto.web.communitygames.GetScheduledBlueprintsResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GetScheduledBlueprintsResponse; + return proto.web.communitygames.GetScheduledBlueprintsResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GetScheduledBlueprintsResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GetScheduledBlueprintsResponse} + */ +proto.web.communitygames.GetScheduledBlueprintsResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.BlueprintInfo; + reader.readMessage(value,proto.web.communitygames.BlueprintInfo.deserializeBinaryFromReader); + msg.setBlueprints(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GetScheduledBlueprintsResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GetScheduledBlueprintsResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GetScheduledBlueprintsResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetScheduledBlueprintsResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getBlueprints(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.BlueprintInfo.serializeBinaryToWriter + ); + } +}; + + +/** + * optional BlueprintInfo blueprints = 1; + * @return {?proto.web.communitygames.BlueprintInfo} + */ +proto.web.communitygames.GetScheduledBlueprintsResponse.prototype.getBlueprints = function() { + return /** @type{?proto.web.communitygames.BlueprintInfo} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.BlueprintInfo, 1)); +}; + + +/** + * @param {?proto.web.communitygames.BlueprintInfo|undefined} value + * @return {!proto.web.communitygames.GetScheduledBlueprintsResponse} returns this +*/ +proto.web.communitygames.GetScheduledBlueprintsResponse.prototype.setBlueprints = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.GetScheduledBlueprintsResponse} returns this + */ +proto.web.communitygames.GetScheduledBlueprintsResponse.prototype.clearBlueprints = function() { + return this.setBlueprints(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.GetScheduledBlueprintsResponse.prototype.hasBlueprints = function() { + return jspb.Message.getField(this, 1) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.GetBlueprintsByIdResponse.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.GetBlueprintsByIdResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GetBlueprintsByIdResponse.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.web.communitygames.GetBlueprintsByIdResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetBlueprintsByIdResponse.toObject = function(includeInstance, msg) { + var f, obj = { + blueprintList: jspb.Message.toObjectList(msg.getBlueprintList(), + proto.web.communitygames.Blueprint.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.web.communitygames.GetBlueprintsByIdResponse} + */ +proto.web.communitygames.GetBlueprintsByIdResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GetBlueprintsByIdResponse; + return proto.web.communitygames.GetBlueprintsByIdResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GetBlueprintsByIdResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GetBlueprintsByIdResponse} + */ +proto.web.communitygames.GetBlueprintsByIdResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.Blueprint; + reader.readMessage(value,proto.web.communitygames.Blueprint.deserializeBinaryFromReader); + msg.addBlueprint(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GetBlueprintsByIdResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GetBlueprintsByIdResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GetBlueprintsByIdResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetBlueprintsByIdResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getBlueprintList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.web.communitygames.Blueprint.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated Blueprint blueprint = 1; + * @return {!Array} + */ +proto.web.communitygames.GetBlueprintsByIdResponse.prototype.getBlueprintList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.Blueprint, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.GetBlueprintsByIdResponse} returns this +*/ +proto.web.communitygames.GetBlueprintsByIdResponse.prototype.setBlueprintList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.web.communitygames.Blueprint=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.Blueprint} + */ +proto.web.communitygames.GetBlueprintsByIdResponse.prototype.addBlueprint = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.web.communitygames.Blueprint, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.GetBlueprintsByIdResponse} returns this + */ +proto.web.communitygames.GetBlueprintsByIdResponse.prototype.clearBlueprintList = function() { + return this.setBlueprintList([]); +}; + + + + + +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.web.communitygames.GetConstraintsResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GetConstraintsResponse.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.web.communitygames.GetConstraintsResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetConstraintsResponse.toObject = function(includeInstance, msg) { + var f, obj = { + globalconstraints: (f = msg.getGlobalconstraints()) && proto.web.communitygames.GlobalConstraints.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.web.communitygames.GetConstraintsResponse} + */ +proto.web.communitygames.GetConstraintsResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GetConstraintsResponse; + return proto.web.communitygames.GetConstraintsResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GetConstraintsResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GetConstraintsResponse} + */ +proto.web.communitygames.GetConstraintsResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.GlobalConstraints; + reader.readMessage(value,proto.web.communitygames.GlobalConstraints.deserializeBinaryFromReader); + msg.setGlobalconstraints(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GetConstraintsResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GetConstraintsResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GetConstraintsResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetConstraintsResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getGlobalconstraints(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.GlobalConstraints.serializeBinaryToWriter + ); + } +}; + + +/** + * optional GlobalConstraints globalConstraints = 1; + * @return {?proto.web.communitygames.GlobalConstraints} + */ +proto.web.communitygames.GetConstraintsResponse.prototype.getGlobalconstraints = function() { + return /** @type{?proto.web.communitygames.GlobalConstraints} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.GlobalConstraints, 1)); +}; + + +/** + * @param {?proto.web.communitygames.GlobalConstraints|undefined} value + * @return {!proto.web.communitygames.GetConstraintsResponse} returns this +*/ +proto.web.communitygames.GetConstraintsResponse.prototype.setGlobalconstraints = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.GetConstraintsResponse} returns this + */ +proto.web.communitygames.GetConstraintsResponse.prototype.clearGlobalconstraints = function() { + return this.setGlobalconstraints(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.GetConstraintsResponse.prototype.hasGlobalconstraints = function() { + return jspb.Message.getField(this, 1) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.ListPlaygroundsByOwnerResponse.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.web.communitygames.ListPlaygroundsByOwnerResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.ListPlaygroundsByOwnerResponse.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.web.communitygames.ListPlaygroundsByOwnerResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ListPlaygroundsByOwnerResponse.toObject = function(includeInstance, msg) { + var f, obj = { + playgroundresponsesList: jspb.Message.toObjectList(msg.getPlaygroundresponsesList(), + proto.web.communitygames.PlaygroundResponse.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.web.communitygames.ListPlaygroundsByOwnerResponse} + */ +proto.web.communitygames.ListPlaygroundsByOwnerResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.ListPlaygroundsByOwnerResponse; + return proto.web.communitygames.ListPlaygroundsByOwnerResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.ListPlaygroundsByOwnerResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.ListPlaygroundsByOwnerResponse} + */ +proto.web.communitygames.ListPlaygroundsByOwnerResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 2: + var value = new proto.web.communitygames.PlaygroundResponse; + reader.readMessage(value,proto.web.communitygames.PlaygroundResponse.deserializeBinaryFromReader); + msg.addPlaygroundresponses(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.ListPlaygroundsByOwnerResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.ListPlaygroundsByOwnerResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.ListPlaygroundsByOwnerResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.ListPlaygroundsByOwnerResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPlaygroundresponsesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 2, + f, + proto.web.communitygames.PlaygroundResponse.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated PlaygroundResponse playgroundResponses = 2; + * @return {!Array} + */ +proto.web.communitygames.ListPlaygroundsByOwnerResponse.prototype.getPlaygroundresponsesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.PlaygroundResponse, 2)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.ListPlaygroundsByOwnerResponse} returns this +*/ +proto.web.communitygames.ListPlaygroundsByOwnerResponse.prototype.setPlaygroundresponsesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 2, value); +}; + + +/** + * @param {!proto.web.communitygames.PlaygroundResponse=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.PlaygroundResponse} + */ +proto.web.communitygames.ListPlaygroundsByOwnerResponse.prototype.addPlaygroundresponses = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 2, opt_value, proto.web.communitygames.PlaygroundResponse, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.ListPlaygroundsByOwnerResponse} returns this + */ +proto.web.communitygames.ListPlaygroundsByOwnerResponse.prototype.clearPlaygroundresponsesList = function() { + return this.setPlaygroundresponsesList([]); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.communitygames.CreatePlaygroundRequest.repeatedFields_ = [5,11]; + + + +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.web.communitygames.CreatePlaygroundRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.CreatePlaygroundRequest.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.web.communitygames.CreatePlaygroundRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.CreatePlaygroundRequest.toObject = function(includeInstance, msg) { + var f, obj = { + blueprinttype: jspb.Message.getFieldWithDefault(msg, 2, ""), + name: jspb.Message.getFieldWithDefault(msg, 3, ""), + description: (f = msg.getDescription()) && proto.web.communitygames.StringValue.toObject(includeInstance, f), + mutatorsList: jspb.Message.toObjectList(msg.getMutatorsList(), + proto.web.communitygames.Mutator.toObject, includeInstance), + maprotation: (f = msg.getMaprotation()) && proto.web.communitygames.MapRotation.toObject(includeInstance, f), + secret: (f = msg.getSecret()) && proto.web.communitygames.StringValue.toObject(includeInstance, f), + serversettings: (f = msg.getServersettings()) && proto.web.communitygames.GameServerSettings.toObject(includeInstance, f), + restrictions: (f = msg.getRestrictions()) && proto.web.communitygames.Restrictions.toObject(includeInstance, f), + originalmodrules: msg.getOriginalmodrules_asB64(), + assetcategoriesList: jspb.Message.toObjectList(msg.getAssetcategoriesList(), + proto.web.communitygames.AssetCategory.toObject, includeInstance), + teamcomposition: (f = msg.getTeamcomposition()) && proto.web.communitygames.TeamComposition.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.web.communitygames.CreatePlaygroundRequest} + */ +proto.web.communitygames.CreatePlaygroundRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.CreatePlaygroundRequest; + return proto.web.communitygames.CreatePlaygroundRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.CreatePlaygroundRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.CreatePlaygroundRequest} + */ +proto.web.communitygames.CreatePlaygroundRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setBlueprinttype(value); + break; + case 3: + var value = /** @type {string} */ (reader.readString()); + msg.setName(value); + break; + case 4: + var value = new proto.web.communitygames.StringValue; + reader.readMessage(value,proto.web.communitygames.StringValue.deserializeBinaryFromReader); + msg.setDescription(value); + break; + case 5: + var value = new proto.web.communitygames.Mutator; + reader.readMessage(value,proto.web.communitygames.Mutator.deserializeBinaryFromReader); + msg.addMutators(value); + break; + case 6: + var value = new proto.web.communitygames.MapRotation; + reader.readMessage(value,proto.web.communitygames.MapRotation.deserializeBinaryFromReader); + msg.setMaprotation(value); + break; + case 7: + var value = new proto.web.communitygames.StringValue; + reader.readMessage(value,proto.web.communitygames.StringValue.deserializeBinaryFromReader); + msg.setSecret(value); + break; + case 8: + var value = new proto.web.communitygames.GameServerSettings; + reader.readMessage(value,proto.web.communitygames.GameServerSettings.deserializeBinaryFromReader); + msg.setServersettings(value); + break; + case 9: + var value = new proto.web.communitygames.Restrictions; + reader.readMessage(value,proto.web.communitygames.Restrictions.deserializeBinaryFromReader); + msg.setRestrictions(value); + break; + case 10: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setOriginalmodrules(value); + break; + case 11: + var value = new proto.web.communitygames.AssetCategory; + reader.readMessage(value,proto.web.communitygames.AssetCategory.deserializeBinaryFromReader); + msg.addAssetcategories(value); + break; + case 12: + var value = new proto.web.communitygames.TeamComposition; + reader.readMessage(value,proto.web.communitygames.TeamComposition.deserializeBinaryFromReader); + msg.setTeamcomposition(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.CreatePlaygroundRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.CreatePlaygroundRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.CreatePlaygroundRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getBlueprinttype(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getName(); + if (f.length > 0) { + writer.writeString( + 3, + f + ); + } + f = message.getDescription(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.communitygames.StringValue.serializeBinaryToWriter + ); + } + f = message.getMutatorsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 5, + f, + proto.web.communitygames.Mutator.serializeBinaryToWriter + ); + } + f = message.getMaprotation(); + if (f != null) { + writer.writeMessage( + 6, + f, + proto.web.communitygames.MapRotation.serializeBinaryToWriter + ); + } + f = message.getSecret(); + if (f != null) { + writer.writeMessage( + 7, + f, + proto.web.communitygames.StringValue.serializeBinaryToWriter + ); + } + f = message.getServersettings(); + if (f != null) { + writer.writeMessage( + 8, + f, + proto.web.communitygames.GameServerSettings.serializeBinaryToWriter + ); + } + f = message.getRestrictions(); + if (f != null) { + writer.writeMessage( + 9, + f, + proto.web.communitygames.Restrictions.serializeBinaryToWriter + ); + } + f = message.getOriginalmodrules_asU8(); + if (f.length > 0) { + writer.writeBytes( + 10, + f + ); + } + f = message.getAssetcategoriesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 11, + f, + proto.web.communitygames.AssetCategory.serializeBinaryToWriter + ); + } + f = message.getTeamcomposition(); + if (f != null) { + writer.writeMessage( + 12, + f, + proto.web.communitygames.TeamComposition.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string blueprintType = 2; + * @return {string} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getBlueprinttype = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setBlueprinttype = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string name = 3; + * @return {string} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getName = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setName = function(value) { + return jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional StringValue description = 4; + * @return {?proto.web.communitygames.StringValue} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getDescription = function() { + return /** @type{?proto.web.communitygames.StringValue} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.StringValue, 4)); +}; + + +/** + * @param {?proto.web.communitygames.StringValue|undefined} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this +*/ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setDescription = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.clearDescription = function() { + return this.setDescription(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.hasDescription = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +/** + * repeated Mutator mutators = 5; + * @return {!Array} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getMutatorsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.Mutator, 5)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this +*/ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setMutatorsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 5, value); +}; + + +/** + * @param {!proto.web.communitygames.Mutator=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.Mutator} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.addMutators = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 5, opt_value, proto.web.communitygames.Mutator, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.clearMutatorsList = function() { + return this.setMutatorsList([]); +}; + + +/** + * optional MapRotation mapRotation = 6; + * @return {?proto.web.communitygames.MapRotation} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getMaprotation = function() { + return /** @type{?proto.web.communitygames.MapRotation} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.MapRotation, 6)); +}; + + +/** + * @param {?proto.web.communitygames.MapRotation|undefined} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this +*/ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setMaprotation = function(value) { + return jspb.Message.setWrapperField(this, 6, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.clearMaprotation = function() { + return this.setMaprotation(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.hasMaprotation = function() { + return jspb.Message.getField(this, 6) != null; +}; + + +/** + * optional StringValue secret = 7; + * @return {?proto.web.communitygames.StringValue} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getSecret = function() { + return /** @type{?proto.web.communitygames.StringValue} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.StringValue, 7)); +}; + + +/** + * @param {?proto.web.communitygames.StringValue|undefined} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this +*/ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setSecret = function(value) { + return jspb.Message.setWrapperField(this, 7, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.clearSecret = function() { + return this.setSecret(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.hasSecret = function() { + return jspb.Message.getField(this, 7) != null; +}; + + +/** + * optional GameServerSettings serverSettings = 8; + * @return {?proto.web.communitygames.GameServerSettings} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getServersettings = function() { + return /** @type{?proto.web.communitygames.GameServerSettings} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.GameServerSettings, 8)); +}; + + +/** + * @param {?proto.web.communitygames.GameServerSettings|undefined} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this +*/ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setServersettings = function(value) { + return jspb.Message.setWrapperField(this, 8, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.clearServersettings = function() { + return this.setServersettings(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.hasServersettings = function() { + return jspb.Message.getField(this, 8) != null; +}; + + +/** + * optional Restrictions restrictions = 9; + * @return {?proto.web.communitygames.Restrictions} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getRestrictions = function() { + return /** @type{?proto.web.communitygames.Restrictions} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Restrictions, 9)); +}; + + +/** + * @param {?proto.web.communitygames.Restrictions|undefined} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this +*/ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setRestrictions = function(value) { + return jspb.Message.setWrapperField(this, 9, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.clearRestrictions = function() { + return this.setRestrictions(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.hasRestrictions = function() { + return jspb.Message.getField(this, 9) != null; +}; + + +/** + * optional bytes originalModRules = 10; + * @return {!(string|Uint8Array)} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getOriginalmodrules = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 10, "")); +}; + + +/** + * optional bytes originalModRules = 10; + * This is a type-conversion wrapper around `getOriginalmodrules()` + * @return {string} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getOriginalmodrules_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getOriginalmodrules())); +}; + + +/** + * optional bytes originalModRules = 10; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getOriginalmodrules()` + * @return {!Uint8Array} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getOriginalmodrules_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getOriginalmodrules())); +}; + + +/** + * @param {!(string|Uint8Array)} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setOriginalmodrules = function(value) { + return jspb.Message.setProto3BytesField(this, 10, value); +}; + + +/** + * repeated AssetCategory assetCategories = 11; + * @return {!Array} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getAssetcategoriesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.communitygames.AssetCategory, 11)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this +*/ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setAssetcategoriesList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 11, value); +}; + + +/** + * @param {!proto.web.communitygames.AssetCategory=} opt_value + * @param {number=} opt_index + * @return {!proto.web.communitygames.AssetCategory} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.addAssetcategories = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 11, opt_value, proto.web.communitygames.AssetCategory, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.clearAssetcategoriesList = function() { + return this.setAssetcategoriesList([]); +}; + + +/** + * optional TeamComposition teamComposition = 12; + * @return {?proto.web.communitygames.TeamComposition} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.getTeamcomposition = function() { + return /** @type{?proto.web.communitygames.TeamComposition} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.TeamComposition, 12)); +}; + + +/** + * @param {?proto.web.communitygames.TeamComposition|undefined} value + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this +*/ +proto.web.communitygames.CreatePlaygroundRequest.prototype.setTeamcomposition = function(value) { + return jspb.Message.setWrapperField(this, 12, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.CreatePlaygroundRequest} returns this + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.clearTeamcomposition = function() { + return this.setTeamcomposition(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.CreatePlaygroundRequest.prototype.hasTeamcomposition = function() { + return jspb.Message.getField(this, 12) != 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.web.communitygames.UpdatePlaygroundRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.UpdatePlaygroundRequest.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.web.communitygames.UpdatePlaygroundRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.UpdatePlaygroundRequest.toObject = function(includeInstance, msg) { + var f, obj = { + newplayground: (f = msg.getNewplayground()) && proto.web.communitygames.Playground.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.web.communitygames.UpdatePlaygroundRequest} + */ +proto.web.communitygames.UpdatePlaygroundRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.UpdatePlaygroundRequest; + return proto.web.communitygames.UpdatePlaygroundRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.UpdatePlaygroundRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.UpdatePlaygroundRequest} + */ +proto.web.communitygames.UpdatePlaygroundRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 2: + var value = new proto.web.communitygames.Playground; + reader.readMessage(value,proto.web.communitygames.Playground.deserializeBinaryFromReader); + msg.setNewplayground(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.UpdatePlaygroundRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.UpdatePlaygroundRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.UpdatePlaygroundRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.UpdatePlaygroundRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getNewplayground(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.Playground.serializeBinaryToWriter + ); + } +}; + + +/** + * optional Playground newPlayground = 2; + * @return {?proto.web.communitygames.Playground} + */ +proto.web.communitygames.UpdatePlaygroundRequest.prototype.getNewplayground = function() { + return /** @type{?proto.web.communitygames.Playground} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.Playground, 2)); +}; + + +/** + * @param {?proto.web.communitygames.Playground|undefined} value + * @return {!proto.web.communitygames.UpdatePlaygroundRequest} returns this +*/ +proto.web.communitygames.UpdatePlaygroundRequest.prototype.setNewplayground = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.UpdatePlaygroundRequest} returns this + */ +proto.web.communitygames.UpdatePlaygroundRequest.prototype.clearNewplayground = function() { + return this.setNewplayground(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.UpdatePlaygroundRequest.prototype.hasNewplayground = 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.web.communitygames.DeletePlaygroundRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.DeletePlaygroundRequest.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.web.communitygames.DeletePlaygroundRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.DeletePlaygroundRequest.toObject = function(includeInstance, msg) { + var f, obj = { + playgroundid: 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.web.communitygames.DeletePlaygroundRequest} + */ +proto.web.communitygames.DeletePlaygroundRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.DeletePlaygroundRequest; + return proto.web.communitygames.DeletePlaygroundRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.DeletePlaygroundRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.DeletePlaygroundRequest} + */ +proto.web.communitygames.DeletePlaygroundRequest.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.setPlaygroundid(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.DeletePlaygroundRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.DeletePlaygroundRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.DeletePlaygroundRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.DeletePlaygroundRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPlaygroundid(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string playgroundId = 1; + * @return {string} + */ +proto.web.communitygames.DeletePlaygroundRequest.prototype.getPlaygroundid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.DeletePlaygroundRequest} returns this + */ +proto.web.communitygames.DeletePlaygroundRequest.prototype.setPlaygroundid = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.GetPlaygroundRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.GetPlaygroundRequest.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.web.communitygames.GetPlaygroundRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetPlaygroundRequest.toObject = function(includeInstance, msg) { + var f, obj = { + playgroundid: 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.web.communitygames.GetPlaygroundRequest} + */ +proto.web.communitygames.GetPlaygroundRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.GetPlaygroundRequest; + return proto.web.communitygames.GetPlaygroundRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.GetPlaygroundRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.GetPlaygroundRequest} + */ +proto.web.communitygames.GetPlaygroundRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setPlaygroundid(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.GetPlaygroundRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.GetPlaygroundRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.GetPlaygroundRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.GetPlaygroundRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPlaygroundid(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } +}; + + +/** + * optional string playgroundId = 2; + * @return {string} + */ +proto.web.communitygames.GetPlaygroundRequest.prototype.getPlaygroundid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.GetPlaygroundRequest} returns this + */ +proto.web.communitygames.GetPlaygroundRequest.prototype.setPlaygroundid = 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.web.communitygames.SharePlaygroundRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.SharePlaygroundRequest.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.web.communitygames.SharePlaygroundRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.SharePlaygroundRequest.toObject = function(includeInstance, msg) { + var f, obj = { + playgroundid: 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.web.communitygames.SharePlaygroundRequest} + */ +proto.web.communitygames.SharePlaygroundRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.SharePlaygroundRequest; + return proto.web.communitygames.SharePlaygroundRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.SharePlaygroundRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.SharePlaygroundRequest} + */ +proto.web.communitygames.SharePlaygroundRequest.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.setPlaygroundid(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.SharePlaygroundRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.SharePlaygroundRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.SharePlaygroundRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.SharePlaygroundRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPlaygroundid(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string playgroundId = 1; + * @return {string} + */ +proto.web.communitygames.SharePlaygroundRequest.prototype.getPlaygroundid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.communitygames.SharePlaygroundRequest} returns this + */ +proto.web.communitygames.SharePlaygroundRequest.prototype.setPlaygroundid = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.SharePlaygroundResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.SharePlaygroundResponse.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.web.communitygames.SharePlaygroundResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.SharePlaygroundResponse.toObject = function(includeInstance, msg) { + var f, obj = { + shortcode: (f = msg.getShortcode()) && proto.web.communitygames.ShortCode.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.web.communitygames.SharePlaygroundResponse} + */ +proto.web.communitygames.SharePlaygroundResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.SharePlaygroundResponse; + return proto.web.communitygames.SharePlaygroundResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.SharePlaygroundResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.SharePlaygroundResponse} + */ +proto.web.communitygames.SharePlaygroundResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.ShortCode; + reader.readMessage(value,proto.web.communitygames.ShortCode.deserializeBinaryFromReader); + msg.setShortcode(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.SharePlaygroundResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.SharePlaygroundResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.SharePlaygroundResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.SharePlaygroundResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getShortcode(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.ShortCode.serializeBinaryToWriter + ); + } +}; + + +/** + * optional ShortCode shortCode = 1; + * @return {?proto.web.communitygames.ShortCode} + */ +proto.web.communitygames.SharePlaygroundResponse.prototype.getShortcode = function() { + return /** @type{?proto.web.communitygames.ShortCode} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.ShortCode, 1)); +}; + + +/** + * @param {?proto.web.communitygames.ShortCode|undefined} value + * @return {!proto.web.communitygames.SharePlaygroundResponse} returns this +*/ +proto.web.communitygames.SharePlaygroundResponse.prototype.setShortcode = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.SharePlaygroundResponse} returns this + */ +proto.web.communitygames.SharePlaygroundResponse.prototype.clearShortcode = function() { + return this.setShortcode(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.SharePlaygroundResponse.prototype.hasShortcode = function() { + return jspb.Message.getField(this, 1) != 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.web.communitygames.CreatePlaygroundResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.CreatePlaygroundResponse.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.web.communitygames.CreatePlaygroundResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.CreatePlaygroundResponse.toObject = function(includeInstance, msg) { + var f, obj = { + playgroundresponse: (f = msg.getPlaygroundresponse()) && proto.web.communitygames.PlaygroundResponse.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.web.communitygames.CreatePlaygroundResponse} + */ +proto.web.communitygames.CreatePlaygroundResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.CreatePlaygroundResponse; + return proto.web.communitygames.CreatePlaygroundResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.CreatePlaygroundResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.CreatePlaygroundResponse} + */ +proto.web.communitygames.CreatePlaygroundResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 2: + var value = new proto.web.communitygames.PlaygroundResponse; + reader.readMessage(value,proto.web.communitygames.PlaygroundResponse.deserializeBinaryFromReader); + msg.setPlaygroundresponse(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.CreatePlaygroundResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.CreatePlaygroundResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.CreatePlaygroundResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.CreatePlaygroundResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPlaygroundresponse(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.PlaygroundResponse.serializeBinaryToWriter + ); + } +}; + + +/** + * optional PlaygroundResponse playgroundResponse = 2; + * @return {?proto.web.communitygames.PlaygroundResponse} + */ +proto.web.communitygames.CreatePlaygroundResponse.prototype.getPlaygroundresponse = function() { + return /** @type{?proto.web.communitygames.PlaygroundResponse} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.PlaygroundResponse, 2)); +}; + + +/** + * @param {?proto.web.communitygames.PlaygroundResponse|undefined} value + * @return {!proto.web.communitygames.CreatePlaygroundResponse} returns this +*/ +proto.web.communitygames.CreatePlaygroundResponse.prototype.setPlaygroundresponse = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.CreatePlaygroundResponse} returns this + */ +proto.web.communitygames.CreatePlaygroundResponse.prototype.clearPlaygroundresponse = function() { + return this.setPlaygroundresponse(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.CreatePlaygroundResponse.prototype.hasPlaygroundresponse = 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.web.communitygames.UpdatePlaygroundResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.UpdatePlaygroundResponse.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.web.communitygames.UpdatePlaygroundResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.UpdatePlaygroundResponse.toObject = function(includeInstance, msg) { + var f, obj = { + playgroundresponse: (f = msg.getPlaygroundresponse()) && proto.web.communitygames.PlaygroundResponse.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.web.communitygames.UpdatePlaygroundResponse} + */ +proto.web.communitygames.UpdatePlaygroundResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.UpdatePlaygroundResponse; + return proto.web.communitygames.UpdatePlaygroundResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.UpdatePlaygroundResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.UpdatePlaygroundResponse} + */ +proto.web.communitygames.UpdatePlaygroundResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 2: + var value = new proto.web.communitygames.PlaygroundResponse; + reader.readMessage(value,proto.web.communitygames.PlaygroundResponse.deserializeBinaryFromReader); + msg.setPlaygroundresponse(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.UpdatePlaygroundResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.UpdatePlaygroundResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.UpdatePlaygroundResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.UpdatePlaygroundResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPlaygroundresponse(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.communitygames.PlaygroundResponse.serializeBinaryToWriter + ); + } +}; + + +/** + * optional PlaygroundResponse playgroundResponse = 2; + * @return {?proto.web.communitygames.PlaygroundResponse} + */ +proto.web.communitygames.UpdatePlaygroundResponse.prototype.getPlaygroundresponse = function() { + return /** @type{?proto.web.communitygames.PlaygroundResponse} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.PlaygroundResponse, 2)); +}; + + +/** + * @param {?proto.web.communitygames.PlaygroundResponse|undefined} value + * @return {!proto.web.communitygames.UpdatePlaygroundResponse} returns this +*/ +proto.web.communitygames.UpdatePlaygroundResponse.prototype.setPlaygroundresponse = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.UpdatePlaygroundResponse} returns this + */ +proto.web.communitygames.UpdatePlaygroundResponse.prototype.clearPlaygroundresponse = function() { + return this.setPlaygroundresponse(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.UpdatePlaygroundResponse.prototype.hasPlaygroundresponse = 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.web.communitygames.DeletePlaygroundResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.DeletePlaygroundResponse.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.web.communitygames.DeletePlaygroundResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.DeletePlaygroundResponse.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.communitygames.DeletePlaygroundResponse} + */ +proto.web.communitygames.DeletePlaygroundResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.DeletePlaygroundResponse; + return proto.web.communitygames.DeletePlaygroundResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.DeletePlaygroundResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.DeletePlaygroundResponse} + */ +proto.web.communitygames.DeletePlaygroundResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.DeletePlaygroundResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.DeletePlaygroundResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.DeletePlaygroundResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.DeletePlaygroundResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.communitygames.PlaygroundInfoResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.communitygames.PlaygroundInfoResponse.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.web.communitygames.PlaygroundInfoResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.PlaygroundInfoResponse.toObject = function(includeInstance, msg) { + var f, obj = { + playground: (f = msg.getPlayground()) && proto.web.communitygames.PlaygroundResponse.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.web.communitygames.PlaygroundInfoResponse} + */ +proto.web.communitygames.PlaygroundInfoResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.communitygames.PlaygroundInfoResponse; + return proto.web.communitygames.PlaygroundInfoResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.communitygames.PlaygroundInfoResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.communitygames.PlaygroundInfoResponse} + */ +proto.web.communitygames.PlaygroundInfoResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.communitygames.PlaygroundResponse; + reader.readMessage(value,proto.web.communitygames.PlaygroundResponse.deserializeBinaryFromReader); + msg.setPlayground(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.communitygames.PlaygroundInfoResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.communitygames.PlaygroundInfoResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.communitygames.PlaygroundInfoResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.communitygames.PlaygroundInfoResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPlayground(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.communitygames.PlaygroundResponse.serializeBinaryToWriter + ); + } +}; + + +/** + * optional PlaygroundResponse playground = 1; + * @return {?proto.web.communitygames.PlaygroundResponse} + */ +proto.web.communitygames.PlaygroundInfoResponse.prototype.getPlayground = function() { + return /** @type{?proto.web.communitygames.PlaygroundResponse} */ ( + jspb.Message.getWrapperField(this, proto.web.communitygames.PlaygroundResponse, 1)); +}; + + +/** + * @param {?proto.web.communitygames.PlaygroundResponse|undefined} value + * @return {!proto.web.communitygames.PlaygroundInfoResponse} returns this +*/ +proto.web.communitygames.PlaygroundInfoResponse.prototype.setPlayground = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.communitygames.PlaygroundInfoResponse} returns this + */ +proto.web.communitygames.PlaygroundInfoResponse.prototype.clearPlayground = function() { + return this.setPlayground(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.communitygames.PlaygroundInfoResponse.prototype.hasPlayground = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * @enum {number} + */ +proto.web.communitygames.Platform = { + UNKNOWN: 0, + PC: 1, + PS4: 2, + XBOXONE: 3, + PS5: 4, + XBSX: 5, + COMMON: 6 +}; + +/** + * @enum {number} + */ +proto.web.communitygames.InputMethods = { + ALL: 0, + KEYBOARD_MOUSE: 1, + GAME_CONTROLLER: 3 +}; + +/** + * @enum {number} + */ +proto.web.communitygames.IncludeFields = { + AVAILABLE_GAME_DATA: 0, + METADATA: 1, + CUSTOM_DATA: 2, + CONSTRAINTS: 3, + AVAILABLE_TAGS: 4 +}; + +/** + * @enum {number} + */ +proto.web.communitygames.State = { + ACTIVE: 0, + ARCHIVED: 1 +}; + +/** + * @enum {number} + */ +proto.web.communitygames.Category = { + CATEGORY_UNKNOWN: 0, + CATEGORY_MODE: 1, + CATEGORY_PACKAGE: 2, + CATEGORY_GENERAL: 3 +}; + +/** + * @enum {number} + */ +proto.web.communitygames.PhantomGameState = { + ENABLED: 0, + DISABLED: 1 +}; + +/** + * @enum {number} + */ +proto.web.communitygames.CapacityType = { + AI_BACKFILL: 0, + AI_STATIC: 1 +}; + +/** + * @enum {number} + */ +proto.web.communitygames.RotationBehavior = { + LOOP: 0, + MATCHMAKE: 1, + ONE_MAP: 2 +}; + +/** + * @enum {number} + */ +proto.web.communitygames.RoundBehavior = { + CONTINUE: 0 +}; + +/** + * @enum {number} + */ +proto.web.communitygames.BalancingMethod = { + UNSPECIFIED: 0, + EVEN_NUMBERS: 1, + EVEN_PERCENTAGE: 2, + FILL_IN_TEAM_ORDER: 3 +}; + +goog.object.extend(exports, proto.web.communitygames); diff --git a/src/grpc-web/proto/localization_grpc_web_pb.d.ts b/src/grpc-web/proto/localization_grpc_web_pb.d.ts new file mode 100644 index 0000000..98920d8 --- /dev/null +++ b/src/grpc-web/proto/localization_grpc_web_pb.d.ts @@ -0,0 +1,32 @@ +import * as grpcWeb from 'grpc-web'; + +import { + GetTranslationsRequest, + GetTranslationsResponse} from './localization_pb'; + +export class ClientLocalizationClient { + constructor (hostname: string, + credentials?: null | { [index: string]: string; }, + options?: null | { [index: string]: string; }); + + getTranslations( + request: GetTranslationsRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: GetTranslationsResponse) => void + ): grpcWeb.ClientReadableStream; + +} + +export class ClientLocalizationPromiseClient { + constructor (hostname: string, + credentials?: null | { [index: string]: string; }, + options?: null | { [index: string]: string; }); + + getTranslations( + request: GetTranslationsRequest, + metadata?: grpcWeb.Metadata + ): Promise; + +} + diff --git a/src/grpc-web/proto/localization_grpc_web_pb.js b/src/grpc-web/proto/localization_grpc_web_pb.js new file mode 100644 index 0000000..3ab171f --- /dev/null +++ b/src/grpc-web/proto/localization_grpc_web_pb.js @@ -0,0 +1,155 @@ +/** + * @fileoverview gRPC-Web generated client stub for web.localization + * @enhanceable + * @public + */ + +// GENERATED CODE -- DO NOT EDIT! + + +/* eslint-disable */ +// @ts-nocheck + + + +const grpc = {}; +grpc.web = require('grpc-web'); + +const proto = {}; +proto.web = {}; +proto.web.localization = require('./localization_pb.js'); + +/** + * @param {string} hostname + * @param {?Object} credentials + * @param {?Object} options + * @constructor + * @struct + * @final + */ +proto.web.localization.ClientLocalizationClient = + function(hostname, credentials, options) { + if (!options) options = {}; + options['format'] = 'binary'; + + /** + * @private @const {!grpc.web.GrpcWebClientBase} The client + */ + this.client_ = new grpc.web.GrpcWebClientBase(options); + + /** + * @private @const {string} The hostname + */ + this.hostname_ = hostname; + +}; + + +/** + * @param {string} hostname + * @param {?Object} credentials + * @param {?Object} options + * @constructor + * @struct + * @final + */ +proto.web.localization.ClientLocalizationPromiseClient = + function(hostname, credentials, options) { + if (!options) options = {}; + options['format'] = 'binary'; + + /** + * @private @const {!grpc.web.GrpcWebClientBase} The client + */ + this.client_ = new grpc.web.GrpcWebClientBase(options); + + /** + * @private @const {string} The hostname + */ + this.hostname_ = hostname; + +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.localization.GetTranslationsRequest, + * !proto.web.localization.GetTranslationsResponse>} + */ +const methodDescriptor_ClientLocalization_getTranslations = new grpc.web.MethodDescriptor( + '/web.localization.ClientLocalization/getTranslations', + grpc.web.MethodType.UNARY, + proto.web.localization.GetTranslationsRequest, + proto.web.localization.GetTranslationsResponse, + /** + * @param {!proto.web.localization.GetTranslationsRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.localization.GetTranslationsResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.localization.GetTranslationsRequest, + * !proto.web.localization.GetTranslationsResponse>} + */ +const methodInfo_ClientLocalization_getTranslations = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.localization.GetTranslationsResponse, + /** + * @param {!proto.web.localization.GetTranslationsRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.localization.GetTranslationsResponse.deserializeBinary +); + + +/** + * @param {!proto.web.localization.GetTranslationsRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.localization.GetTranslationsResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.localization.ClientLocalizationClient.prototype.getTranslations = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.localization.ClientLocalization/getTranslations', + request, + metadata || {}, + methodDescriptor_ClientLocalization_getTranslations, + callback); +}; + + +/** + * @param {!proto.web.localization.GetTranslationsRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.localization.ClientLocalizationPromiseClient.prototype.getTranslations = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.localization.ClientLocalization/getTranslations', + request, + metadata || {}, + methodDescriptor_ClientLocalization_getTranslations); +}; + + +module.exports = proto.web.localization; + diff --git a/src/grpc-web/proto/localization_pb.d.ts b/src/grpc-web/proto/localization_pb.d.ts new file mode 100644 index 0000000..c55a0a9 --- /dev/null +++ b/src/grpc-web/proto/localization_pb.d.ts @@ -0,0 +1,198 @@ +import * as jspb from "google-protobuf" + +export class SidList extends jspb.Message { + getSidsList(): Array; + setSidsList(value: Array): SidList; + clearSidsList(): SidList; + addSids(value: string, index?: number): SidList; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): SidList.AsObject; + static toObject(includeInstance: boolean, msg: SidList): SidList.AsObject; + static serializeBinaryToWriter(message: SidList, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): SidList; + static deserializeBinaryFromReader(message: SidList, reader: jspb.BinaryReader): SidList; +} + +export namespace SidList { + export type AsObject = { + sidsList: Array, + } +} + +export class CategoryIdList extends jspb.Message { + getIdsList(): Array; + setIdsList(value: Array): CategoryIdList; + clearIdsList(): CategoryIdList; + addIds(value: number, index?: number): CategoryIdList; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): CategoryIdList.AsObject; + static toObject(includeInstance: boolean, msg: CategoryIdList): CategoryIdList.AsObject; + static serializeBinaryToWriter(message: CategoryIdList, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): CategoryIdList; + static deserializeBinaryFromReader(message: CategoryIdList, reader: jspb.BinaryReader): CategoryIdList; +} + +export namespace CategoryIdList { + export type AsObject = { + idsList: Array, + } +} + +export class SubCategoryIdList extends jspb.Message { + getIdsList(): Array; + setIdsList(value: Array): SubCategoryIdList; + clearIdsList(): SubCategoryIdList; + addIds(value: number, index?: number): SubCategoryIdList; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): SubCategoryIdList.AsObject; + static toObject(includeInstance: boolean, msg: SubCategoryIdList): SubCategoryIdList.AsObject; + static serializeBinaryToWriter(message: SubCategoryIdList, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): SubCategoryIdList; + static deserializeBinaryFromReader(message: SubCategoryIdList, reader: jspb.BinaryReader): SubCategoryIdList; +} + +export namespace SubCategoryIdList { + export type AsObject = { + idsList: Array, + } +} + +export class TranslationsQuery extends jspb.Message { + getSidlist(): SidList | undefined; + setSidlist(value?: SidList): TranslationsQuery; + hasSidlist(): boolean; + clearSidlist(): TranslationsQuery; + + getCategoryidlist(): CategoryIdList | undefined; + setCategoryidlist(value?: CategoryIdList): TranslationsQuery; + hasCategoryidlist(): boolean; + clearCategoryidlist(): TranslationsQuery; + + getSubcategoryidlist(): SubCategoryIdList | undefined; + setSubcategoryidlist(value?: SubCategoryIdList): TranslationsQuery; + hasSubcategoryidlist(): boolean; + clearSubcategoryidlist(): TranslationsQuery; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): TranslationsQuery.AsObject; + static toObject(includeInstance: boolean, msg: TranslationsQuery): TranslationsQuery.AsObject; + static serializeBinaryToWriter(message: TranslationsQuery, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): TranslationsQuery; + static deserializeBinaryFromReader(message: TranslationsQuery, reader: jspb.BinaryReader): TranslationsQuery; +} + +export namespace TranslationsQuery { + export type AsObject = { + sidlist?: SidList.AsObject, + categoryidlist?: CategoryIdList.AsObject, + subcategoryidlist?: SubCategoryIdList.AsObject, + } +} + +export class LocalizedText extends jspb.Message { + getSid(): string; + setSid(value: string): LocalizedText; + + getLocalizedtext(): string; + setLocalizedtext(value: string): LocalizedText; + + getCategoryid(): number; + setCategoryid(value: number): LocalizedText; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): LocalizedText.AsObject; + static toObject(includeInstance: boolean, msg: LocalizedText): LocalizedText.AsObject; + static serializeBinaryToWriter(message: LocalizedText, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): LocalizedText; + static deserializeBinaryFromReader(message: LocalizedText, reader: jspb.BinaryReader): LocalizedText; +} + +export namespace LocalizedText { + export type AsObject = { + sid: string, + localizedtext: string, + categoryid: number, + } +} + +export class Timestamp extends jspb.Message { + getSeconds(): string; + setSeconds(value: string): Timestamp; + + getNanos(): number; + setNanos(value: number): Timestamp; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Timestamp.AsObject; + static toObject(includeInstance: boolean, msg: Timestamp): Timestamp.AsObject; + static serializeBinaryToWriter(message: Timestamp, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Timestamp; + static deserializeBinaryFromReader(message: Timestamp, reader: jspb.BinaryReader): Timestamp; +} + +export namespace Timestamp { + export type AsObject = { + seconds: string, + nanos: number, + } +} + +export class GetTranslationsRequest extends jspb.Message { + getTranslationsquery(): TranslationsQuery | undefined; + setTranslationsquery(value?: TranslationsQuery): GetTranslationsRequest; + hasTranslationsquery(): boolean; + clearTranslationsquery(): GetTranslationsRequest; + + getLocale(): string; + setLocale(value: string): GetTranslationsRequest; + + getFetchfrom(): Timestamp | undefined; + setFetchfrom(value?: Timestamp): GetTranslationsRequest; + hasFetchfrom(): boolean; + clearFetchfrom(): GetTranslationsRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetTranslationsRequest.AsObject; + static toObject(includeInstance: boolean, msg: GetTranslationsRequest): GetTranslationsRequest.AsObject; + static serializeBinaryToWriter(message: GetTranslationsRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetTranslationsRequest; + static deserializeBinaryFromReader(message: GetTranslationsRequest, reader: jspb.BinaryReader): GetTranslationsRequest; +} + +export namespace GetTranslationsRequest { + export type AsObject = { + translationsquery?: TranslationsQuery.AsObject, + locale: string, + fetchfrom?: Timestamp.AsObject, + } +} + +export class GetTranslationsResponse extends jspb.Message { + getLocalizedtextsList(): Array; + setLocalizedtextsList(value: Array): GetTranslationsResponse; + clearLocalizedtextsList(): GetTranslationsResponse; + addLocalizedtexts(value?: LocalizedText, index?: number): LocalizedText; + + getFetcheduntil(): Timestamp | undefined; + setFetcheduntil(value?: Timestamp): GetTranslationsResponse; + hasFetcheduntil(): boolean; + clearFetcheduntil(): GetTranslationsResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): GetTranslationsResponse.AsObject; + static toObject(includeInstance: boolean, msg: GetTranslationsResponse): GetTranslationsResponse.AsObject; + static serializeBinaryToWriter(message: GetTranslationsResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): GetTranslationsResponse; + static deserializeBinaryFromReader(message: GetTranslationsResponse, reader: jspb.BinaryReader): GetTranslationsResponse; +} + +export namespace GetTranslationsResponse { + export type AsObject = { + localizedtextsList: Array, + fetcheduntil?: Timestamp.AsObject, + } +} + diff --git a/src/grpc-web/proto/localization_pb.js b/src/grpc-web/proto/localization_pb.js new file mode 100644 index 0000000..11b81c8 --- /dev/null +++ b/src/grpc-web/proto/localization_pb.js @@ -0,0 +1,1705 @@ +// source: proto/localization.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! + +var jspb = require('google-protobuf'); +var goog = jspb; +var global = Function('return this')(); + +goog.exportSymbol('proto.web.localization.CategoryIdList', null, global); +goog.exportSymbol('proto.web.localization.GetTranslationsRequest', null, global); +goog.exportSymbol('proto.web.localization.GetTranslationsResponse', null, global); +goog.exportSymbol('proto.web.localization.LocalizedText', null, global); +goog.exportSymbol('proto.web.localization.SidList', null, global); +goog.exportSymbol('proto.web.localization.SubCategoryIdList', null, global); +goog.exportSymbol('proto.web.localization.Timestamp', null, global); +goog.exportSymbol('proto.web.localization.TranslationsQuery', 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.web.localization.SidList = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.localization.SidList.repeatedFields_, null); +}; +goog.inherits(proto.web.localization.SidList, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.localization.SidList.displayName = 'proto.web.localization.SidList'; +} +/** + * 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.web.localization.CategoryIdList = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.localization.CategoryIdList.repeatedFields_, null); +}; +goog.inherits(proto.web.localization.CategoryIdList, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.localization.CategoryIdList.displayName = 'proto.web.localization.CategoryIdList'; +} +/** + * 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.web.localization.SubCategoryIdList = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.localization.SubCategoryIdList.repeatedFields_, null); +}; +goog.inherits(proto.web.localization.SubCategoryIdList, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.localization.SubCategoryIdList.displayName = 'proto.web.localization.SubCategoryIdList'; +} +/** + * 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.web.localization.TranslationsQuery = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.localization.TranslationsQuery, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.localization.TranslationsQuery.displayName = 'proto.web.localization.TranslationsQuery'; +} +/** + * 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.web.localization.LocalizedText = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.localization.LocalizedText, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.localization.LocalizedText.displayName = 'proto.web.localization.LocalizedText'; +} +/** + * 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.web.localization.Timestamp = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.localization.Timestamp, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.localization.Timestamp.displayName = 'proto.web.localization.Timestamp'; +} +/** + * 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.web.localization.GetTranslationsRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.localization.GetTranslationsRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.localization.GetTranslationsRequest.displayName = 'proto.web.localization.GetTranslationsRequest'; +} +/** + * 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.web.localization.GetTranslationsResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.web.localization.GetTranslationsResponse.repeatedFields_, null); +}; +goog.inherits(proto.web.localization.GetTranslationsResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.localization.GetTranslationsResponse.displayName = 'proto.web.localization.GetTranslationsResponse'; +} + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.localization.SidList.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.localization.SidList.prototype.toObject = function(opt_includeInstance) { + return proto.web.localization.SidList.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.web.localization.SidList} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.SidList.toObject = function(includeInstance, msg) { + var f, obj = { + sidsList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.localization.SidList} + */ +proto.web.localization.SidList.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.localization.SidList; + return proto.web.localization.SidList.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.localization.SidList} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.localization.SidList} + */ +proto.web.localization.SidList.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.addSids(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.localization.SidList.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.localization.SidList.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.localization.SidList} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.SidList.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getSidsList(); + if (f.length > 0) { + writer.writeRepeatedString( + 1, + f + ); + } +}; + + +/** + * repeated string sids = 1; + * @return {!Array} + */ +proto.web.localization.SidList.prototype.getSidsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.localization.SidList} returns this + */ +proto.web.localization.SidList.prototype.setSidsList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {string} value + * @param {number=} opt_index + * @return {!proto.web.localization.SidList} returns this + */ +proto.web.localization.SidList.prototype.addSids = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.localization.SidList} returns this + */ +proto.web.localization.SidList.prototype.clearSidsList = function() { + return this.setSidsList([]); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.localization.CategoryIdList.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.localization.CategoryIdList.prototype.toObject = function(opt_includeInstance) { + return proto.web.localization.CategoryIdList.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.web.localization.CategoryIdList} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.CategoryIdList.toObject = function(includeInstance, msg) { + var f, obj = { + idsList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.localization.CategoryIdList} + */ +proto.web.localization.CategoryIdList.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.localization.CategoryIdList; + return proto.web.localization.CategoryIdList.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.localization.CategoryIdList} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.localization.CategoryIdList} + */ +proto.web.localization.CategoryIdList.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Array} */ (reader.readPackedInt32()); + msg.setIdsList(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.localization.CategoryIdList.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.localization.CategoryIdList.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.localization.CategoryIdList} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.CategoryIdList.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getIdsList(); + if (f.length > 0) { + writer.writePackedInt32( + 1, + f + ); + } +}; + + +/** + * repeated int32 ids = 1; + * @return {!Array} + */ +proto.web.localization.CategoryIdList.prototype.getIdsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.localization.CategoryIdList} returns this + */ +proto.web.localization.CategoryIdList.prototype.setIdsList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {number} value + * @param {number=} opt_index + * @return {!proto.web.localization.CategoryIdList} returns this + */ +proto.web.localization.CategoryIdList.prototype.addIds = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.localization.CategoryIdList} returns this + */ +proto.web.localization.CategoryIdList.prototype.clearIdsList = function() { + return this.setIdsList([]); +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.localization.SubCategoryIdList.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.localization.SubCategoryIdList.prototype.toObject = function(opt_includeInstance) { + return proto.web.localization.SubCategoryIdList.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.web.localization.SubCategoryIdList} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.SubCategoryIdList.toObject = function(includeInstance, msg) { + var f, obj = { + idsList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.localization.SubCategoryIdList} + */ +proto.web.localization.SubCategoryIdList.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.localization.SubCategoryIdList; + return proto.web.localization.SubCategoryIdList.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.localization.SubCategoryIdList} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.localization.SubCategoryIdList} + */ +proto.web.localization.SubCategoryIdList.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Array} */ (reader.readPackedInt32()); + msg.setIdsList(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.localization.SubCategoryIdList.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.localization.SubCategoryIdList.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.localization.SubCategoryIdList} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.SubCategoryIdList.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getIdsList(); + if (f.length > 0) { + writer.writePackedInt32( + 1, + f + ); + } +}; + + +/** + * repeated int32 ids = 1; + * @return {!Array} + */ +proto.web.localization.SubCategoryIdList.prototype.getIdsList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 1)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.localization.SubCategoryIdList} returns this + */ +proto.web.localization.SubCategoryIdList.prototype.setIdsList = function(value) { + return jspb.Message.setField(this, 1, value || []); +}; + + +/** + * @param {number} value + * @param {number=} opt_index + * @return {!proto.web.localization.SubCategoryIdList} returns this + */ +proto.web.localization.SubCategoryIdList.prototype.addIds = function(value, opt_index) { + return jspb.Message.addToRepeatedField(this, 1, value, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.localization.SubCategoryIdList} returns this + */ +proto.web.localization.SubCategoryIdList.prototype.clearIdsList = function() { + return this.setIdsList([]); +}; + + + + + +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.web.localization.TranslationsQuery.prototype.toObject = function(opt_includeInstance) { + return proto.web.localization.TranslationsQuery.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.web.localization.TranslationsQuery} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.TranslationsQuery.toObject = function(includeInstance, msg) { + var f, obj = { + sidlist: (f = msg.getSidlist()) && proto.web.localization.SidList.toObject(includeInstance, f), + categoryidlist: (f = msg.getCategoryidlist()) && proto.web.localization.CategoryIdList.toObject(includeInstance, f), + subcategoryidlist: (f = msg.getSubcategoryidlist()) && proto.web.localization.SubCategoryIdList.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.web.localization.TranslationsQuery} + */ +proto.web.localization.TranslationsQuery.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.localization.TranslationsQuery; + return proto.web.localization.TranslationsQuery.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.localization.TranslationsQuery} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.localization.TranslationsQuery} + */ +proto.web.localization.TranslationsQuery.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.localization.SidList; + reader.readMessage(value,proto.web.localization.SidList.deserializeBinaryFromReader); + msg.setSidlist(value); + break; + case 2: + var value = new proto.web.localization.CategoryIdList; + reader.readMessage(value,proto.web.localization.CategoryIdList.deserializeBinaryFromReader); + msg.setCategoryidlist(value); + break; + case 3: + var value = new proto.web.localization.SubCategoryIdList; + reader.readMessage(value,proto.web.localization.SubCategoryIdList.deserializeBinaryFromReader); + msg.setSubcategoryidlist(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.localization.TranslationsQuery.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.localization.TranslationsQuery.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.localization.TranslationsQuery} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.TranslationsQuery.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getSidlist(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.localization.SidList.serializeBinaryToWriter + ); + } + f = message.getCategoryidlist(); + if (f != null) { + writer.writeMessage( + 2, + f, + proto.web.localization.CategoryIdList.serializeBinaryToWriter + ); + } + f = message.getSubcategoryidlist(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.web.localization.SubCategoryIdList.serializeBinaryToWriter + ); + } +}; + + +/** + * optional SidList sidList = 1; + * @return {?proto.web.localization.SidList} + */ +proto.web.localization.TranslationsQuery.prototype.getSidlist = function() { + return /** @type{?proto.web.localization.SidList} */ ( + jspb.Message.getWrapperField(this, proto.web.localization.SidList, 1)); +}; + + +/** + * @param {?proto.web.localization.SidList|undefined} value + * @return {!proto.web.localization.TranslationsQuery} returns this +*/ +proto.web.localization.TranslationsQuery.prototype.setSidlist = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.localization.TranslationsQuery} returns this + */ +proto.web.localization.TranslationsQuery.prototype.clearSidlist = function() { + return this.setSidlist(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.localization.TranslationsQuery.prototype.hasSidlist = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional CategoryIdList categoryIdList = 2; + * @return {?proto.web.localization.CategoryIdList} + */ +proto.web.localization.TranslationsQuery.prototype.getCategoryidlist = function() { + return /** @type{?proto.web.localization.CategoryIdList} */ ( + jspb.Message.getWrapperField(this, proto.web.localization.CategoryIdList, 2)); +}; + + +/** + * @param {?proto.web.localization.CategoryIdList|undefined} value + * @return {!proto.web.localization.TranslationsQuery} returns this +*/ +proto.web.localization.TranslationsQuery.prototype.setCategoryidlist = function(value) { + return jspb.Message.setWrapperField(this, 2, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.localization.TranslationsQuery} returns this + */ +proto.web.localization.TranslationsQuery.prototype.clearCategoryidlist = function() { + return this.setCategoryidlist(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.localization.TranslationsQuery.prototype.hasCategoryidlist = function() { + return jspb.Message.getField(this, 2) != null; +}; + + +/** + * optional SubCategoryIdList subCategoryIdList = 3; + * @return {?proto.web.localization.SubCategoryIdList} + */ +proto.web.localization.TranslationsQuery.prototype.getSubcategoryidlist = function() { + return /** @type{?proto.web.localization.SubCategoryIdList} */ ( + jspb.Message.getWrapperField(this, proto.web.localization.SubCategoryIdList, 3)); +}; + + +/** + * @param {?proto.web.localization.SubCategoryIdList|undefined} value + * @return {!proto.web.localization.TranslationsQuery} returns this +*/ +proto.web.localization.TranslationsQuery.prototype.setSubcategoryidlist = function(value) { + return jspb.Message.setWrapperField(this, 3, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.localization.TranslationsQuery} returns this + */ +proto.web.localization.TranslationsQuery.prototype.clearSubcategoryidlist = function() { + return this.setSubcategoryidlist(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.localization.TranslationsQuery.prototype.hasSubcategoryidlist = function() { + return jspb.Message.getField(this, 3) != null; +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.localization.LocalizedText.prototype.toObject = function(opt_includeInstance) { + return proto.web.localization.LocalizedText.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.web.localization.LocalizedText} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.LocalizedText.toObject = function(includeInstance, msg) { + var f, obj = { + sid: jspb.Message.getFieldWithDefault(msg, 1, ""), + localizedtext: jspb.Message.getFieldWithDefault(msg, 2, ""), + categoryid: jspb.Message.getFieldWithDefault(msg, 3, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.localization.LocalizedText} + */ +proto.web.localization.LocalizedText.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.localization.LocalizedText; + return proto.web.localization.LocalizedText.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.localization.LocalizedText} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.localization.LocalizedText} + */ +proto.web.localization.LocalizedText.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.setSid(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setLocalizedtext(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setCategoryid(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.localization.LocalizedText.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.localization.LocalizedText.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.localization.LocalizedText} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.LocalizedText.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getSid(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getLocalizedtext(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getCategoryid(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } +}; + + +/** + * optional string sid = 1; + * @return {string} + */ +proto.web.localization.LocalizedText.prototype.getSid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.localization.LocalizedText} returns this + */ +proto.web.localization.LocalizedText.prototype.setSid = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string localizedText = 2; + * @return {string} + */ +proto.web.localization.LocalizedText.prototype.getLocalizedtext = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.localization.LocalizedText} returns this + */ +proto.web.localization.LocalizedText.prototype.setLocalizedtext = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional int32 categoryId = 3; + * @return {number} + */ +proto.web.localization.LocalizedText.prototype.getCategoryid = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.localization.LocalizedText} returns this + */ +proto.web.localization.LocalizedText.prototype.setCategoryid = function(value) { + return jspb.Message.setProto3IntField(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.web.localization.Timestamp.prototype.toObject = function(opt_includeInstance) { + return proto.web.localization.Timestamp.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.web.localization.Timestamp} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.Timestamp.toObject = function(includeInstance, msg) { + var f, obj = { + seconds: jspb.Message.getFieldWithDefault(msg, 1, "0"), + nanos: jspb.Message.getFieldWithDefault(msg, 2, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.web.localization.Timestamp} + */ +proto.web.localization.Timestamp.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.localization.Timestamp; + return proto.web.localization.Timestamp.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.localization.Timestamp} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.localization.Timestamp} + */ +proto.web.localization.Timestamp.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readInt64String()); + msg.setSeconds(value); + break; + case 2: + var value = /** @type {number} */ (reader.readInt32()); + msg.setNanos(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.localization.Timestamp.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.localization.Timestamp.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.localization.Timestamp} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.Timestamp.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getSeconds(); + if (parseInt(f, 10) !== 0) { + writer.writeInt64String( + 1, + f + ); + } + f = message.getNanos(); + if (f !== 0) { + writer.writeInt32( + 2, + f + ); + } +}; + + +/** + * optional int64 seconds = 1; + * @return {string} + */ +proto.web.localization.Timestamp.prototype.getSeconds = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "0")); +}; + + +/** + * @param {string} value + * @return {!proto.web.localization.Timestamp} returns this + */ +proto.web.localization.Timestamp.prototype.setSeconds = function(value) { + return jspb.Message.setProto3StringIntField(this, 1, value); +}; + + +/** + * optional int32 nanos = 2; + * @return {number} + */ +proto.web.localization.Timestamp.prototype.getNanos = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.web.localization.Timestamp} returns this + */ +proto.web.localization.Timestamp.prototype.setNanos = function(value) { + return jspb.Message.setProto3IntField(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.web.localization.GetTranslationsRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.localization.GetTranslationsRequest.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.web.localization.GetTranslationsRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.GetTranslationsRequest.toObject = function(includeInstance, msg) { + var f, obj = { + translationsquery: (f = msg.getTranslationsquery()) && proto.web.localization.TranslationsQuery.toObject(includeInstance, f), + locale: jspb.Message.getFieldWithDefault(msg, 4, ""), + fetchfrom: (f = msg.getFetchfrom()) && proto.web.localization.Timestamp.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.web.localization.GetTranslationsRequest} + */ +proto.web.localization.GetTranslationsRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.localization.GetTranslationsRequest; + return proto.web.localization.GetTranslationsRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.localization.GetTranslationsRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.localization.GetTranslationsRequest} + */ +proto.web.localization.GetTranslationsRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.web.localization.TranslationsQuery; + reader.readMessage(value,proto.web.localization.TranslationsQuery.deserializeBinaryFromReader); + msg.setTranslationsquery(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setLocale(value); + break; + case 5: + var value = new proto.web.localization.Timestamp; + reader.readMessage(value,proto.web.localization.Timestamp.deserializeBinaryFromReader); + msg.setFetchfrom(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.localization.GetTranslationsRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.localization.GetTranslationsRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.localization.GetTranslationsRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.GetTranslationsRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTranslationsquery(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.web.localization.TranslationsQuery.serializeBinaryToWriter + ); + } + f = message.getLocale(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } + f = message.getFetchfrom(); + if (f != null) { + writer.writeMessage( + 5, + f, + proto.web.localization.Timestamp.serializeBinaryToWriter + ); + } +}; + + +/** + * optional TranslationsQuery translationsQuery = 1; + * @return {?proto.web.localization.TranslationsQuery} + */ +proto.web.localization.GetTranslationsRequest.prototype.getTranslationsquery = function() { + return /** @type{?proto.web.localization.TranslationsQuery} */ ( + jspb.Message.getWrapperField(this, proto.web.localization.TranslationsQuery, 1)); +}; + + +/** + * @param {?proto.web.localization.TranslationsQuery|undefined} value + * @return {!proto.web.localization.GetTranslationsRequest} returns this +*/ +proto.web.localization.GetTranslationsRequest.prototype.setTranslationsquery = function(value) { + return jspb.Message.setWrapperField(this, 1, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.localization.GetTranslationsRequest} returns this + */ +proto.web.localization.GetTranslationsRequest.prototype.clearTranslationsquery = function() { + return this.setTranslationsquery(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.localization.GetTranslationsRequest.prototype.hasTranslationsquery = function() { + return jspb.Message.getField(this, 1) != null; +}; + + +/** + * optional string locale = 4; + * @return {string} + */ +proto.web.localization.GetTranslationsRequest.prototype.getLocale = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.localization.GetTranslationsRequest} returns this + */ +proto.web.localization.GetTranslationsRequest.prototype.setLocale = function(value) { + return jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * optional Timestamp fetchFrom = 5; + * @return {?proto.web.localization.Timestamp} + */ +proto.web.localization.GetTranslationsRequest.prototype.getFetchfrom = function() { + return /** @type{?proto.web.localization.Timestamp} */ ( + jspb.Message.getWrapperField(this, proto.web.localization.Timestamp, 5)); +}; + + +/** + * @param {?proto.web.localization.Timestamp|undefined} value + * @return {!proto.web.localization.GetTranslationsRequest} returns this +*/ +proto.web.localization.GetTranslationsRequest.prototype.setFetchfrom = function(value) { + return jspb.Message.setWrapperField(this, 5, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.localization.GetTranslationsRequest} returns this + */ +proto.web.localization.GetTranslationsRequest.prototype.clearFetchfrom = function() { + return this.setFetchfrom(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.localization.GetTranslationsRequest.prototype.hasFetchfrom = function() { + return jspb.Message.getField(this, 5) != null; +}; + + + +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.web.localization.GetTranslationsResponse.repeatedFields_ = [3]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.localization.GetTranslationsResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.localization.GetTranslationsResponse.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.web.localization.GetTranslationsResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.GetTranslationsResponse.toObject = function(includeInstance, msg) { + var f, obj = { + localizedtextsList: jspb.Message.toObjectList(msg.getLocalizedtextsList(), + proto.web.localization.LocalizedText.toObject, includeInstance), + fetcheduntil: (f = msg.getFetcheduntil()) && proto.web.localization.Timestamp.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.web.localization.GetTranslationsResponse} + */ +proto.web.localization.GetTranslationsResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.localization.GetTranslationsResponse; + return proto.web.localization.GetTranslationsResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.localization.GetTranslationsResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.localization.GetTranslationsResponse} + */ +proto.web.localization.GetTranslationsResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 3: + var value = new proto.web.localization.LocalizedText; + reader.readMessage(value,proto.web.localization.LocalizedText.deserializeBinaryFromReader); + msg.addLocalizedtexts(value); + break; + case 4: + var value = new proto.web.localization.Timestamp; + reader.readMessage(value,proto.web.localization.Timestamp.deserializeBinaryFromReader); + msg.setFetcheduntil(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.localization.GetTranslationsResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.localization.GetTranslationsResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.localization.GetTranslationsResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.localization.GetTranslationsResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getLocalizedtextsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 3, + f, + proto.web.localization.LocalizedText.serializeBinaryToWriter + ); + } + f = message.getFetcheduntil(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.localization.Timestamp.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated LocalizedText localizedTexts = 3; + * @return {!Array} + */ +proto.web.localization.GetTranslationsResponse.prototype.getLocalizedtextsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.web.localization.LocalizedText, 3)); +}; + + +/** + * @param {!Array} value + * @return {!proto.web.localization.GetTranslationsResponse} returns this +*/ +proto.web.localization.GetTranslationsResponse.prototype.setLocalizedtextsList = function(value) { + return jspb.Message.setRepeatedWrapperField(this, 3, value); +}; + + +/** + * @param {!proto.web.localization.LocalizedText=} opt_value + * @param {number=} opt_index + * @return {!proto.web.localization.LocalizedText} + */ +proto.web.localization.GetTranslationsResponse.prototype.addLocalizedtexts = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 3, opt_value, proto.web.localization.LocalizedText, opt_index); +}; + + +/** + * Clears the list making it empty but non-null. + * @return {!proto.web.localization.GetTranslationsResponse} returns this + */ +proto.web.localization.GetTranslationsResponse.prototype.clearLocalizedtextsList = function() { + return this.setLocalizedtextsList([]); +}; + + +/** + * optional Timestamp fetchedUntil = 4; + * @return {?proto.web.localization.Timestamp} + */ +proto.web.localization.GetTranslationsResponse.prototype.getFetcheduntil = function() { + return /** @type{?proto.web.localization.Timestamp} */ ( + jspb.Message.getWrapperField(this, proto.web.localization.Timestamp, 4)); +}; + + +/** + * @param {?proto.web.localization.Timestamp|undefined} value + * @return {!proto.web.localization.GetTranslationsResponse} returns this +*/ +proto.web.localization.GetTranslationsResponse.prototype.setFetcheduntil = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.localization.GetTranslationsResponse} returns this + */ +proto.web.localization.GetTranslationsResponse.prototype.clearFetcheduntil = function() { + return this.setFetcheduntil(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.localization.GetTranslationsResponse.prototype.hasFetcheduntil = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +goog.object.extend(exports, proto.web.localization); diff --git a/src/grpc-web/proto/reporting_grpc_web_pb.d.ts b/src/grpc-web/proto/reporting_grpc_web_pb.d.ts new file mode 100644 index 0000000..dca5c10 --- /dev/null +++ b/src/grpc-web/proto/reporting_grpc_web_pb.d.ts @@ -0,0 +1,32 @@ +import * as grpcWeb from 'grpc-web'; + +import { + ReportPlaygroundRequest, + ReportPlaygroundResponse} from './reporting_pb'; + +export class WebReportingClient { + constructor (hostname: string, + credentials?: null | { [index: string]: string; }, + options?: null | { [index: string]: string; }); + + reportPlayground( + request: ReportPlaygroundRequest, + metadata: grpcWeb.Metadata | undefined, + callback: (err: grpcWeb.Error, + response: ReportPlaygroundResponse) => void + ): grpcWeb.ClientReadableStream; + +} + +export class WebReportingPromiseClient { + constructor (hostname: string, + credentials?: null | { [index: string]: string; }, + options?: null | { [index: string]: string; }); + + reportPlayground( + request: ReportPlaygroundRequest, + metadata?: grpcWeb.Metadata + ): Promise; + +} + diff --git a/src/grpc-web/proto/reporting_grpc_web_pb.js b/src/grpc-web/proto/reporting_grpc_web_pb.js new file mode 100644 index 0000000..fde21ea --- /dev/null +++ b/src/grpc-web/proto/reporting_grpc_web_pb.js @@ -0,0 +1,155 @@ +/** + * @fileoverview gRPC-Web generated client stub for web.reporting + * @enhanceable + * @public + */ + +// GENERATED CODE -- DO NOT EDIT! + + +/* eslint-disable */ +// @ts-nocheck + + + +const grpc = {}; +grpc.web = require('grpc-web'); + +const proto = {}; +proto.web = {}; +proto.web.reporting = require('./reporting_pb.js'); + +/** + * @param {string} hostname + * @param {?Object} credentials + * @param {?Object} options + * @constructor + * @struct + * @final + */ +proto.web.reporting.WebReportingClient = + function(hostname, credentials, options) { + if (!options) options = {}; + options['format'] = 'binary'; + + /** + * @private @const {!grpc.web.GrpcWebClientBase} The client + */ + this.client_ = new grpc.web.GrpcWebClientBase(options); + + /** + * @private @const {string} The hostname + */ + this.hostname_ = hostname; + +}; + + +/** + * @param {string} hostname + * @param {?Object} credentials + * @param {?Object} options + * @constructor + * @struct + * @final + */ +proto.web.reporting.WebReportingPromiseClient = + function(hostname, credentials, options) { + if (!options) options = {}; + options['format'] = 'binary'; + + /** + * @private @const {!grpc.web.GrpcWebClientBase} The client + */ + this.client_ = new grpc.web.GrpcWebClientBase(options); + + /** + * @private @const {string} The hostname + */ + this.hostname_ = hostname; + +}; + + +/** + * @const + * @type {!grpc.web.MethodDescriptor< + * !proto.web.reporting.ReportPlaygroundRequest, + * !proto.web.reporting.ReportPlaygroundResponse>} + */ +const methodDescriptor_WebReporting_reportPlayground = new grpc.web.MethodDescriptor( + '/web.reporting.WebReporting/reportPlayground', + grpc.web.MethodType.UNARY, + proto.web.reporting.ReportPlaygroundRequest, + proto.web.reporting.ReportPlaygroundResponse, + /** + * @param {!proto.web.reporting.ReportPlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.reporting.ReportPlaygroundResponse.deserializeBinary +); + + +/** + * @const + * @type {!grpc.web.AbstractClientBase.MethodInfo< + * !proto.web.reporting.ReportPlaygroundRequest, + * !proto.web.reporting.ReportPlaygroundResponse>} + */ +const methodInfo_WebReporting_reportPlayground = new grpc.web.AbstractClientBase.MethodInfo( + proto.web.reporting.ReportPlaygroundResponse, + /** + * @param {!proto.web.reporting.ReportPlaygroundRequest} request + * @return {!Uint8Array} + */ + function(request) { + return request.serializeBinary(); + }, + proto.web.reporting.ReportPlaygroundResponse.deserializeBinary +); + + +/** + * @param {!proto.web.reporting.ReportPlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @param {function(?grpc.web.Error, ?proto.web.reporting.ReportPlaygroundResponse)} + * callback The callback function(error, response) + * @return {!grpc.web.ClientReadableStream|undefined} + * The XHR Node Readable Stream + */ +proto.web.reporting.WebReportingClient.prototype.reportPlayground = + function(request, metadata, callback) { + return this.client_.rpcCall(this.hostname_ + + '/web.reporting.WebReporting/reportPlayground', + request, + metadata || {}, + methodDescriptor_WebReporting_reportPlayground, + callback); +}; + + +/** + * @param {!proto.web.reporting.ReportPlaygroundRequest} request The + * request proto + * @param {?Object} metadata User defined + * call metadata + * @return {!Promise} + * A native promise that resolves to the response + */ +proto.web.reporting.WebReportingPromiseClient.prototype.reportPlayground = + function(request, metadata) { + return this.client_.unaryCall(this.hostname_ + + '/web.reporting.WebReporting/reportPlayground', + request, + metadata || {}, + methodDescriptor_WebReporting_reportPlayground); +}; + + +module.exports = proto.web.reporting; + diff --git a/src/grpc-web/proto/reporting_pb.d.ts b/src/grpc-web/proto/reporting_pb.d.ts new file mode 100644 index 0000000..ce45132 --- /dev/null +++ b/src/grpc-web/proto/reporting_pb.d.ts @@ -0,0 +1,96 @@ +import * as jspb from "google-protobuf" + +export class StringValue extends jspb.Message { + getValue(): string; + setValue(value: string): StringValue; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): StringValue.AsObject; + static toObject(includeInstance: boolean, msg: StringValue): StringValue.AsObject; + static serializeBinaryToWriter(message: StringValue, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): StringValue; + static deserializeBinaryFromReader(message: StringValue, reader: jspb.BinaryReader): StringValue; +} + +export namespace StringValue { + export type AsObject = { + value: string, + } +} + +export class ReportPlaygroundRequest extends jspb.Message { + getProtocolversion(): string; + setProtocolversion(value: string): ReportPlaygroundRequest; + + getPlaygroundid(): string; + setPlaygroundid(value: string): ReportPlaygroundRequest; + + getCategory(): Category; + setCategory(value: Category): ReportPlaygroundRequest; + + getRequesteremail(): StringValue | undefined; + setRequesteremail(value?: StringValue): ReportPlaygroundRequest; + hasRequesteremail(): boolean; + clearRequesteremail(): ReportPlaygroundRequest; + + getSubject(): StringValue | undefined; + setSubject(value?: StringValue): ReportPlaygroundRequest; + hasSubject(): boolean; + clearSubject(): ReportPlaygroundRequest; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ReportPlaygroundRequest.AsObject; + static toObject(includeInstance: boolean, msg: ReportPlaygroundRequest): ReportPlaygroundRequest.AsObject; + static serializeBinaryToWriter(message: ReportPlaygroundRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ReportPlaygroundRequest; + static deserializeBinaryFromReader(message: ReportPlaygroundRequest, reader: jspb.BinaryReader): ReportPlaygroundRequest; +} + +export namespace ReportPlaygroundRequest { + export type AsObject = { + protocolversion: string, + playgroundid: string, + category: Category, + requesteremail?: StringValue.AsObject, + subject?: StringValue.AsObject, + } +} + +export class ReportPlaygroundResponse extends jspb.Message { + getPetitionid(): string; + setPetitionid(value: string): ReportPlaygroundResponse; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ReportPlaygroundResponse.AsObject; + static toObject(includeInstance: boolean, msg: ReportPlaygroundResponse): ReportPlaygroundResponse.AsObject; + static serializeBinaryToWriter(message: ReportPlaygroundResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ReportPlaygroundResponse; + static deserializeBinaryFromReader(message: ReportPlaygroundResponse, reader: jspb.BinaryReader): ReportPlaygroundResponse; +} + +export namespace ReportPlaygroundResponse { + export type AsObject = { + petitionid: string, + } +} + +export enum Category { + UNKNOWN_CATEGORY = 0, + CHEATING = 1, + HARASSMENT = 2, + SPAM = 3, + PLAGIARISM = 4, + HATE_SPEECH = 5, + SEXUALLY_EXPLICIT = 6, + CHILD_SOLICITATION = 7, + TERRORIST_THREAT = 8, + CLIENT_HACK = 9, + SUICIDE_THREAT = 10, + DOXING = 11, + ADVERTISING = 12, + INAPPROPRIATE = 13, + VIOLENT = 14, + OFFENSIVE = 15, + OFFENSIVE_CHAT = 16, + OFFENSIVE_NAME = 17, +} diff --git a/src/grpc-web/proto/reporting_pb.js b/src/grpc-web/proto/reporting_pb.js new file mode 100644 index 0000000..099b160 --- /dev/null +++ b/src/grpc-web/proto/reporting_pb.js @@ -0,0 +1,658 @@ +// source: proto/reporting.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! + +var jspb = require('google-protobuf'); +var goog = jspb; +var global = Function('return this')(); + +goog.exportSymbol('proto.web.reporting.Category', null, global); +goog.exportSymbol('proto.web.reporting.ReportPlaygroundRequest', null, global); +goog.exportSymbol('proto.web.reporting.ReportPlaygroundResponse', null, global); +goog.exportSymbol('proto.web.reporting.StringValue', 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.web.reporting.StringValue = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.reporting.StringValue, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.reporting.StringValue.displayName = 'proto.web.reporting.StringValue'; +} +/** + * 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.web.reporting.ReportPlaygroundRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.reporting.ReportPlaygroundRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.reporting.ReportPlaygroundRequest.displayName = 'proto.web.reporting.ReportPlaygroundRequest'; +} +/** + * 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.web.reporting.ReportPlaygroundResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.web.reporting.ReportPlaygroundResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + /** + * @public + * @override + */ + proto.web.reporting.ReportPlaygroundResponse.displayName = 'proto.web.reporting.ReportPlaygroundResponse'; +} + + + +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.web.reporting.StringValue.prototype.toObject = function(opt_includeInstance) { + return proto.web.reporting.StringValue.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.web.reporting.StringValue} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.reporting.StringValue.toObject = function(includeInstance, msg) { + var f, obj = { + value: 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.web.reporting.StringValue} + */ +proto.web.reporting.StringValue.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.reporting.StringValue; + return proto.web.reporting.StringValue.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.reporting.StringValue} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.reporting.StringValue} + */ +proto.web.reporting.StringValue.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.setValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.reporting.StringValue.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.reporting.StringValue.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.reporting.StringValue} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.reporting.StringValue.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getValue(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string value = 1; + * @return {string} + */ +proto.web.reporting.StringValue.prototype.getValue = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.reporting.StringValue} returns this + */ +proto.web.reporting.StringValue.prototype.setValue = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * Optional fields that are not set will be set to undefined. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * net/proto2/compiler/js/internal/generator.cc#kKeyword. + * @param {boolean=} opt_includeInstance Deprecated. whether to include the + * JSPB instance for transitional soy proto support: + * http://goto/soy-param-migration + * @return {!Object} + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.toObject = function(opt_includeInstance) { + return proto.web.reporting.ReportPlaygroundRequest.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.web.reporting.ReportPlaygroundRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.reporting.ReportPlaygroundRequest.toObject = function(includeInstance, msg) { + var f, obj = { + protocolversion: jspb.Message.getFieldWithDefault(msg, 1, ""), + playgroundid: jspb.Message.getFieldWithDefault(msg, 2, ""), + category: jspb.Message.getFieldWithDefault(msg, 3, 0), + requesteremail: (f = msg.getRequesteremail()) && proto.web.reporting.StringValue.toObject(includeInstance, f), + subject: (f = msg.getSubject()) && proto.web.reporting.StringValue.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.web.reporting.ReportPlaygroundRequest} + */ +proto.web.reporting.ReportPlaygroundRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.reporting.ReportPlaygroundRequest; + return proto.web.reporting.ReportPlaygroundRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.reporting.ReportPlaygroundRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.reporting.ReportPlaygroundRequest} + */ +proto.web.reporting.ReportPlaygroundRequest.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.setProtocolversion(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setPlaygroundid(value); + break; + case 3: + var value = /** @type {!proto.web.reporting.Category} */ (reader.readEnum()); + msg.setCategory(value); + break; + case 4: + var value = new proto.web.reporting.StringValue; + reader.readMessage(value,proto.web.reporting.StringValue.deserializeBinaryFromReader); + msg.setRequesteremail(value); + break; + case 5: + var value = new proto.web.reporting.StringValue; + reader.readMessage(value,proto.web.reporting.StringValue.deserializeBinaryFromReader); + msg.setSubject(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.reporting.ReportPlaygroundRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.reporting.ReportPlaygroundRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.reporting.ReportPlaygroundRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getProtocolversion(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getPlaygroundid(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getCategory(); + if (f !== 0.0) { + writer.writeEnum( + 3, + f + ); + } + f = message.getRequesteremail(); + if (f != null) { + writer.writeMessage( + 4, + f, + proto.web.reporting.StringValue.serializeBinaryToWriter + ); + } + f = message.getSubject(); + if (f != null) { + writer.writeMessage( + 5, + f, + proto.web.reporting.StringValue.serializeBinaryToWriter + ); + } +}; + + +/** + * optional string protocolVersion = 1; + * @return {string} + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.getProtocolversion = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.reporting.ReportPlaygroundRequest} returns this + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.setProtocolversion = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string playgroundId = 2; + * @return {string} + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.getPlaygroundid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.reporting.ReportPlaygroundRequest} returns this + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.setPlaygroundid = function(value) { + return jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional Category category = 3; + * @return {!proto.web.reporting.Category} + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.getCategory = function() { + return /** @type {!proto.web.reporting.Category} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** + * @param {!proto.web.reporting.Category} value + * @return {!proto.web.reporting.ReportPlaygroundRequest} returns this + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.setCategory = function(value) { + return jspb.Message.setProto3EnumField(this, 3, value); +}; + + +/** + * optional StringValue requesterEmail = 4; + * @return {?proto.web.reporting.StringValue} + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.getRequesteremail = function() { + return /** @type{?proto.web.reporting.StringValue} */ ( + jspb.Message.getWrapperField(this, proto.web.reporting.StringValue, 4)); +}; + + +/** + * @param {?proto.web.reporting.StringValue|undefined} value + * @return {!proto.web.reporting.ReportPlaygroundRequest} returns this +*/ +proto.web.reporting.ReportPlaygroundRequest.prototype.setRequesteremail = function(value) { + return jspb.Message.setWrapperField(this, 4, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.reporting.ReportPlaygroundRequest} returns this + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.clearRequesteremail = function() { + return this.setRequesteremail(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.hasRequesteremail = function() { + return jspb.Message.getField(this, 4) != null; +}; + + +/** + * optional StringValue subject = 5; + * @return {?proto.web.reporting.StringValue} + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.getSubject = function() { + return /** @type{?proto.web.reporting.StringValue} */ ( + jspb.Message.getWrapperField(this, proto.web.reporting.StringValue, 5)); +}; + + +/** + * @param {?proto.web.reporting.StringValue|undefined} value + * @return {!proto.web.reporting.ReportPlaygroundRequest} returns this +*/ +proto.web.reporting.ReportPlaygroundRequest.prototype.setSubject = function(value) { + return jspb.Message.setWrapperField(this, 5, value); +}; + + +/** + * Clears the message field making it undefined. + * @return {!proto.web.reporting.ReportPlaygroundRequest} returns this + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.clearSubject = function() { + return this.setSubject(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.web.reporting.ReportPlaygroundRequest.prototype.hasSubject = function() { + return jspb.Message.getField(this, 5) != 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.web.reporting.ReportPlaygroundResponse.prototype.toObject = function(opt_includeInstance) { + return proto.web.reporting.ReportPlaygroundResponse.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.web.reporting.ReportPlaygroundResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.reporting.ReportPlaygroundResponse.toObject = function(includeInstance, msg) { + var f, obj = { + petitionid: 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.web.reporting.ReportPlaygroundResponse} + */ +proto.web.reporting.ReportPlaygroundResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.web.reporting.ReportPlaygroundResponse; + return proto.web.reporting.ReportPlaygroundResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.web.reporting.ReportPlaygroundResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.web.reporting.ReportPlaygroundResponse} + */ +proto.web.reporting.ReportPlaygroundResponse.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.setPetitionid(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.web.reporting.ReportPlaygroundResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.web.reporting.ReportPlaygroundResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.web.reporting.ReportPlaygroundResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.web.reporting.ReportPlaygroundResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getPetitionid(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } +}; + + +/** + * optional string petitionId = 1; + * @return {string} + */ +proto.web.reporting.ReportPlaygroundResponse.prototype.getPetitionid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * @param {string} value + * @return {!proto.web.reporting.ReportPlaygroundResponse} returns this + */ +proto.web.reporting.ReportPlaygroundResponse.prototype.setPetitionid = function(value) { + return jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * @enum {number} + */ +proto.web.reporting.Category = { + UNKNOWN_CATEGORY: 0, + CHEATING: 1, + HARASSMENT: 2, + SPAM: 3, + PLAGIARISM: 4, + HATE_SPEECH: 5, + SEXUALLY_EXPLICIT: 6, + CHILD_SOLICITATION: 7, + TERRORIST_THREAT: 8, + CLIENT_HACK: 9, + SUICIDE_THREAT: 10, + DOXING: 11, + ADVERTISING: 12, + INAPPROPRIATE: 13, + VIOLENT: 14, + OFFENSIVE: 15, + OFFENSIVE_CHAT: 16, + OFFENSIVE_NAME: 17 +}; + +goog.object.extend(exports, proto.web.reporting); diff --git a/src/index.d.ts b/src/index.d.ts new file mode 100644 index 0000000..4334ad1 --- /dev/null +++ b/src/index.d.ts @@ -0,0 +1,9 @@ +export as namespace BfPortal; +export { ClientAuthenticationClient } from './grpc-web/proto/authentication_grpc_web_pb'; +export * as authentication from './grpc-web/proto/authentication_pb'; +export { CommunityGamesClient } from './grpc-web/proto/communitygames_grpc_web_pb'; +export * as communitygames from './grpc-web/proto/communitygames_pb'; +export { ClientLocalizationClient } from './grpc-web/proto/localization_grpc_web_pb'; +export * as localization from './grpc-web/proto/localization_pb'; +export { WebReportingClient } from './grpc-web/proto/reporting_grpc_web_pb'; +export * as reporting from './grpc-web/proto/reporting_pb'; \ No newline at end of file diff --git a/src/index.js b/src/index.js new file mode 100644 index 0000000..25211f9 --- /dev/null +++ b/src/index.js @@ -0,0 +1,5 @@ +var BfPortal = module.exports = null; +BfPortal.authentication = require("./grpc-web/proto/authentication_pb"); +BfPortal.communitygames = require("./grpc-web/proto/communitygames_pb"); +BfPortal.localization = require("./grpc-web/proto/localization_pb"); +BfPortal.reporting = require("./grpc-web/proto/reporting_pb"); \ No newline at end of file diff --git a/src/index.ts b/src/index.ts new file mode 100644 index 0000000..6b593d8 --- /dev/null +++ b/src/index.ts @@ -0,0 +1,300 @@ +import { CommunityGamesClient } from './grpc-web/proto/communitygames_grpc_web_pb'; +import * as communitygames from './grpc-web/proto/communitygames_pb'; +import * as grpcWeb from 'grpc-web'; +import { load } from "protobufjs"; +global.XMLHttpRequest = require('xhr2'); +var fs = require('fs'); + +const communityGames = new CommunityGamesClient('https://kingston-prod-wgw-envoy.ops.dice.se', null); +var metadata = { + "x-dice-tenancy": "prod_default-prod_default-kingston-common", + "x-gateway-session-id": "web-38eb969a-cff6-4c98-befe-b9e610f3df0e", + "x-grpc-web": "1", + "x-user-agent": "grpc-web-javascript/0.1" +} + + +const request = new communitygames.GetPlaygroundRequest(); +request.setPlaygroundid("bbe433c0-13fa-11ed-bc32-24a8c2c0764e"); +const call = communityGames.getPlayground(request, metadata, + (_err: grpcWeb.Error, response: communitygames.PlaygroundInfoResponse) => { + console.log("err:", _err) + var test = response.getPlayground()?.getOriginalplayground()?.getModrules()?.getCompatiblerules()?.getRules(); + if (test instanceof Uint8Array) { + console.log(new TextDecoder().decode(test)) + } + + load("proto/communitygames.proto", function(err, root) { + if (err) + throw err; + if (root == undefined) + return + + const AwesomeMessage = root.lookupType("web.communitygames.PlaygroundInfoResponse"); + + let decoded = AwesomeMessage.decode(response.serializeBinary()); + fs.writeFile("test.json", JSON.stringify(decoded, null, 4), function(err: any) { + if (err) { + console.log(err); + } + }); + }) +}); + +// const request = new communitygames.ListPlaygroundsByOwnerRequest(); +// request.setBlueprinttype("vanilla"); +// request.setProtocolversion("84668704"); +// const call = communityGames.listPlaygroundsByOwner(request, metadata, +// (_err: grpcWeb.Error, response: communitygames.ListPlaygroundsByOwnerResponse) => { +// load("proto/communitygames.proto", function(err, root) { +// if (err) +// throw err; +// if (root == undefined) +// return + +// const AwesomeMessage = root.lookupType("web.communitygames.ListPlaygroundsByOwnerResponse"); + +// let decoded = AwesomeMessage.decode(response.serializeBinary()); +// fs.writeFile("test.json", JSON.stringify(decoded, null, 4), function(err: any) { +// if (err) { +// console.log(err); +// } +// }); +// }) +// }); + +// const request = new communitygames.GetScheduledBlueprintsRequest(); +// const call = communityGames.getScheduledBlueprints(request, metadata, +// (_err: grpcWeb.Error, response: communitygames.GetScheduledBlueprintsResponse) => { + +// if (response.getBlueprints()?.getBlueprintid() == undefined) +// return + +// const fields = communitygames.IncludeFields; + +// const request = new communitygames.GetBlueprintsByIdRequest(); +// request.setBlueprintidsList([response.getBlueprints()?.getBlueprintid()!]) +// request.setIncludefieldsList([fields.AVAILABLE_GAME_DATA, fields.METADATA, fields.CUSTOM_DATA, fields.CONSTRAINTS, fields.AVAILABLE_TAGS]) + +// const call = communityGames.getBlueprintsById(request, metadata, +// (_err: grpcWeb.Error, response: communitygames.GetBlueprintsByIdResponse) => { +// load("proto/communitygames.proto", function(err, root) { +// if (err) +// throw err; +// if (root == undefined) +// return + +// const AwesomeMessage = root.lookupType("web.communitygames.GetBlueprintsByIdResponse"); + +// let decoded = AwesomeMessage.decode(response.serializeBinary()); +// fs.writeFile("test.json", JSON.stringify(decoded, null, 4), function(err: any) { +// if (err) { +// console.log(err); +// } +// }); +// }) +// }); +// }); + +// const request = new communitygames.GetConstraintsRequest(); +// const call = communityGames.getConstraints(request, metadata, +// (_err: grpcWeb.Error, response: communitygames.GetConstraintsResponse) => { +// load("proto/communitygames.proto", function(err, root) { +// if (err) +// throw err; +// if (root == undefined) +// return + +// const AwesomeMessage = root.lookupType("web.communitygames.GetConstraintsResponse"); + +// let decoded = AwesomeMessage.decode(response.serializeBinary()); +// fs.writeFile("test.json", JSON.stringify(decoded, null, 4), function(err: any) { +// if (err) { +// console.log(err); +// } +// }); +// }) +// }); + +// const request = new communitygames.SharePlaygroundRequest(); +// request.setPlaygroundid("42924ad0-7d1d-11ec-bd24-e2cf76b022fe") +// const call = communityGames.sharePlayground(request, metadata, +// (_err: grpcWeb.Error, response: communitygames.SharePlaygroundResponse) => { +// load("proto/communitygames.proto", function(err, root) { +// if (err) +// throw err; +// if (root == undefined) +// return + +// const AwesomeMessage = root.lookupType("web.communitygames.SharePlaygroundResponse"); + +// let decoded = AwesomeMessage.decode(response.serializeBinary()); +// fs.writeFile("test.json", JSON.stringify(decoded, null, 4), function(err: any) { +// if (err) { +// console.log(err); +// } +// }); +// }) +// }); + +// const request = new communitygames.GetProgressionTypesRequest(); +// const call = communityGames.getProgressionTypes(request, metadata, +// (_err: grpcWeb.Error, response: communitygames.GetProgressionTypesResponse) => { +// load("proto/communitygames.proto", function(err, root) { +// if (err) +// throw err; +// if (root == undefined) +// return + +// const AwesomeMessage = root.lookupType("web.communitygames.GetProgressionTypesResponse"); + +// let decoded = AwesomeMessage.decode(response.serializeBinary()); +// fs.writeFile("test.json", JSON.stringify(decoded, null, 4), function(err: any) { +// if (err) { +// console.log(err); +// } +// }); +// }) +// }); + +// const request = new communitygames.DeletePlaygroundRequest(); +// request.setPlaygroundid("e2c7d5a0-3772-11ed-87cf-05cba9cc70d6"); +// const call = communityGames.deletePlayground(request, metadata, +// (_err: grpcWeb.Error, response: communitygames.DeletePlaygroundResponse) => { +// if (_err) +// return "failed" +// }); + + + + + + + + + + + + + + + + + + +// load("proto/communitygames.proto", function(err, root) { +// if (err) +// throw err; +// if (root == undefined) +// return + +// var enc = new TextEncoder(); +// // from copy as fetch in chrome or firefox +// var encoded = enc.encode("\u0000\u0000\u0000\u0000Ÿ\u0012\u0007vanilla\u001a\u0004test\"\u0006\n\u0004test*7\n\u0016MaxPlayerCount_PerTeam\u0012\tWA_GM_All\u001a\u0006B\u0004\b \u0010\u0003\"\n297673875127\n5\n\fMP_Discarded\u0012\rConquestSmall\u0018@ \u00012\u000eConquestSmall0@\bH\u0004B\u0006\n\u0004testb\f\n\u0004\b\u0001\u0010 \n\u0004\b\u0002\u0010 "); + +// const AwesomeMessage = root.lookupType("web.communitygames.CreatePlaygroundRequest"); + +// var decodedMessage = AwesomeMessage.decode(encoded); +// fs.writeFile("test.json", JSON.stringify(decodedMessage, null, 4), function(err: any) { +// if (err) { +// console.log(err); +// } +// }); +// }) + +// load("proto/communitygames.proto", function(err, root) { +// if (err) +// throw err; +// if (root == undefined) +// return + +// const AwesomeMessage = root.lookupType("web.communitygames.CreatePlaygroundRequest"); + +// var encoded = { +// "blueprintType": "vanilla", +// "playgroundName": "testa", +// "playgroundDescription": { +// "value": "testa" +// }, +// "mutators": [ +// { +// "name": "MaxPlayerCount_PerTeam", +// "category": "WA_GM_All", +// "kind": { +// "intSparse": { +// "defaultValue": 32, +// "size": 3 +// } +// }, +// "mutatorId": "2976738751" +// } +// ], +// "mapRotation": { +// "maps": [ +// { +// "mapname": "MP_Discarded", +// "mode": "ConquestSmall", +// "gameSize": 64, +// "rounds": 1, +// "location": "ConquestSmall0", +// "warmUpSize": 8, +// "allowedSpectators": 4 +// } +// ] +// }, +// "settings": { +// "name": "testa" +// }, +// "teamComposition": { +// "teams": { +// "teamId": 2, +// "capacity": 32 +// } +// } +// } + +// var encodedMessage = AwesomeMessage.encode(encoded).finish(); +// const request = communitygames.CreatePlaygroundRequest.deserializeBinary(encodedMessage); +// console.log(request) + +// const call = communityGames.createPlayground(request, metadata, +// (_err: grpcWeb.Error, response: communitygames.CreatePlaygroundResponse) => { +// console.log(_err) + +// const AwesomeMessage = root.lookupType("web.communitygames.CreatePlaygroundResponse"); + +// let decoded = AwesomeMessage.decode(response.serializeBinary()); +// fs.writeFile("test.json", JSON.stringify(decoded, null, 4), function(err: any) { +// if (err) { +// console.log(err); +// } +// }); +// }); +// }) + + + + + + + + +// load("proto/communitygames.proto", function(err, root) { +// if (err) +// throw err; +// if (root == undefined) +// return + +// var enc = new TextEncoder(); +// // from copy as fetch in chrome or firefox +// var encoded = enc.encode("\u0000\u0000\u0000\u00017\u0012´\u0002\n$355a31a0-3778-11ed-a187-5967b3f31df6\u001a\u0007vanilla\"\u0005testa*\u0004test27\n\u0016MaxPlayerCount_PerTeam\u0012\tWA_GM_All\u001a\u0006B\u0004\b \u0010\u0003\"\n2976738751:7\n5\n\fMP_Discarded\u0012\rConquestSmall\u0018@ \u00012\u000eConquestSmall0@\bH\u0004J@8e8764e80b0c1a012c7491b310c5b6c25bb19114e237608b33d876e41f7baab2Z\f\b¾­™\u0006\u0010À§›¶\u0003b\f\b¾­™\u0006\u0010À§›¶\u0003j\u0007\n\u0005testar\u000e\b”¹À·\n\u0010í•æú\u0002\u0018\u0001’\u0001\f\n\u0004\b\u0001\u0010 \n\u0004\b\u0002\u0010 "); + +// const AwesomeMessage = root.lookupType("web.communitygames.UpdatePlaygroundRequest"); + +// var decodedMessage = AwesomeMessage.decode(encoded); +// fs.writeFile("test.json", JSON.stringify(decodedMessage, null, 4), function(err: any) { +// if (err) { +// console.log(err); +// } +// }); +// }) \ No newline at end of file diff --git a/test.json b/test.json new file mode 100644 index 0000000..27f4c16 --- /dev/null +++ b/test.json @@ -0,0 +1,806 @@ +{ + "playground": { + "originalPlayground": { + "playgroundId": "bbe433c0-13fa-11ed-bc32-24a8c2c0764e", + "blueprintType": "vanilla", + "name": "! ESCALATION 2042", + "description": "Welcome to ESCALATION! 32 vs 32 specialists tdm with three phases: each phase brings heavier vehicles. First to 300 wins!", + "mutators": [ + { + "name": "VehicleSpawnDelayMultiplier_PerTeam", + "category": "Native,WA_ST_Vehicle,WA_XP_Reduced", + "kind": { + "mutatorSparseFloat": { + "defaultValue": 0.6000000238418579, + "size": 3 + } + }, + "id": "3192277320" + }, + { + "name": "CombatVehicleSpawnType_PerTeam", + "category": "WA_ST_Vehicle", + "kind": { + "mutatorSparseInt": { + "defaultValue": 2, + "size": 3 + } + }, + "id": "4125176977" + }, + { + "name": "AiMaxCount_PerTeam", + "category": "WA_ST_AI", + "kind": { + "mutatorSparseInt": { + "defaultValue": 30, + "size": 3 + } + }, + "id": "1544673979" + }, + { + "name": "AiSpawnType", + "category": "WA_ST_AI,WA_XP_Reduced", + "kind": { + "mutatorInt": { + "value": 2 + } + }, + "id": "1666992788" + }, + { + "name": "AiDifficulty_PerTeam", + "category": "WA_ST_AI", + "kind": { + "mutatorSparseInt": { + "defaultValue": 2, + "size": 3 + } + }, + "id": "2622397711" + }, + { + "name": "MaxPlayerCount_PerTeam", + "category": "WA_GM_All", + "kind": { + "mutatorSparseInt": { + "defaultValue": 32, + "size": 3 + } + }, + "id": "2976738751" + }, + { + "name": "FactionID_PerTeam", + "category": "WA_ST_Era", + "kind": { + "mutatorSparseInt": { + "defaultValue": 753847964, + "size": 3, + "sparseValues": { + "index": 2, + "value": -1345154873 + } + } + }, + "id": "548273204" + }, + { + "name": "ModBuilder_GameMode", + "category": "WA_GM_Custom,WA_XP_Reduced", + "kind": { + "mutatorInt": { + "value": 1 + } + }, + "id": "2047132398" + } + ], + "mapRotation": { + "maps": [ + { + "mapname": "MP_LightHouse", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom0", + "warmUpSize": 6, + "allowedSpectators": 4 + }, + { + "mapname": "MP_Port", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom1", + "warmUpSize": 6, + "allowedSpectators": 4 + }, + { + "mapname": "MP_Frost", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom0", + "warmUpSize": 6, + "allowedSpectators": 4 + }, + { + "mapname": "MP_Discarded", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom0", + "warmUpSize": 6, + "allowedSpectators": 4 + }, + { + "mapname": "MP_Rural", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom0", + "warmUpSize": 6, + "allowedSpectators": 4 + }, + { + "mapname": "MP_Harbor", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom0", + "warmUpSize": 6, + "allowedSpectators": 4 + } + ] + }, + "checksum": "b3ec1b037ffdc063403d9b9514051d7aa73c94640a94e50ea42a9d43b0adeba6", + "createdAt": { + "seconds": "1659620313", + "nanos": 364000000 + }, + "updatedAt": { + "seconds": "1660318980", + "nanos": 785000000 + }, + "serverSettings": { + "name": "! ESCALATION 2042", + "configName": { + "value": "! ESCALATION 2042" + }, + "ConfigDescription": { + "value": "Welcome to ESCALATION! 32 vs 32 specialists tdm with three phases: each phase brings heavier vehicles. First to 300 wins!" + } + }, + "owner": { + "nucleusId": "2395741186", + "personaId": "1135135840", + "platformId": "PC" + }, + "modRules": { + "compatibleRules": { + "rules": "{"mainWorkspace":"<xml xmlns=\"https://developers.google.com/blockly/xml\"><variables><variable type=\"Global\" id=\"@?=3tY%]i*G8FiB!zskt\">messages</variable></variables><block type=\"modBlock\" deletable=\"false\" x=\"-337\" y=\"86\"><statement name=\"RULES\"><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnPlayerJoinGame</field><statement name=\"ACTIONS\"><block type=\"SetTeam\"><value name=\"VALUE-0\"><block type=\"EventPlayer\"></block></value><value name=\"VALUE-1\"><block type=\"GetTeamId\"><value name=\"VALUE-0\"><block type=\"RandomReal\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">1</field></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">2</field></block></value></block></value></block></value></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnGameModeStarted</field><statement name=\"ACTIONS\"><block type=\"SetTargetScore\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"SetRoundTimeLimit\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">900</field></block></value></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnGameModeStarted</field><statement name=\"ACTIONS\"><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Welcome to ESCALATION!</field></block></value></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">1st phase: 5 minutes</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">HeaderText</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">LATV4 Recon available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText1</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"UnspawnAllPlayers\"><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Phase 2 commences</field></block></value></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">2nd phase: 5 minutes</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">HeaderText</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">LATV4 Recon available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText1</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">MAVs &amp; Boltes available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText2</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"UnspawnAllPlayers\"><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Last phase commences</field></block></value></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">3rd phase: 5 minutes</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">HeaderText</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">LATV4 Recon available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText1</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">MAVs &amp; Boltes available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText2</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Main Battle Tanks &amp; Nightbirds available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText3</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnGameModeStarted</field><statement name=\"ACTIONS\"><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"EmptyArray\"></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Specialis teamwork brings victory!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Use anti tank mines to block lanes!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Revive to keep up your numbers!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Hold down key positions!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Try out different vehicle loadouts!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Repair those vehicles!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Irish, lock down key positions!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Mackay, give us a height advantage!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Dozer, use your shield to push!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Boris, put turrets on those lanes!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Casper, spot those flanks!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Rao, hack those vehicles!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Paik, hightlight their position!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Falck, keep our healt up!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Angel, top us up!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Liz, keep pressure on their armour!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Sundance, blast them with your grenades!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Look up for sniping positions!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Insertion beacons give us an edge!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Use smoke to cover our positioning!</field></block></value></block></value></block></value></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnPlayerIrreversiblyDead</field><statement name=\"ACTIONS\"><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"RandomValueInArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value></block></value><value name=\"VALUE-1\"><block type=\"EventPlayer\"></block></value></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnGameModeStarted</field><statement name=\"ACTIONS\"><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">290</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">10 SECONDS UNTIL REDEPLOY!</field></block></value></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">10 SECONDS UNTIL REDEPLOY!</field></block></value></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">TIME IS ALMOST UP!</field></block></value></block></value></block></next></block></next></block></next></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnGameModeStarted</field><statement name=\"ACTIONS\"><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">240</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">LAST MINUTE OF PHASE 1 !</field></block></value></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">LAST MINUTE OF PHASE 2 !</field></block></value></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">FINAL MINUTE OF THE GAME!</field></block></value></block></value></block></next></block></next></block></next></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">MAV</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"IsVehicleOccupied\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"LessThan\"><value name=\"VALUE-0\"><block type=\"GetGameModeTimeElapsed\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehiclesItem\"><field name=\"VALUE-0\">Medium</field><field name=\"VALUE-1\">FNSS_ZAHA</field></block></value></block></value></block></next></block></next></block></statement><statement name=\"ACTIONS\"><block type=\"ForceExitAllPlayerInVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">3</field></block></value><next><block type=\"DestroyVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"IsVehicleOccupied\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"LessThan\"><value name=\"VALUE-0\"><block type=\"GetGameModeTimeElapsed\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehiclesItem\"><field name=\"VALUE-0\">Medium</field><field name=\"VALUE-1\">Bolte</field></block></value></block></value></block></next></block></next></block></statement><statement name=\"ACTIONS\"><block type=\"ForceExitAllPlayerInVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">3</field></block></value><next><block type=\"DestroyVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"IsVehicleOccupied\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"LessThan\"><value name=\"VALUE-0\"><block type=\"GetGameModeTimeElapsed\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">600</field></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehiclesItem\"><field name=\"VALUE-0\">Heavy</field><field name=\"VALUE-1\">M1_Abrams</field></block></value></block></value></block></next></block></next></block></statement><statement name=\"ACTIONS\"><block type=\"ForceExitAllPlayerInVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">3</field></block></value><next><block type=\"DestroyVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"IsVehicleOccupied\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"LessThan\"><value name=\"VALUE-0\"><block type=\"GetGameModeTimeElapsed\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">600</field></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehicleTypesItem\"><field name=\"VALUE-0\">VehicleTypes</field><field name=\"VALUE-1\">Heavy</field></block></value></block></value></block></next></block></next></block></statement><statement name=\"ACTIONS\"><block type=\"ForceExitAllPlayerInVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">3</field></block></value><next><block type=\"DestroyVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"IsVehicleOccupied\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"LessThan\"><value name=\"VALUE-0\"><block type=\"GetGameModeTimeElapsed\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">600</field></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehiclesItem\"><field name=\"VALUE-0\">Helicopter</field><field name=\"VALUE-1\">LittleBird</field></block></value></block></value></block></next></block></next></block></statement><statement name=\"ACTIONS\"><block type=\"ForceExitAllPlayerInVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">3</field></block></value><next><block type=\"DestroyVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5 buff</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehiclesItem\"><field name=\"VALUE-0\">Heavy</field><field name=\"VALUE-1\">M1_Abrams</field></block></value></block></value></block></statement><statement name=\"ACTIONS\"><block type=\"SetVehicleMaxHealthMultiplier\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">2</field></block></value></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5 buff</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehicleTypesItem\"><field name=\"VALUE-0\">VehicleTypes</field><field name=\"VALUE-1\">Heavy</field></block></value></block></value></block></statement><statement name=\"ACTIONS\"><block type=\"SetVehicleMaxHealthMultiplier\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">2</field></block></value></block></statement></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></statement></block></xml>","variables":"<variables xmlns=\"https://developers.google.com/blockly/xml\"><variable type=\"Global\" id=\"@?=3tY%]i*G8FiB!zskt\">messages</variable></variables>"}", + "rulesVersion": 1043927622, + "compiled": { + "compressed": { + "compiledModRules": "H4sIAAAAAAAAA+1a3U/jOBD/V3x5uKc80LJ30vIWSqA59UtNYHW3Qis3GRpfHTuynUIX8b/vOGmhLeWOFe2C0qovqb9mfjPjXyYe3zshGMPEWDsn984FlyPKr6hidMShJQthnJOG6/RH/0JsVtpx/NfrB9cZFhzs873jT8EO/+r0xYDTGai/JBMXNAPn2nVaUiTMMCnKea7jxYs/9/Nn58SqEgHNHNcZUEWzqveK8gKws1y+Wth5cJ/aL6pJQbJ52pCKRGZDoHy5v+E2rx+qn7uiudW3KxMIDVUGkp9SnaoxmDCWCpZFHR8dlUKWhw7RgknEMuiwjJnl0Z/t6K0plcrbnjTshsXUNnVBazqGzYba0Ol8AR7LDIiRxA9bXseLgn7vN2eu4aOcM6ZzdEyr0EZmbxLY0IbkKdVwQv4gGROFweC6XnZ3JWQ+VwcGVsJlrRu72kATUBHcGbvOM2dsT3U0ztUnMoRYCkKnlHG7Vd6m+/zRKt/YqP0Xuho9zwZcCp3TW+FxXu0c7ayG4lsDZGB9RZoEoyQDEZfO2pWBmyI5xMbrY2N72ne9K01+J6eSo8V3oH/zY8Z2hy7I6JeE97E6hPcehfcW9adMkFNqDAcSUTGxYHpsnJoRU8kuAB0/Atpi9rRILjfjXk1Ml8ccraDys9zMPKXozFnbqFsT4eU5YPImKymbl3qTrBVpmxwe5hAzypkmBhPfW6kmZKRsCk+mLDZSzaoMrbb4L5GRqTCMGIx2S5W4bTFDHXEZTwin+LfmBhjClE3LrHwCkJMiJzNZKCKKbISvwZqDb0uekETeCgQ/I7nUFbvUHHWkZkQWhiTs5gYUEi6ZQspipHwuaYI9dTfAEHLKFDGpxN0/x153zIFiOnVJyWt7F/FdGk/ozCVjS3UF5jEkBZvVEJpMkf1xeM0NcCa/g3IROlT0rlMGSH3I+nmh05qDP5UY+y4iNcQUSoHRBD8uqt2/D6/4FtW59b7OpZnDvuE2ua857iGVLklx6+8X0w8omyBuy2+8JDmDZKceub7m6M8pjxF+mcxapkuBcoNpbc1he2IM3EVCz+37rfZwO+z73Me5wu5CQUXpNtCpytDxNTdAWIiEihhc/FS1Z4sIPSO3zKTV+32MaT1Nak91HSkn9pP1RmJKI1jOxHhvctpAaFAWFhkBjRHvU3YrCCS1T2ntyY3O5KQ8u4jlFFTJ9wv3YygsDLB+slgd8QeYCeIkzUZ8dgZ0R5XQqmRc/gvEDo21enK5XN7e3snqehWl+Xm9Gv3WMknjiIR+q987C8llLwo6ZOif+YNO/+/ndeL/LenUS5ko6PokCInX6fbDiFwOlnb3Llz7adsAOh6q3Q16l5FP+udk0PZCnzTIe9hyoyrNd1HlPOh5nSVdorZPLryuv9G75cUZnH5Vfcc8c+6TqEDPx/TjuMgZvHCfpVx6sdoqhXRQ2Sil4kW2WkSavXnic5prFPJUmnqsDMkspwrmMnr2As8rNFlaYN72vKi06MDG814YfvvHa3uV0V4I8XOpYvDvmHks8gZiIfG11nk5MtYKcqCNkrOfWv7g7Fc5uyytHhz9Sx3953s4utv45o3K9oOz6+DsaJa/7PCy0ymvmUxnB4fXwuH/ubs7zN4xOWUq2U9vfyAKtWcC1ZwuvWvb49K0W3DDcs7w+/E1WjU/gCG2RC9bMgYuHxYjJQtjb5TYD6+HH0kxQjweLwAA", + "rulesVersion": 1043927622, + "inflatedSize": 12062 + } + } + } + }, + "assetCategories": [ + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AE9", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AE9" + ], + "teamId": 1 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AEA", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AEA" + ], + "teamId": 2 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AEB", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AEB" + ], + "teamId": 1 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AF8", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AF8" + ], + "teamId": 2 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AF5", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AF5" + ], + "teamId": 2 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AF6", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AF6" + ], + "teamId": 1 + } + ] + } + }, + { + "tagId": "B0813C5F-D964-490D-9968-45288B92A079", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "B0813C5F-D964-490D-9968-45288B92A079" + ], + "teamId": 2 + } + ] + } + }, + { + "tagId": "1FF2096A-7BB4-45CE-BBC9-FDE4C9FFEABE", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "1FF2096A-7BB4-45CE-BBC9-FDE4C9FFEABE" + ], + "teamId": 1 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AEC", + "boolean": {} + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AEE", + "boolean": {} + } + ], + "teamComposition": { + "teams": { + "teamId": 2, + "capacity": 32 + }, + "internalTeams": [ + { + "teamId": 1, + "capacity": 30 + }, + { + "teamId": 2, + "capacity": 30 + } + ] + } + }, + "validatedPlayground": { + "playgroundId": "bbe433c0-13fa-11ed-bc32-24a8c2c0764e", + "blueprintType": "vanilla", + "name": "! ESCALATION 2042", + "description": "Welcome to ESCALATION! 32 vs 32 specialists tdm with three phases: each phase brings heavier vehicles. First to 300 wins!", + "mutators": [ + { + "name": "VehicleSpawnDelayMultiplier_PerTeam", + "category": "Native,WA_ST_Vehicle,WA_XP_Reduced", + "kind": { + "mutatorSparseFloat": { + "defaultValue": 0.6000000238418579, + "size": 3 + } + }, + "id": "3192277320" + }, + { + "name": "CombatVehicleSpawnType_PerTeam", + "category": "WA_ST_Vehicle", + "kind": { + "mutatorSparseInt": { + "defaultValue": 2, + "size": 3 + } + }, + "id": "4125176977" + }, + { + "name": "AiMaxCount_PerTeam", + "category": "WA_ST_AI", + "kind": { + "mutatorSparseInt": { + "defaultValue": 30, + "size": 3 + } + }, + "id": "1544673979" + }, + { + "name": "AiSpawnType", + "category": "WA_ST_AI,WA_XP_Reduced", + "kind": { + "mutatorInt": { + "value": 2 + } + }, + "id": "1666992788" + }, + { + "name": "AiDifficulty_PerTeam", + "category": "WA_ST_AI", + "kind": { + "mutatorSparseInt": { + "defaultValue": 2, + "size": 3 + } + }, + "id": "2622397711" + }, + { + "name": "MaxPlayerCount_PerTeam", + "category": "WA_GM_All", + "kind": { + "mutatorSparseInt": { + "defaultValue": 32, + "size": 3 + } + }, + "id": "2976738751" + }, + { + "name": "FactionID_PerTeam", + "category": "WA_ST_Era", + "kind": { + "mutatorSparseInt": { + "defaultValue": 753847964, + "size": 3, + "sparseValues": { + "index": 2, + "value": -1345154873 + } + } + }, + "id": "548273204" + }, + { + "name": "ModBuilder_GameMode", + "category": "WA_GM_Custom,WA_XP_Reduced", + "kind": { + "mutatorInt": { + "value": 1 + } + }, + "id": "2047132398" + } + ], + "mapRotation": { + "maps": [ + { + "mapname": "MP_LightHouse", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom0", + "warmUpSize": 6, + "allowedSpectators": 4 + }, + { + "mapname": "MP_Port", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom1", + "warmUpSize": 6, + "allowedSpectators": 4 + }, + { + "mapname": "MP_Frost", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom0", + "warmUpSize": 6, + "allowedSpectators": 4 + }, + { + "mapname": "MP_Discarded", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom0", + "warmUpSize": 6, + "allowedSpectators": 4 + }, + { + "mapname": "MP_Rural", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom0", + "warmUpSize": 6, + "allowedSpectators": 4 + }, + { + "mapname": "MP_Harbor", + "mode": "ModBuilderCustom", + "gameSize": 64, + "rounds": 1, + "location": "ModBuilderCustom0", + "warmUpSize": 6, + "allowedSpectators": 4 + } + ] + }, + "checksum": "c93db51cd46c82bd989bd65e1e077502701f5a673344cfdae3cf5492c177ce66", + "createdAt": { + "seconds": "1659620313", + "nanos": 364000000 + }, + "updatedAt": { + "seconds": "1660318980", + "nanos": 785000000 + }, + "serverSettings": { + "name": "! ESCALATION 2042", + "configName": { + "value": "! ESCALATION 2042" + }, + "ConfigDescription": { + "value": "Welcome to ESCALATION! 32 vs 32 specialists tdm with three phases: each phase brings heavier vehicles. First to 300 wins!" + } + }, + "owner": { + "nucleusId": "2395741186", + "personaId": "1135135840", + "platformId": "PC" + }, + "modRules": { + "incompatibleRules": { + "rules": "{"mainWorkspace":"<xml xmlns=\"https://developers.google.com/blockly/xml\"><variables><variable type=\"Global\" id=\"@?=3tY%]i*G8FiB!zskt\">messages</variable></variables><block type=\"modBlock\" deletable=\"false\" x=\"-337\" y=\"86\"><statement name=\"RULES\"><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnPlayerJoinGame</field><statement name=\"ACTIONS\"><block type=\"SetTeam\"><value name=\"VALUE-0\"><block type=\"EventPlayer\"></block></value><value name=\"VALUE-1\"><block type=\"GetTeamId\"><value name=\"VALUE-0\"><block type=\"RandomReal\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">1</field></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">2</field></block></value></block></value></block></value></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnGameModeStarted</field><statement name=\"ACTIONS\"><block type=\"SetTargetScore\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"SetRoundTimeLimit\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">900</field></block></value></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnGameModeStarted</field><statement name=\"ACTIONS\"><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Welcome to ESCALATION!</field></block></value></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">1st phase: 5 minutes</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">HeaderText</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">LATV4 Recon available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText1</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"UnspawnAllPlayers\"><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Phase 2 commences</field></block></value></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">2nd phase: 5 minutes</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">HeaderText</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">LATV4 Recon available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText1</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">MAVs &amp; Boltes available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText2</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"UnspawnAllPlayers\"><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Last phase commences</field></block></value></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">3rd phase: 5 minutes</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">HeaderText</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">LATV4 Recon available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText1</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">MAVs &amp; Boltes available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText2</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"DisplayCustomNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Main Battle Tanks &amp; Nightbirds available</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"CustomMessagesItem\"><field name=\"VALUE-0\">CustomMessages</field><field name=\"VALUE-1\">MessageText3</field></block></value><value name=\"VALUE-2\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnGameModeStarted</field><statement name=\"ACTIONS\"><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"EmptyArray\"></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Specialis teamwork brings victory!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Use anti tank mines to block lanes!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Revive to keep up your numbers!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Hold down key positions!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Try out different vehicle loadouts!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Repair those vehicles!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Irish, lock down key positions!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Mackay, give us a height advantage!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Dozer, use your shield to push!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Boris, put turrets on those lanes!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Casper, spot those flanks!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Rao, hack those vehicles!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Paik, hightlight their position!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Falck, keep our healt up!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Angel, top us up!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Liz, keep pressure on their armour!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Sundance, blast them with your grenades!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Look up for sniping positions!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Insertion beacons give us an edge!</field></block></value></block></value></block></value><next><block type=\"SetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value><value name=\"VALUE-1\"><block type=\"AppendToArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value><value name=\"VALUE-1\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">Use smoke to cover our positioning!</field></block></value></block></value></block></value></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnPlayerIrreversiblyDead</field><statement name=\"ACTIONS\"><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"RandomValueInArray\"><value name=\"VALUE-0\"><block type=\"GetVariable\"><value name=\"VALUE-0\"><block type=\"variableReferenceBlock\"><mutation isObjectVar=\"false\"></mutation><field name=\"OBJECTTYPE\">Global</field><field name=\"VAR\" id=\"@?=3tY%]i*G8FiB!zskt\" variabletype=\"Global\">messages</field></block></value></block></value></block></value><value name=\"VALUE-1\"><block type=\"EventPlayer\"></block></value></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnGameModeStarted</field><statement name=\"ACTIONS\"><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">290</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">10 SECONDS UNTIL REDEPLOY!</field></block></value></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">10 SECONDS UNTIL REDEPLOY!</field></block></value></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">TIME IS ALMOST UP!</field></block></value></block></value></block></next></block></next></block></next></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"false\"></mutation><field name=\"NAME\">New Rule</field><field name=\"EVENTTYPE\">OnGameModeStarted</field><statement name=\"ACTIONS\"><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">240</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">LAST MINUTE OF PHASE 1 !</field></block></value></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">LAST MINUTE OF PHASE 2 !</field></block></value></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value><next><block type=\"ShowNotificationMessage\"><value name=\"VALUE-0\"><block type=\"Message\"><value name=\"VALUE-0\"><block type=\"Text\"><field name=\"TEXT\">FINAL MINUTE OF THE GAME!</field></block></value></block></value></block></next></block></next></block></next></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">MAV</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"IsVehicleOccupied\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"LessThan\"><value name=\"VALUE-0\"><block type=\"GetGameModeTimeElapsed\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehiclesItem\"><field name=\"VALUE-0\">Medium</field><field name=\"VALUE-1\">FNSS_ZAHA</field></block></value></block></value></block></next></block></next></block></statement><statement name=\"ACTIONS\"><block type=\"ForceExitAllPlayerInVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">3</field></block></value><next><block type=\"DestroyVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"IsVehicleOccupied\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"LessThan\"><value name=\"VALUE-0\"><block type=\"GetGameModeTimeElapsed\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">300</field></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehiclesItem\"><field name=\"VALUE-0\">Medium</field><field name=\"VALUE-1\">Bolte</field></block></value></block></value></block></next></block></next></block></statement><statement name=\"ACTIONS\"><block type=\"ForceExitAllPlayerInVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">3</field></block></value><next><block type=\"DestroyVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"IsVehicleOccupied\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"LessThan\"><value name=\"VALUE-0\"><block type=\"GetGameModeTimeElapsed\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">600</field></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehiclesItem\"><field name=\"VALUE-0\">Heavy</field><field name=\"VALUE-1\">M1_Abrams</field></block></value></block></value></block></next></block></next></block></statement><statement name=\"ACTIONS\"><block type=\"ForceExitAllPlayerInVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">3</field></block></value><next><block type=\"DestroyVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"IsVehicleOccupied\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"LessThan\"><value name=\"VALUE-0\"><block type=\"GetGameModeTimeElapsed\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">600</field></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehicleTypesItem\"><field name=\"VALUE-0\">VehicleTypes</field><field name=\"VALUE-1\">Heavy</field></block></value></block></value></block></next></block></next></block></statement><statement name=\"ACTIONS\"><block type=\"ForceExitAllPlayerInVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">3</field></block></value><next><block type=\"DestroyVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"IsVehicleOccupied\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"LessThan\"><value name=\"VALUE-0\"><block type=\"GetGameModeTimeElapsed\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">600</field></block></value></block></value><next><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehiclesItem\"><field name=\"VALUE-0\">Helicopter</field><field name=\"VALUE-1\">LittleBird</field></block></value></block></value></block></next></block></next></block></statement><statement name=\"ACTIONS\"><block type=\"ForceExitAllPlayerInVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><next><block type=\"Wait\"><value name=\"VALUE-0\"><block type=\"Number\"><field name=\"NUM\">3</field></block></value><next><block type=\"DestroyVehicle\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value></block></next></block></next></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5 buff</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehiclesItem\"><field name=\"VALUE-0\">Heavy</field><field name=\"VALUE-1\">M1_Abrams</field></block></value></block></value></block></statement><statement name=\"ACTIONS\"><block type=\"SetVehicleMaxHealthMultiplier\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">2</field></block></value></block></statement><next><block type=\"ruleBlock\"><mutation isOnGoingEvent=\"true\"></mutation><field name=\"NAME\">M1A5 buff</field><field name=\"EVENTTYPE\">Ongoing</field><field name=\"OBJECTTYPE\">Vehicle</field><statement name=\"CONDITIONS\"><block type=\"conditionBlock\"><value name=\"CONDITION\"><block type=\"CompareVehicleName\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"VehicleTypesItem\"><field name=\"VALUE-0\">VehicleTypes</field><field name=\"VALUE-1\">Heavy</field></block></value></block></value></block></statement><statement name=\"ACTIONS\"><block type=\"SetVehicleMaxHealthMultiplier\"><value name=\"VALUE-0\"><block type=\"EventVehicle\"></block></value><value name=\"VALUE-1\"><block type=\"Number\"><field name=\"NUM\">2</field></block></value></block></statement></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></next></block></statement></block></xml>","variables":"<variables xmlns=\"https://developers.google.com/blockly/xml\"><variable type=\"Global\" id=\"@?=3tY%]i*G8FiB!zskt\">messages</variable></variables>"}", + "rulesVersion": 1043927622, + "blueprintRulesVersion": 668966575 + } + }, + "assetCategories": [ + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AE9", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AE9" + ], + "teamId": 1 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AEA", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AEA" + ], + "teamId": 2 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AEB", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AEB" + ], + "teamId": 1 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AF8", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AF8" + ], + "teamId": 2 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AF5", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AF5" + ], + "teamId": 2 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AF6", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "6203AB24-874C-2B00-A6D1-CCA10E8F5AF6" + ], + "teamId": 1 + } + ] + } + }, + { + "tagId": "B0813C5F-D964-490D-9968-45288B92A079", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "B0813C5F-D964-490D-9968-45288B92A079" + ], + "teamId": 2 + } + ] + } + }, + { + "tagId": "1FF2096A-7BB4-45CE-BBC9-FDE4C9FFEABE", + "boolean": { + "defaultValue": true, + "teamOverrides": [ + { + "assetCategoryTags": [ + "1FF2096A-7BB4-45CE-BBC9-FDE4C9FFEABE" + ], + "teamId": 1 + } + ] + } + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AEC", + "boolean": {} + }, + { + "tagId": "6203AB24-874C-2B00-A6D1-CCA10E8F5AEE", + "boolean": {} + } + ], + "teamComposition": { + "teams": { + "teamId": 2, + "capacity": 32 + }, + "internalTeams": [ + { + "teamId": 1, + "capacity": 30 + }, + { + "teamId": 2, + "capacity": 30 + } + ] + } + }, + "tag": [ + { + "id": "kingston_era", + "metadata": { + "translations": [ + { + "kind": "6", + "translationId": "ID_ARRIVAL_SERVERTAG_KINGSTONERA" + }, + { + "kind": "7", + "translationId": "ID_ARRIVAL_SERVERTAG_KINGSTONERA_DESC" + } + ] + } + }, + { + "id": "custom_scripted", + "sortOrder": 1, + "metadata": { + "translations": [ + { + "kind": "6", + "translationId": "ID_ARRIVAL_SERVERTAG_CUSTOM_SCRIPTED" + }, + { + "kind": "7", + "translationId": "ID_ARRIVAL_SERVERTAG_CUSTOM_SCRIPTED_DESC" + } + ] + } + }, + { + "id": "mastery_restricted", + "sortOrder": 2, + "metadata": { + "translations": [ + { + "kind": "6", + "translationId": "ID_ARRIVAL_SERVERTAG_MASTERY_RESTRICTED" + }, + { + "kind": "7", + "translationId": "ID_ARRIVAL_SERVERTAG_MASTERY_RESTRICTED_DESC" + } + ] + } + }, + { + "id": "no_callins", + "sortOrder": 3, + "metadata": { + "translations": [ + { + "kind": "6", + "translationId": "ID_ARRIVAL_SERVERTAG_NO_CALLIN" + }, + { + "kind": "7", + "translationId": "ID_ARRIVAL_SERVERTAG_NO_CALLIN_DESC" + } + ] + } + }, + { + "id": "custom_vehicle_settings", + "sortOrder": 4, + "metadata": { + "translations": [ + { + "kind": "6", + "translationId": "ID_ARRIVAL_SERVERTAG_CUSTOM_VEHICLE_SETTINGS" + }, + { + "kind": "7", + "translationId": "ID_ARRIVAL_SERVERTAG_CUSTOM_VEHICLE_SETTINGS_DESC" + } + ] + } + }, + { + "id": "ai_enabled", + "sortOrder": 5, + "metadata": { + "translations": [ + { + "kind": "6", + "translationId": "ID_ARRIVAL_SERVERTAG_AI_ENABLED" + }, + { + "kind": "7", + "translationId": "ID_ARRIVAL_SERVERTAG_AI_ENABLED_DESC" + } + ] + } + }, + { + "id": "even_team_sizes", + "sortOrder": 6, + "metadata": { + "translations": [ + { + "kind": "6", + "translationId": "ID_ARRIVAL_SERVERTAG_EVEN_TEAM_SIZES" + }, + { + "kind": "7", + "translationId": "ID_ARRIVAL_SERVERTAG_EVEN_TEAM_SIZES_DESC" + } + ] + } + }, + { + "id": "sym_team_settings", + "sortOrder": 7, + "metadata": { + "translations": [ + { + "kind": "6", + "translationId": "ID_ARRIVAL_SERVERTAG_SYMMETRIC_TEAM_SETTINGS" + }, + { + "kind": "7", + "translationId": "ID_ARRIVAL_SERVERTAG_SYMMETRIC_TEAM_SETTINGS_DESC" + } + ] + } + }, + { + "id": "custom_spawning", + "sortOrder": 8, + "metadata": { + "translations": [ + { + "kind": "6", + "translationId": "ID_ARRIVAL_SERVERTAG_CUSTOM_SPAWN_SETTINGS" + }, + { + "kind": "7", + "translationId": "ID_ARRIVAL_SERVERTAG_CUSTOM_SPAWN_SETTINGS_DESC" + } + ] + } + } + ], + "progressionMode": { + "value": "portal-unranked" + } + } +} \ No newline at end of file diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..83d92c7 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,103 @@ +{ + "compilerOptions": { + /* Visit https://aka.ms/tsconfig to read more about this file */ + + /* Projects */ + // "incremental": true, /* Save .tsbuildinfo files to allow for incremental compilation of projects. */ + // "composite": true, /* Enable constraints that allow a TypeScript project to be used with project references. */ + // "tsBuildInfoFile": "./.tsbuildinfo", /* Specify the path to .tsbuildinfo incremental compilation file. */ + // "disableSourceOfProjectReferenceRedirect": true, /* Disable preferring source files instead of declaration files when referencing composite projects. */ + // "disableSolutionSearching": true, /* Opt a project out of multi-project reference checking when editing. */ + // "disableReferencedProjectLoad": true, /* Reduce the number of projects loaded automatically by TypeScript. */ + + /* Language and Environment */ + "target": "es2016", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */ + // "lib": [], /* Specify a set of bundled library declaration files that describe the target runtime environment. */ + // "jsx": "preserve", /* Specify what JSX code is generated. */ + // "experimentalDecorators": true, /* Enable experimental support for TC39 stage 2 draft decorators. */ + // "emitDecoratorMetadata": true, /* Emit design-type metadata for decorated declarations in source files. */ + // "jsxFactory": "", /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */ + // "jsxFragmentFactory": "", /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */ + // "jsxImportSource": "", /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */ + // "reactNamespace": "", /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */ + // "noLib": true, /* Disable including any library files, including the default lib.d.ts. */ + // "useDefineForClassFields": true, /* Emit ECMAScript-standard-compliant class fields. */ + // "moduleDetection": "auto", /* Control what method is used to detect module-format JS files. */ + + /* Modules */ + "module": "commonjs", /* Specify what module code is generated. */ + "rootDir": "./src", /* Specify the root folder within your source files. */ + // "moduleResolution": "node", /* Specify how TypeScript looks up a file from a given module specifier. */ + // "baseUrl": "./", /* Specify the base directory to resolve non-relative module names. */ + // "paths": {}, /* Specify a set of entries that re-map imports to additional lookup locations. */ + // "rootDirs": [], /* Allow multiple folders to be treated as one when resolving modules. */ + // "typeRoots": [], /* Specify multiple folders that act like './node_modules/@types'. */ + // "types": [], /* Specify type package names to be included without being referenced in a source file. */ + // "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */ + // "moduleSuffixes": [], /* List of file name suffixes to search when resolving a module. */ + // "resolveJsonModule": true, /* Enable importing .json files. */ + // "noResolve": true, /* Disallow 'import's, 'require's or ''s from expanding the number of files TypeScript should add to a project. */ + + /* JavaScript Support */ + // "allowJs": true, /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */ + // "checkJs": true, /* Enable error reporting in type-checked JavaScript files. */ + // "maxNodeModuleJsDepth": 1, /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */ + + /* Emit */ + // "declaration": true, /* Generate .d.ts files from TypeScript and JavaScript files in your project. */ + // "declarationMap": true, /* Create sourcemaps for d.ts files. */ + // "emitDeclarationOnly": true, /* Only output d.ts files and not JavaScript files. */ + "sourceMap": true, /* Create source map files for emitted JavaScript files. */ + // "outFile": "./", /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */ + "outDir": "./dist", /* Specify an output folder for all emitted files. */ + // "removeComments": true, /* Disable emitting comments. */ + // "noEmit": true, /* Disable emitting files from a compilation. */ + // "importHelpers": true, /* Allow importing helper functions from tslib once per project, instead of including them per-file. */ + // "importsNotUsedAsValues": "remove", /* Specify emit/checking behavior for imports that are only used for types. */ + // "downlevelIteration": true, /* Emit more compliant, but verbose and less performant JavaScript for iteration. */ + // "sourceRoot": "", /* Specify the root path for debuggers to find the reference source code. */ + // "mapRoot": "", /* Specify the location where debugger should locate map files instead of generated locations. */ + // "inlineSourceMap": true, /* Include sourcemap files inside the emitted JavaScript. */ + // "inlineSources": true, /* Include source code in the sourcemaps inside the emitted JavaScript. */ + // "emitBOM": true, /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */ + // "newLine": "crlf", /* Set the newline character for emitting files. */ + // "stripInternal": true, /* Disable emitting declarations that have '@internal' in their JSDoc comments. */ + // "noEmitHelpers": true, /* Disable generating custom helper functions like '__extends' in compiled output. */ + // "noEmitOnError": true, /* Disable emitting files if any type checking errors are reported. */ + // "preserveConstEnums": true, /* Disable erasing 'const enum' declarations in generated code. */ + // "declarationDir": "./", /* Specify the output directory for generated declaration files. */ + // "preserveValueImports": true, /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */ + + /* Interop Constraints */ + // "isolatedModules": true, /* Ensure that each file can be safely transpiled without relying on other imports. */ + // "allowSyntheticDefaultImports": true, /* Allow 'import x from y' when a module doesn't have a default export. */ + "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */ + // "preserveSymlinks": true, /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */ + "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */ + + /* Type Checking */ + "strict": true, /* Enable all strict type-checking options. */ + // "noImplicitAny": true, /* Enable error reporting for expressions and declarations with an implied 'any' type. */ + // "strictNullChecks": true, /* When type checking, take into account 'null' and 'undefined'. */ + // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ + // "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */ + // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ + // "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */ + // "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */ + // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ + // "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */ + // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */ + // "exactOptionalPropertyTypes": true, /* Interpret optional property types as written, rather than adding 'undefined'. */ + // "noImplicitReturns": true, /* Enable error reporting for codepaths that do not explicitly return in a function. */ + // "noFallthroughCasesInSwitch": true, /* Enable error reporting for fallthrough cases in switch statements. */ + // "noUncheckedIndexedAccess": true, /* Add 'undefined' to a type when accessed using an index. */ + // "noImplicitOverride": true, /* Ensure overriding members in derived classes are marked with an override modifier. */ + // "noPropertyAccessFromIndexSignature": true, /* Enforces using indexed accessors for keys declared using an indexed type. */ + // "allowUnusedLabels": true, /* Disable error reporting for unused labels. */ + // "allowUnreachableCode": true, /* Disable error reporting for unreachable code. */ + + /* Completeness */ + // "skipDefaultLibCheck": true, /* Skip type checking .d.ts files that are included with TypeScript. */ + "skipLibCheck": true /* Skip type checking all .d.ts files. */ + } +}