From 9842f533968dec5afd8af1d7ecbafc614db28aa9 Mon Sep 17 00:00:00 2001 From: feywind <57276408+feywind@users.noreply.github.com> Date: Fri, 7 Aug 2026 12:42:06 -0400 Subject: [PATCH] feat: resumable upload support for node --- .../pubsub-api-dump-esm/api.json.baseline | 3 + .../pubsub-api-dump/api.json.baseline | 3 + .../.OwlBot.yaml.baseline | 19 + .../.babelrc.json.baseline | 19 + .../resumable-upload-esm/.gitignore.baseline | 15 + .../resumable-upload-esm/.jsdoc.cjs.baseline | 54 + .../resumable-upload-esm/.nycrc.baseline | 24 + .../resumable-upload-esm/README.md.baseline | 108 + .../esm/src/index.ts.baseline | 26 + .../esm/src/json-helper.cjs.baseline | 20 + .../esm/src/v1/index.ts.baseline | 19 + ...esumable_upload_service_client.ts.baseline | 598 ++ ...upload_service_client_config.json.baseline | 34 + ...le_upload_service_proto_list.json.baseline | 3 + .../fixtures/sample/src/index.cjs.baseline | 27 + .../fixtures/sample/src/index.js.baseline | 27 + .../fixtures/sample/src/index.ts.baseline | 35 + .../esm/system-test/install.ts.baseline | 60 + ...ic_resumable_upload_service_v1.ts.baseline | 419 + .../resumable-upload-esm/package.json | 108 + .../package.json.baseline | 1 + .../google/api/media_upload.proto.baseline | 63 + .../resumable/v1/resumable.proto.baseline | 78 + ...ervice.create_resumable_upload.js.baseline | 68 + ...load_service.get_upload_status.js.baseline | 59 + .../tsconfig.esm.json.baseline | 27 + .../tsconfig.json.baseline | 32 + .../webpack.config.cjs.baseline | 64 + .../resumable-upload/.OwlBot.yaml.baseline | 19 + .../resumable-upload/.gitignore.baseline | 14 + .../resumable-upload/.jsdoc.js.baseline | 55 + .../resumable-upload/.nycrc.baseline | 24 + .../resumable-upload/README.md.baseline | 108 + .../baselines/resumable-upload/package.json | 64 + .../resumable-upload/package.json.baseline | 1 + .../google/api/media_upload.proto.baseline | 63 + .../resumable/v1/resumable.proto.baseline | 78 + ...ervice.create_resumable_upload.js.baseline | 68 + ...load_service.get_upload_status.js.baseline | 59 + .../resumable-upload/src/index.ts.baseline | 25 + .../resumable-upload/src/v1/index.ts.baseline | 19 + ...esumable_upload_service_client.ts.baseline | 576 ++ ...upload_service_client_config.json.baseline | 34 + ...le_upload_service_proto_list.json.baseline | 3 + .../fixtures/sample/src/index.js.baseline | 27 + .../fixtures/sample/src/index.ts.baseline | 34 + .../system-test/install.ts.baseline | 51 + ...ic_resumable_upload_service_v1.ts.baseline | 408 + .../resumable-upload/tsconfig.json.baseline | 22 + .../webpack.config.js.baseline | 64 + .../gapic-generator-typescript/package.json | 4 +- .../protos/google/api/media_upload.proto | 63 + .../protos/index.d.ts | 136 + .../protos/index.js | 7139 ++++++++++++----- .../protos/protos.json | 95 +- .../src/$version/$service_client.ts.njk | 95 +- .../$version/$service.$method.js.njk | 13 +- .../esm/src/$version/$service_client.ts.njk | 95 +- .../$version/$service.$method.js.njk | 13 +- .../protos/google/api/media_upload.proto | 63 + .../samples/resumable/v1/resumable.proto | 78 + .../typescript/src/schema/proto.ts | 33 +- .../typescript/test/unit/baselines-esm.ts | 7 + .../typescript/test/unit/baselines.ts | 6 + .../typescript/test/unit/proto.ts | 97 + core/packages/gax/client-libraries.md | 42 + core/packages/gax/src/clientInterface.ts | 2 + core/packages/gax/src/descriptor.ts | 1 + core/packages/gax/src/fallback.ts | 2 + core/packages/gax/src/gax.ts | 14 + core/packages/gax/src/index.ts | 11 + core/packages/gax/src/resumableUpload.ts | 1258 +++ .../gax/test/system-test/resumableUpload.ts | 277 + .../packages/gax/test/unit/resumableUpload.ts | 792 ++ 74 files changed, 11986 insertions(+), 2179 deletions(-) create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.OwlBot.yaml.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.babelrc.json.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.gitignore.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.jsdoc.cjs.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.nycrc.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/README.md.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/index.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/json-helper.cjs.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/index.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_client.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_client_config.json.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_proto_list.json.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.cjs.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.js.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/install.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/test/gapic_resumable_upload_service_v1.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/package.json create mode 120000 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/package.json.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/protos/google/api/media_upload.proto.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/protos/google/samples/resumable/v1/resumable.proto.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/samples/generated/v1/resumable_upload_service.create_resumable_upload.js.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/samples/generated/v1/resumable_upload_service.get_upload_status.js.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/tsconfig.esm.json.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/tsconfig.json.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/webpack.config.cjs.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/.OwlBot.yaml.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/.gitignore.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/.jsdoc.js.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/.nycrc.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/README.md.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/package.json create mode 120000 core/generator/gapic-generator-typescript/baselines/resumable-upload/package.json.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/protos/google/api/media_upload.proto.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/protos/google/samples/resumable/v1/resumable.proto.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/samples/generated/v1/resumable_upload_service.create_resumable_upload.js.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/samples/generated/v1/resumable_upload_service.get_upload_status.js.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/src/index.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/index.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_client.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_client_config.json.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_proto_list.json.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/fixtures/sample/src/index.js.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/fixtures/sample/src/index.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/install.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/test/gapic_resumable_upload_service_v1.ts.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/tsconfig.json.baseline create mode 100644 core/generator/gapic-generator-typescript/baselines/resumable-upload/webpack.config.js.baseline create mode 100644 core/generator/gapic-generator-typescript/protos/google/api/media_upload.proto create mode 100644 core/generator/gapic-generator-typescript/test-fixtures/protos/google/api/media_upload.proto create mode 100644 core/generator/gapic-generator-typescript/test-fixtures/protos/google/samples/resumable/v1/resumable.proto create mode 100644 core/packages/gax/src/resumableUpload.ts create mode 100644 core/packages/gax/test/system-test/resumableUpload.ts create mode 100644 core/packages/gax/test/unit/resumableUpload.ts diff --git a/core/generator/gapic-generator-typescript/baselines/pubsub-api-dump-esm/api.json.baseline b/core/generator/gapic-generator-typescript/baselines/pubsub-api-dump-esm/api.json.baseline index 22b35ea23025..3bb822ccd445 100644 --- a/core/generator/gapic-generator-typescript/baselines/pubsub-api-dump-esm/api.json.baseline +++ b/core/generator/gapic-generator-typescript/baselines/pubsub-api-dump-esm/api.json.baseline @@ -4825,6 +4825,7 @@ ] } ], + "resumableUploads": [], "longRunning": [], "diregapicLRO": [], "streaming": [], @@ -9692,6 +9693,7 @@ ] } ], + "resumableUploads": [], "longRunning": [], "diregapicLRO": [], "streaming": [], @@ -15858,6 +15860,7 @@ ] } ], + "resumableUploads": [], "longRunning": [], "diregapicLRO": [], "streaming": [ diff --git a/core/generator/gapic-generator-typescript/baselines/pubsub-api-dump/api.json.baseline b/core/generator/gapic-generator-typescript/baselines/pubsub-api-dump/api.json.baseline index 22b35ea23025..3bb822ccd445 100644 --- a/core/generator/gapic-generator-typescript/baselines/pubsub-api-dump/api.json.baseline +++ b/core/generator/gapic-generator-typescript/baselines/pubsub-api-dump/api.json.baseline @@ -4825,6 +4825,7 @@ ] } ], + "resumableUploads": [], "longRunning": [], "diregapicLRO": [], "streaming": [], @@ -9692,6 +9693,7 @@ ] } ], + "resumableUploads": [], "longRunning": [], "diregapicLRO": [], "streaming": [], @@ -15858,6 +15860,7 @@ ] } ], + "resumableUploads": [], "longRunning": [], "diregapicLRO": [], "streaming": [ diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.OwlBot.yaml.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.OwlBot.yaml.baseline new file mode 100644 index 000000000000..7feea79e8531 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.OwlBot.yaml.baseline @@ -0,0 +1,19 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +deep-copy-regex: + - source: /google/samples/resumable/google-samples-resumable-nodejs + dest: /owl-bot-staging/google-samples-resumable + +api-name: resumable \ No newline at end of file diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.babelrc.json.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.babelrc.json.baseline new file mode 100644 index 000000000000..940d91b0a07b --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.babelrc.json.baseline @@ -0,0 +1,19 @@ +{ + "presets": [ + "@babel/preset-typescript", + "@babel/env" + ], + "plugins": [ + [ + "replace-import-extension", + { + "extMapping": { + ".js": ".cjs" + } + } + ], + "./node_modules/gapic-tools/build/src/replaceESMMockingLib.js", + "./node_modules/gapic-tools/build/src/replaceImportMetaUrl.js", + "./node_modules/gapic-tools/build/src/toggleESMFlagVariable.js" + ] +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.gitignore.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.gitignore.baseline new file mode 100644 index 000000000000..b391f5f9cd1a --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.gitignore.baseline @@ -0,0 +1,15 @@ +**/*.log +**/node_modules +/.coverage +/coverage +/.nyc_output +/docs/ +/out/ +/build/ +system-test/secrets.js +system-test/*key.json +*.lock +.DS_Store +package-lock.json +__pycache__ +esm/**/*.d.ts \ No newline at end of file diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.jsdoc.cjs.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.jsdoc.cjs.baseline new file mode 100644 index 000000000000..de732583739e --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.jsdoc.cjs.baseline @@ -0,0 +1,54 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + + +module.exports = { + opts: { + readme: './README.md', + package: './package.json', + template: './node_modules/jsdoc-fresh', + recurse: true, + verbose: true, + destination: './docs/' + }, + plugins: [ + 'plugins/markdown', + 'jsdoc-region-tag' + ], + source: { + excludePattern: '(^|\\/|\\\\)[._]', + include: [ + 'build/src', + 'protos' + ], + includePattern: '\\.js$' + }, + templates: { + copyright: 'Copyright 2026 Google LLC', + includeDate: false, + sourceFiles: false, + systemName: 'resumable', + theme: 'lumen', + default: { + outputSourceFiles: false + } + }, + markdown: { + idInHeadings: true + } +}; diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.nycrc.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.nycrc.baseline new file mode 100644 index 000000000000..81a95fc94b00 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/.nycrc.baseline @@ -0,0 +1,24 @@ +{ + "report-dir": "./.coverage", + "reporter": ["text", "lcov"], + "exclude": [ + "**/*-test", + "**/.coverage", + "**/apis", + "**/benchmark", + "**/conformance", + "**/docs", + "**/samples", + "**/scripts", + "**/protos", + "**/test", + "**/*.d.ts", + ".jsdoc.js", + "**/.jsdoc.js", + "karma.conf.js", + "webpack-tests.config.js", + "webpack.config.js" + ], + "exclude-after-remap": false, + "all": true +} \ No newline at end of file diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/README.md.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/README.md.baseline new file mode 100644 index 000000000000..582e319d972b --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/README.md.baseline @@ -0,0 +1,108 @@ +[//]: # "This README.md file is auto-generated, all changes to this file will be lost." +[//]: # "The comments you see below are used to generate those parts of the template in later states." +Google Cloud Platform logo + +# [Resumable: Nodejs Client][homepage] + +[//]: # "releaseLevel" + +[![npm version](https://img.shields.io/npm/v/resumable.svg)](https://www.npmjs.org/package/resumable) + +Resumable client for Node.js + +[//]: # "partials.introduction" + +A comprehensive list of changes in each version may be found in +[the CHANGELOG][homepage_changelog]. + +* [Resumable Nodejs Client API Reference](https://cloud.google.com/nodejs/docs/reference/resumable/latest) + + +Read more about the client libraries for Cloud APIs, including the older +Google APIs Client Libraries, in [Client Libraries Explained][explained]. + +[explained]: https://cloud.google.com/apis/docs/client-libraries-explained + +**Table of contents:** + +* [Quickstart](#quickstart) + * [Before you begin](#before-you-begin) + * [Installing the client library](#installing-the-client-library) + +* [Versioning](#versioning) +* [Contributing](#contributing) +* [License](#license) + +## Quickstart +### Before you begin + +1. [Select or create a Cloud Platform project][projects]. +1. [Enable billing for your project][billing]. +1. [Enable the Resumable API][enable_api]. +1. [Set up authentication][auth] so you can access the + API from your local workstation. +### Installing the client library + +```bash +npm install resumable +``` + +[//]: # "partials.body" + +## Samples + +Samples are in the [`samples/`][homepage_samples] directory. Each sample's `README.md` has instructions for running its sample. + +[//]: # "samples" + +## Supported Node.js Versions + +Our client libraries follow the [Node.js release schedule](https://github.com/nodejs/release#release-schedule). +Libraries are compatible with all current _active_ and _maintenance_ versions of +Node.js. +If you are using an end-of-life version of Node.js, we recommend that you update +as soon as possible to an actively supported LTS version. + +Google's client libraries support legacy versions of Node.js runtimes on a +best-efforts basis with the following warnings: + +* Legacy versions are not tested in continuous integration. +* Some security patches and features cannot be backported. +* Dependencies cannot be kept up-to-date. + +Client libraries targeting some end-of-life versions of Node.js are available, and +can be installed through npm [dist-tags](https://docs.npmjs.com/cli/dist-tag). +The dist-tags follow the naming convention `legacy-(version)`. +For example, `npm install resumable@legacy-8` installs client libraries +for versions compatible with Node.js 8. + +## Versioning + +This library follows [Semantic Versioning](http://semver.org/). + +More Information: [Google Cloud Platform Launch Stages][launch_stages] + +[launch_stages]: https://cloud.google.com/terms/launch-stages + +## Contributing + +Contributions welcome! See the [Contributing Guide](https://github.com/googleapis/google-cloud-node/blob/main/CONTRIBUTING.md). + +Please note that this `README.md` +and a variety of configuration files in this repository (including `.nycrc` and `tsconfig.json`) +are generated from a central template. + +## License + +Apache Version 2.0 + +See [LICENSE](https://github.com/googleapis/google-cloud-node/blob/main/LICENSE) + +[shell_img]: https://gstatic.com/cloudssh/images/open-btn.png +[projects]: https://console.cloud.google.com/project +[billing]: https://support.google.com/cloud/answer/6293499#enable-billing +[enable_api]: https://console.cloud.google.com/flows/enableapi?apiid=resumable.googleapis.com +[auth]: https://cloud.google.com/docs/authentication/external/set-up-adc-local +[homepage_samples]: https://github.com/googleapis/google-cloud-node/blob/main/packages/google-samples-resumable/samples +[homepage_changelog]: https://github.com/googleapis/google-cloud-node/blob/main/packages/google-samples-resumable/CHANGELOG.md +[homepage]: https://github.com/googleapis/google-cloud-node/blob/main/packages/google-samples-resumable diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/index.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/index.ts.baseline new file mode 100644 index 000000000000..d3c955f9f441 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/index.ts.baseline @@ -0,0 +1,26 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +import * as v1 from './v1/index.js'; +const ResumableUploadServiceClient = v1.ResumableUploadServiceClient; +type ResumableUploadServiceClient = v1.ResumableUploadServiceClient; +export { v1, ResumableUploadServiceClient }; +export default { v1, ResumableUploadServiceClient }; +// @ts-ignore +import * as protos from '../../protos/protos.js'; +export { protos }; diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/json-helper.cjs.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/json-helper.cjs.baseline new file mode 100644 index 000000000000..3c1fc730201e --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/json-helper.cjs.baseline @@ -0,0 +1,20 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* eslint-disable node/no-missing-require */ +function getJSON(path) { + return require(path); +} + +exports.getJSON = getJSON; diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/index.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/index.ts.baseline new file mode 100644 index 000000000000..bb9ae6574953 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/index.ts.baseline @@ -0,0 +1,19 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +export { ResumableUploadServiceClient } from './resumable_upload_service_client.js'; diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_client.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_client.ts.baseline new file mode 100644 index 000000000000..6b25fad1969f --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_client.ts.baseline @@ -0,0 +1,598 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +/* global window */ +import * as gax from 'google-gax'; +import type { + Callback, + CallOptions, + Descriptors, + ClientOptions, +} from 'google-gax'; + +// @ts-ignore +import type * as protos from '../../../protos/protos.js'; +import * as resumable_upload_service_client_config from './resumable_upload_service_client_config.json'; +import fs from 'fs'; +import path from 'path'; +import { fileURLToPath } from 'url'; +import { getJSON } from '../json-helper.cjs'; +// @ts-ignore +const dirname = path.dirname(fileURLToPath(import.meta.url)); + +/** + * Client JSON configuration object, loaded from + * `src/v1/resumable_upload_service_client_config.json`. + * This file defines retry strategy and timeouts for all API methods in this library. + */ +const gapicConfig = getJSON( + path.join(dirname, 'resumable_upload_service_client_config.json'), +); + +const jsonProtos = getJSON( + path.join(dirname, '..', '..', '..', 'protos/protos.json'), +); +import { loggingUtils as logging, decodeAnyProtosInArray } from 'google-gax'; +const version = getJSON( + path.join(dirname, '..', '..', '..', '..', 'package.json'), +).version; + +/** + * @class + * @memberof v1 + */ +export class ResumableUploadServiceClient { + private _terminated = false; + private _opts: ClientOptions; + private _providedCustomServicePath: boolean; + private _gaxModule: typeof gax | typeof gax.fallback; + private _gaxGrpc: gax.GrpcClient | gax.fallback.GrpcClient; + private _fallbackRest?: gax.GrpcClient | gax.fallback.GrpcClient; + private _protos: {}; + private _defaults: { [method: string]: gax.CallSettings }; + private _universeDomain: string; + private _servicePath: string; + private _log = logging.log('resumable'); + auth: gax.GoogleAuth; + descriptors: Descriptors = { + page: {}, + stream: {}, + longrunning: {}, + batching: {}, + resumableUpload: {}, + }; + warn: (code: string, message: string, warnType?: string) => void; + innerApiCalls: { [name: string]: Function }; + resumableUploadServiceStub?: Promise<{ [name: string]: Function }>; + + /** + * Construct an instance of ResumableUploadServiceClient. + * + * @param {object} [options] - The configuration object. + * The options accepted by the constructor are described in detail + * in [this document](https://github.com/googleapis/gax-nodejs/blob/main/client-libraries.md#creating-the-client-instance). + * The common options are: + * @param {object} [options.credentials] - Credentials object. + * @param {string} [options.credentials.client_email] + * @param {string} [options.credentials.private_key] + * @param {string} [options.email] - Account email address. Required when + * using a .pem or .p12 keyFilename. + * @param {string} [options.keyFilename] - Full path to the a .json, .pem, or + * .p12 key downloaded from the Google Developers Console. If you provide + * a path to a JSON file, the projectId option below is not necessary. + * NOTE: .pem and .p12 require you to specify options.email as well. + * @param {number} [options.port] - The port on which to connect to + * the remote host. + * @param {string} [options.projectId] - The project ID from the Google + * Developer's Console, e.g. 'grape-spaceship-123'. We will also check + * the environment variable GCLOUD_PROJECT for your project ID. If your + * app is running in an environment which supports + * {@link https://cloud.google.com/docs/authentication/application-default-credentials Application Default Credentials}, + * your project ID will be detected automatically. + * @param {string} [options.apiEndpoint] - The domain name of the + * API remote host. + * @param {gax.ClientConfig} [options.clientConfig] - Client configuration override. + * Follows the structure of {@link gapicConfig}. + * @param {boolean | "rest"} [options.fallback] - Use HTTP fallback mode. + * Pass "rest" to use HTTP/1.1 REST API instead of gRPC. + * For more information, please check the + * {@link https://github.com/googleapis/gax-nodejs/blob/main/client-libraries.md#http11-rest-api-mode documentation}. + * @param {gax} [gaxInstance]: loaded instance of `google-gax`. Useful if you + * need to avoid loading the default gRPC version and want to use the fallback + * HTTP implementation. Load only fallback version and pass it to the constructor: + * ``` + * const gax = require('google-gax/build/src/fallback'); // avoids loading google-gax with gRPC + * const client = new ResumableUploadServiceClient({fallback: 'rest'}, gax); + * ``` + */ + constructor( + opts?: ClientOptions, + gaxInstance?: typeof gax | typeof gax.fallback, + ) { + // Ensure that options include all the required fields. + const staticMembers = this + .constructor as typeof ResumableUploadServiceClient; + if ( + opts?.universe_domain && + opts?.universeDomain && + opts?.universe_domain !== opts?.universeDomain + ) { + throw new Error( + 'Please set either universe_domain or universeDomain, but not both.', + ); + } + const universeDomainEnvVar = + typeof process === 'object' && typeof process.env === 'object' + ? process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN'] + : undefined; + this._universeDomain = + opts?.universeDomain ?? + opts?.universe_domain ?? + universeDomainEnvVar ?? + 'googleapis.com'; + this._servicePath = 'resumable.' + this._universeDomain; + const servicePath = + opts?.servicePath || opts?.apiEndpoint || this._servicePath; + this._providedCustomServicePath = !!( + opts?.servicePath || opts?.apiEndpoint + ); + const port = opts?.port || staticMembers.port; + const clientConfig = opts?.clientConfig ?? {}; + const fallback = + opts?.fallback ?? + (typeof window !== 'undefined' && typeof window?.fetch === 'function'); + opts = Object.assign({ servicePath, port, clientConfig, fallback }, opts); + + // If scopes are unset in options and we're connecting to a non-default endpoint, set scopes just in case. + if (servicePath !== this._servicePath && !('scopes' in opts)) { + opts['scopes'] = staticMembers.scopes; + } + + // Load google-gax module synchronously if needed + if (!gaxInstance) { + gaxInstance = gax as typeof gax; + } + + // Choose either gRPC or proto-over-HTTP implementation of google-gax. + this._gaxModule = opts.fallback ? gaxInstance.fallback : gaxInstance; + + // Create a `gaxGrpc` object, with any grpc-specific options sent to the client. + this._gaxGrpc = new this._gaxModule.GrpcClient(opts); + + // This service contains resumable upload methods, which are HTTPS-only. + // Make sure the REST transport is available even when the client was + // configured for gRPC. + this._fallbackRest = opts.fallback + ? this._gaxGrpc + : new gaxInstance.fallback.GrpcClient({ ...opts, fallback: true }); + + // Save options to use in initialize() method. + this._opts = opts; + + // Save the auth object to the client, for use by other methods. + this.auth = this._gaxGrpc.auth as gax.GoogleAuth; + + // Set useJWTAccessWithScope on the auth object. + this.auth.useJWTAccessWithScope = true; + + // Set defaultServicePath on the auth object. + this.auth.defaultServicePath = this._servicePath; + + // Set the default scopes in auth client if needed. + if (servicePath === this._servicePath) { + this.auth.defaultScopes = staticMembers.scopes; + } + + // Add ESM headers + const isEsm = true; + const isEsmString = isEsm ? '-esm' : '-cjs'; + // Determine the client header string. + const clientHeader = [`gax/${this._gaxModule.version}`, `gapic/${version}`]; + if (typeof process === 'object' && 'versions' in process) { + clientHeader.push(`gl-node/{process.versions.node}${isEsmString}`); + } else { + clientHeader.push(`gl-web/${this._gaxModule.version}`); + } + if (!opts.fallback) { + clientHeader.push(`grpc/${this._gaxGrpc.grpcVersion}`); + } else if (opts.fallback === 'rest') { + clientHeader.push(`rest/${this._gaxGrpc.grpcVersion}`); + } + if (opts.libName && opts.libVersion) { + clientHeader.push(`${opts.libName}/${opts.libVersion}`); + } + + // Load the applicable protos. + this._protos = this._gaxGrpc.loadProtoJSON( + jsonProtos as gax.protobuf.INamespace, + ); + + // Some methods on this API support resumable uploads; provide + // descriptors for these methods. + this.descriptors.resumableUpload = { + createResumableUpload: new this._gaxModule.ResumableUploadDescriptor( + '/resumable/upload', + ), + }; + + // Put together the default options sent with requests. + this._defaults = this._gaxGrpc.constructSettings( + 'google.samples.resumable.v1.ResumableUploadService', + gapicConfig as gax.ClientConfig, + opts.clientConfig || {}, + { 'x-goog-api-client': clientHeader.join(' ') }, + ); + + // Set up a dictionary of "inner API calls"; the core implementation + // of calling the API is handled in `google-gax`, with this code + // merely providing the destination and request information. + this.innerApiCalls = {}; + + // Add a warn function to the client constructor so it can be easily tested. + this.warn = this._gaxModule.warn; + } + + /** + * Initialize the client. + * Performs asynchronous operations (such as authentication) and prepares the client. + * This function will be called automatically when any class method is called for the + * first time, but if you need to initialize it before calling an actual method, + * feel free to call initialize() directly. + * + * You can await on this method if you want to make sure the client is initialized. + * + * @returns {Promise} A promise that resolves to an authenticated service stub. + */ + initialize() { + // If the client stub promise is already initialized, return immediately. + if (this.resumableUploadServiceStub) { + return this.resumableUploadServiceStub; + } + + // Put together the "service stub" for + // google.samples.resumable.v1.ResumableUploadService. + this.resumableUploadServiceStub = this._gaxGrpc.createStub( + this._opts.fallback + ? (this._protos as protobuf.Root).lookupService( + 'google.samples.resumable.v1.ResumableUploadService', + ) + : // eslint-disable-next-line @typescript-eslint/no-explicit-any + (this._protos as any).google.samples.resumable.v1 + .ResumableUploadService, + this._opts, + this._providedCustomServicePath, + ) as Promise<{ [method: string]: Function }>; + + // Iterate over each of the methods that the service provides + // and create an API call method for each. + const resumableUploadServiceStubMethods = ['getUploadStatus']; + for (const methodName of resumableUploadServiceStubMethods) { + const callPromise = this.resumableUploadServiceStub.then( + (stub) => + (...args: Array<{}>) => { + if (this._terminated) { + return Promise.reject('The client has already been closed.'); + } + const func = stub[methodName]; + return func.apply(stub, args); + }, + (err: Error | null | undefined) => () => { + throw err; + }, + ); + + const descriptor = undefined; + const apiCall = this._gaxModule.createApiCall( + callPromise, + this._defaults[methodName], + descriptor, + this._opts.fallback, + ); + + this.innerApiCalls[methodName] = apiCall; + } + + // Resumable upload methods do not use the gRPC/REST service stub; the + // ResumableUpload helper performs its own HTTP requests. + this.innerApiCalls['createResumableUpload'] = this._gaxModule.createApiCall( + this._gaxModule.resumableUploadStub, + this._defaults['createResumableUpload'], + this.descriptors.resumableUpload['createResumableUpload'], + this._opts.fallback, + ); + + return this.resumableUploadServiceStub; + } + + /** + * The DNS address for this API service. + * @deprecated Use the apiEndpoint method of the client instance. + * @returns {string} The DNS address for this service. + */ + static get servicePath() { + if ( + typeof process === 'object' && + typeof process.emitWarning === 'function' + ) { + process.emitWarning( + 'Static servicePath is deprecated, please use the instance method instead.', + 'DeprecationWarning', + ); + } + return 'resumable.googleapis.com'; + } + + /** + * The DNS address for this API service - same as servicePath, + * exists for compatibility reasons. + * @deprecated Use the apiEndpoint method of the client instance. + * @returns {string} The DNS address for this service. + */ + static get apiEndpoint() { + if ( + typeof process === 'object' && + typeof process.emitWarning === 'function' + ) { + process.emitWarning( + 'Static apiEndpoint is deprecated, please use the instance method instead.', + 'DeprecationWarning', + ); + } + return 'resumable.googleapis.com'; + } + + /** + * The DNS address for this API service. + * @returns {string} The DNS address for this service. + */ + get apiEndpoint() { + return this._servicePath; + } + + get universeDomain() { + return this._universeDomain; + } + + /** + * The port for this API service. + * @returns {number} The default port for this service. + */ + static get port() { + return 443; + } + + /** + * The scopes needed to make gRPC calls for every method defined + * in this service. + * @returns {string[]} List of default scopes. + */ + static get scopes() { + return ['https://www.googleapis.com/auth/cloud-platform']; + } + + getProjectId(): Promise; + getProjectId(callback: Callback): void; + /** + * Return the project ID used by this class. + * @returns {Promise} A promise that resolves to string containing the project ID. + */ + getProjectId( + callback?: Callback, + ): Promise | void { + if (callback) { + this.auth.getProjectId(callback); + return; + } + return this.auth.getProjectId(); + } + + // ------------------- + // -- Service calls -- + // ------------------- + /** + * Returns the status of a previously created upload session. + * + * @param {Object} request + * The request object that will be sent. + * @param {string} request.uploadUrl + * @param {object} [options] + * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. + * @returns {Promise} - The promise which resolves to an array. + * The first element of the array is an object representing {@link protos.google.samples.resumable.v1.GetUploadStatusResponse|GetUploadStatusResponse}. + * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation } + * for more details and examples. + * @example include:samples/generated/v1/resumable_upload_service.get_upload_status.js + * region_tag:resumable_v1_generated_ResumableUploadService_GetUploadStatus_async + */ + getUploadStatus( + request?: protos.google.samples.resumable.v1.IGetUploadStatusRequest, + options?: CallOptions, + ): Promise< + [ + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + protos.google.samples.resumable.v1.IGetUploadStatusRequest | undefined, + {} | undefined, + ] + >; + getUploadStatus( + request: protos.google.samples.resumable.v1.IGetUploadStatusRequest, + options: CallOptions, + callback: Callback< + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | null + | undefined, + {} | null | undefined + >, + ): void; + getUploadStatus( + request: protos.google.samples.resumable.v1.IGetUploadStatusRequest, + callback: Callback< + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | null + | undefined, + {} | null | undefined + >, + ): void; + getUploadStatus( + request?: protos.google.samples.resumable.v1.IGetUploadStatusRequest, + optionsOrCallback?: + | CallOptions + | Callback< + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | null + | undefined, + {} | null | undefined + >, + callback?: Callback< + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | null + | undefined, + {} | null | undefined + >, + ): Promise< + [ + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + protos.google.samples.resumable.v1.IGetUploadStatusRequest | undefined, + {} | undefined, + ] + > | void { + request = request || {}; + let options: CallOptions; + if (typeof optionsOrCallback === 'function' && callback === undefined) { + callback = optionsOrCallback; + options = {}; + } else { + options = optionsOrCallback as CallOptions; + } + options = options || {}; + options.otherArgs = options.otherArgs || {}; + options.otherArgs.headers = options.otherArgs.headers || {}; + options.otherArgs.headers['x-goog-request-params'] = + this._gaxModule.routingHeader.fromParams({ + upload_url: request.uploadUrl ?? '', + }); + this.initialize().catch((err) => { + throw err; + }); + this._log.info('getUploadStatus request %j', request); + const wrappedCallback: + | Callback< + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | null + | undefined, + {} | null | undefined + > + | undefined = callback + ? (error, response, options, rawResponse) => { + this._log.info('getUploadStatus response %j', response); + callback!(error, response, options, rawResponse); + } + : undefined; + return this.innerApiCalls + .getUploadStatus(request, options, wrappedCallback) + ?.then( + ([response, options, rawResponse]: [ + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + ( + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | undefined + ), + {} | undefined, + ]) => { + this._log.info('getUploadStatus response %j', response); + return [response, options, rawResponse]; + }, + ) + .catch((error: any) => { + if ( + error && + 'statusDetails' in error && + error.statusDetails instanceof Array + ) { + const protos = this._gaxModule.protobuf.Root.fromJSON( + jsonProtos, + ) as unknown as gax.protobuf.Type; + error.statusDetails = decodeAnyProtosInArray( + error.statusDetails, + protos, + ); + } + throw error; + }); + } + /** + * Creates a resumable upload session. + * + * @param {object} [request] - The request object. + * @param {object} [options] - Optional parameters. The upload stream, + * chunk size, progress callback, and resume URL are passed to + * {@link gax.ResumableUpload#start} instead. + * @returns {Promise} A resumable upload helper. Call + * `.start(uploadParams)` with the stream to upload, then await + * `.finished()` for the final RPC response. + */ + createResumableUpload( + request?: protos.google.samples.resumable.v1.ICreateResumableUploadRequest, + options?: CallOptions, + ): Promise { + request = request || {}; + options = options || {}; + this.initialize().catch((err) => { + throw err; + }); + this._log.info('createResumableUpload request %j', request); + return this.innerApiCalls['createResumableUpload'](request, { + ...options, + resumableUpload: { + auth: this._fallbackRest!.auth as gax.GoogleAuth, + servicePath: this._opts.servicePath ?? this._servicePath, + servicePort: this._opts.port || 443, + protocol: this._opts.protocol || 'https', + rpc: this._gaxModule.protobuf.Root.fromJSON(jsonProtos).lookupService( + 'google.samples.resumable.v1.ResumableUploadService', + ).methods['CreateResumableUpload'], + request, + uploadPrefix: '/resumable/upload', + numericEnums: this._opts.numericEnums, + minifyJson: this._opts.minifyJson, + }, + }).then(([helper]) => helper); + } + + /** + * Terminate the gRPC channel and close the client. + * + * The client will no longer be usable and all future behavior is undefined. + * @returns {Promise} A promise that resolves when the client is closed. + */ + close(): Promise { + if (this.resumableUploadServiceStub && !this._terminated) { + return this.resumableUploadServiceStub.then((stub) => { + this._log.info('ending gRPC channel'); + this._terminated = true; + stub.close(); + }); + } + return Promise.resolve(); + } +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_client_config.json.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_client_config.json.baseline new file mode 100644 index 000000000000..de3f9fed6441 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_client_config.json.baseline @@ -0,0 +1,34 @@ +{ + "interfaces": { + "google.samples.resumable.v1.ResumableUploadService": { + "retry_codes": { + "non_idempotent": [], + "idempotent": [ + "DEADLINE_EXCEEDED", + "UNAVAILABLE" + ] + }, + "retry_params": { + "default": { + "initial_retry_delay_millis": 100, + "retry_delay_multiplier": 1.3, + "max_retry_delay_millis": 60000, + "initial_rpc_timeout_millis": 60000, + "rpc_timeout_multiplier": 1, + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 600000 + } + }, + "methods": { + "CreateResumableUpload": { + "retry_codes_name": "non_idempotent", + "retry_params_name": "default" + }, + "GetUploadStatus": { + "retry_codes_name": "non_idempotent", + "retry_params_name": "default" + } + } + } + } +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_proto_list.json.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_proto_list.json.baseline new file mode 100644 index 000000000000..4acc3ac38ace --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/src/v1/resumable_upload_service_proto_list.json.baseline @@ -0,0 +1,3 @@ +[ + "../../protos/google/samples/resumable/v1/resumable.proto" +] diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.cjs.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.cjs.baseline new file mode 100644 index 000000000000..0bad3604de88 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.cjs.baseline @@ -0,0 +1,27 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + + +/* eslint-disable node/no-missing-require, no-unused-vars, no-undef */ +const resumable = require('resumable'); + +function main() { + const resumableUploadServiceClient = new resumable.ResumableUploadServiceClient(); +} + +main(); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.js.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.js.baseline new file mode 100644 index 000000000000..db497b0f574d --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.js.baseline @@ -0,0 +1,27 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + + +/* eslint-disable node/no-missing-require, no-unused-vars, no-undef */ +import * as resumable from 'resumable'; + +function main() { + const resumableUploadServiceClient = new resumable.ResumableUploadServiceClient(); +} + +main(); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.ts.baseline new file mode 100644 index 000000000000..57a59185bdaf --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/fixtures/sample/src/index.ts.baseline @@ -0,0 +1,35 @@ +/* eslint-disable node/no-missing-require, no-unused-vars, no-undef */ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +import { ResumableUploadServiceClient } from 'resumable'; + +// check that the client class type name can be used +function doStuffWithResumableUploadServiceClient( + client: ResumableUploadServiceClient, +) { + client.close(); +} + +function main() { + // check that the client instance can be created + const resumableUploadServiceClient = new ResumableUploadServiceClient(); + doStuffWithResumableUploadServiceClient(resumableUploadServiceClient); +} + +main(); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/install.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/install.ts.baseline new file mode 100644 index 000000000000..d109fdd8c97f --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/system-test/install.ts.baseline @@ -0,0 +1,60 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +import { packNTest } from 'pack-n-play'; +import { readFileSync } from 'fs'; +import { describe, it } from 'mocha'; + +describe('📦 pack-n-play test', () => { + it('TypeScript', async function () { + this.timeout(300000); + await packNTest({ + packageDir: process.cwd(), + sample: { + description: 'TypeScript user can use the type definitions', + ts: readFileSync( + './esm/system-test/fixtures/sample/src/index.ts', + ).toString(), + }, + }); + }); + + it('ESM module', async function () { + this.timeout(300000); + await packNTest({ + sample: { + description: 'Should be able to import using ESM', + esm: readFileSync( + './esm/system-test/fixtures/sample/src/index.js', + ).toString(), + }, + }); + }); + + it('CJS module', async function () { + this.timeout(300000); + await packNTest({ + sample: { + description: 'Should be able to import using CJS', + cjs: readFileSync( + './esm/system-test/fixtures/sample/src/index.cjs', + ).toString(), + }, + }); + }); +}); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/test/gapic_resumable_upload_service_v1.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/test/gapic_resumable_upload_service_v1.ts.baseline new file mode 100644 index 000000000000..0caa4600082d --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/esm/test/gapic_resumable_upload_service_v1.ts.baseline @@ -0,0 +1,419 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +// @ts-ignore +import * as protos from '../../protos/protos.js'; +import assert from 'assert'; +import * as sinon from 'sinon'; +import { SinonStub } from 'sinon'; +import { describe, it } from 'mocha'; +import * as resumableuploadserviceModule from '../src/index.js'; + +import { protobuf } from 'google-gax'; +import fs from 'fs'; +import path from 'path'; +import { fileURLToPath } from 'url'; + +// @ts-ignore +const dirname = path.dirname(fileURLToPath(import.meta.url)); +// Dynamically loaded proto JSON is needed to get the type information +// to fill in default values for request objects +const root = protobuf.Root.fromJSON( + JSON.parse( + fs.readFileSync( + path.join(dirname, '..', '..', 'protos/protos.json'), + 'utf8', + ), + ), +); + +// eslint-disable-next-line @typescript-eslint/no-unused-vars +function getTypeDefaultValue(typeName: string, fields: string[]) { + let type = root.lookupType(typeName) as protobuf.Type; + for (const field of fields.slice(0, -1)) { + type = type?.fields[field]?.resolvedType as protobuf.Type; + } + return type?.fields[fields[fields.length - 1]]?.defaultValue ?? null; +} + +function generateSampleMessage(instance: T) { + const filledObject = ( + instance.constructor as typeof protobuf.Message + ).toObject(instance as protobuf.Message, { defaults: true }); + return (instance.constructor as typeof protobuf.Message).fromObject( + filledObject, + ) as T; +} + +function stubSimpleCall(response?: ResponseType, error?: Error) { + return error + ? sinon.stub().rejects(error) + : sinon.stub().resolves([response]); +} + +function stubSimpleCallWithCallback( + response?: ResponseType, + error?: Error, +) { + return error + ? sinon.stub().callsArgWith(2, error) + : sinon.stub().callsArgWith(2, null, response); +} + +describe('v1.ResumableUploadServiceClient', () => { + describe('Common methods', () => { + it('has apiEndpoint', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient(); + const apiEndpoint = client.apiEndpoint; + assert.strictEqual(apiEndpoint, 'resumable.googleapis.com'); + }); + + it('has universeDomain', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient(); + const universeDomain = client.universeDomain; + assert.strictEqual(universeDomain, 'googleapis.com'); + }); + + if ( + typeof process === 'object' && + typeof process.emitWarning === 'function' + ) { + it('throws DeprecationWarning if static servicePath is used', () => { + const stub = sinon.stub(process, 'emitWarning'); + const servicePath = + resumableuploadserviceModule.v1.ResumableUploadServiceClient + .servicePath; + assert.strictEqual(servicePath, 'resumable.googleapis.com'); + assert(stub.called); + stub.restore(); + }); + + it('throws DeprecationWarning if static apiEndpoint is used', () => { + const stub = sinon.stub(process, 'emitWarning'); + const apiEndpoint = + resumableuploadserviceModule.v1.ResumableUploadServiceClient + .apiEndpoint; + assert.strictEqual(apiEndpoint, 'resumable.googleapis.com'); + assert(stub.called); + stub.restore(); + }); + } + it('sets apiEndpoint according to universe domain camelCase', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + universeDomain: 'example.com', + }); + const servicePath = client.apiEndpoint; + assert.strictEqual(servicePath, 'resumable.example.com'); + }); + + it('sets apiEndpoint according to universe domain snakeCase', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + universe_domain: 'example.com', + }); + const servicePath = client.apiEndpoint; + assert.strictEqual(servicePath, 'resumable.example.com'); + }); + + if (typeof process === 'object' && 'env' in process) { + describe('GOOGLE_CLOUD_UNIVERSE_DOMAIN environment variable', () => { + it('sets apiEndpoint from environment variable', () => { + const saved = process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN']; + process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN'] = 'example.com'; + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient(); + const servicePath = client.apiEndpoint; + assert.strictEqual(servicePath, 'resumable.example.com'); + if (saved) { + process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN'] = saved; + } else { + delete process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN']; + } + }); + + it('value configured in code has priority over environment variable', () => { + const saved = process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN']; + process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN'] = 'example.com'; + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + universeDomain: 'configured.example.com', + }); + const servicePath = client.apiEndpoint; + assert.strictEqual(servicePath, 'resumable.configured.example.com'); + if (saved) { + process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN'] = saved; + } else { + delete process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN']; + } + }); + }); + } + it('does not allow setting both universeDomain and universe_domain', () => { + assert.throws(() => { + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + universe_domain: 'example.com', + universeDomain: 'example.net', + }); + }); + }); + + it('has port', () => { + const port = + resumableuploadserviceModule.v1.ResumableUploadServiceClient.port; + assert(port); + assert(typeof port === 'number'); + }); + + it('should create a client with no option', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient(); + assert(client); + }); + + it('should create a client with gRPC fallback', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + fallback: true, + }); + assert(client); + }); + + it('has initialize method and supports deferred initialization', async () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + assert.strictEqual(client.resumableUploadServiceStub, undefined); + await client.initialize(); + assert(client.resumableUploadServiceStub); + }); + + it('has close method for the initialized client', (done) => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + client.initialize().catch((err) => { + throw err; + }); + assert(client.resumableUploadServiceStub); + client + .close() + .then(() => { + done(); + }) + .catch((err) => { + throw err; + }); + }); + + it('has close method for the non-initialized client', (done) => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + assert.strictEqual(client.resumableUploadServiceStub, undefined); + client + .close() + .then(() => { + done(); + }) + .catch((err) => { + throw err; + }); + }); + + it('has getProjectId method', async () => { + const fakeProjectId = 'fake-project-id'; + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + client.auth.getProjectId = sinon.stub().resolves(fakeProjectId); + const result = await client.getProjectId(); + assert.strictEqual(result, fakeProjectId); + assert((client.auth.getProjectId as SinonStub).calledWithExactly()); + }); + + it('has getProjectId method with callback', async () => { + const fakeProjectId = 'fake-project-id'; + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + client.auth.getProjectId = sinon + .stub() + .callsArgWith(0, null, fakeProjectId); + const promise = new Promise((resolve, reject) => { + client.getProjectId((err?: Error | null, projectId?: string | null) => { + if (err) { + reject(err); + } else { + resolve(projectId); + } + }); + }); + const result = await promise; + assert.strictEqual(result, fakeProjectId); + }); + }); + + describe('getUploadStatus', () => { + it('invokes getUploadStatus without error', async () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + await client.initialize(); + const request = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusRequest(), + ); + const defaultValue1 = getTypeDefaultValue( + '.google.samples.resumable.v1.GetUploadStatusRequest', + ['uploadUrl'], + ); + request.uploadUrl = defaultValue1; + const expectedHeaderRequestParams = `upload_url=${defaultValue1 ?? ''}`; + const expectedResponse = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusResponse(), + ); + client.innerApiCalls.getUploadStatus = stubSimpleCall(expectedResponse); + const [response] = await client.getUploadStatus(request); + assert.deepStrictEqual(response, expectedResponse); + const actualRequest = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[0]; + assert.deepStrictEqual(actualRequest, request); + const actualHeaderRequestParams = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[1].otherArgs.headers['x-goog-request-params']; + assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams)); + }); + + it('invokes getUploadStatus without error using callback', async () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + await client.initialize(); + const request = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusRequest(), + ); + const defaultValue1 = getTypeDefaultValue( + '.google.samples.resumable.v1.GetUploadStatusRequest', + ['uploadUrl'], + ); + request.uploadUrl = defaultValue1; + const expectedHeaderRequestParams = `upload_url=${defaultValue1 ?? ''}`; + const expectedResponse = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusResponse(), + ); + client.innerApiCalls.getUploadStatus = + stubSimpleCallWithCallback(expectedResponse); + const promise = new Promise((resolve, reject) => { + client.getUploadStatus( + request, + ( + err?: Error | null, + result?: protos.google.samples.resumable.v1.IGetUploadStatusResponse | null, + ) => { + if (err) { + reject(err); + } else { + resolve(result); + } + }, + ); + }); + const response = await promise; + assert.deepStrictEqual(response, expectedResponse); + const actualRequest = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[0]; + assert.deepStrictEqual(actualRequest, request); + const actualHeaderRequestParams = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[1].otherArgs.headers['x-goog-request-params']; + assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams)); + }); + + it('invokes getUploadStatus with error', async () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + await client.initialize(); + const request = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusRequest(), + ); + const defaultValue1 = getTypeDefaultValue( + '.google.samples.resumable.v1.GetUploadStatusRequest', + ['uploadUrl'], + ); + request.uploadUrl = defaultValue1; + const expectedHeaderRequestParams = `upload_url=${defaultValue1 ?? ''}`; + const expectedError = new Error('expected'); + client.innerApiCalls.getUploadStatus = stubSimpleCall( + undefined, + expectedError, + ); + await assert.rejects(client.getUploadStatus(request), expectedError); + const actualRequest = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[0]; + assert.deepStrictEqual(actualRequest, request); + const actualHeaderRequestParams = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[1].otherArgs.headers['x-goog-request-params']; + assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams)); + }); + + it('invokes getUploadStatus with closed client', async () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + await client.initialize(); + const request = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusRequest(), + ); + const defaultValue1 = getTypeDefaultValue( + '.google.samples.resumable.v1.GetUploadStatusRequest', + ['uploadUrl'], + ); + request.uploadUrl = defaultValue1; + const expectedError = new Error('The client has already been closed.'); + client.close().catch((err) => { + throw err; + }); + await assert.rejects(client.getUploadStatus(request), expectedError); + }); + }); +}); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/package.json b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/package.json new file mode 100644 index 000000000000..d54ad8309592 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/package.json @@ -0,0 +1,108 @@ +{ + "name": "resumable", + "version": "0.1.0", + "description": "Resumable client for Node.js", + "repository": { + "type": "git", + "directory": "packages/google-samples-resumable", + "url": "https://github.com/googleapis/google-cloud-node.git" + }, + "license": "Apache-2.0", + "homepage": "https://github.com/googleapis/google-cloud-node/tree/main/packages/google-samples-resumable", + "author": "Google LLC", + "main": "./build/cjs/src/index.cjs", + "types": "./build/cjs/src/index.d.ts", + "type": "module", + "exports": { + ".": { + "import": { + "types": "./build/esm/src/index.d.ts", + "default": "./build/esm/src/index.js" + }, + "require": { + "types": "./build/cjs/src/index.d.ts", + "default": "./build/cjs/src/index.cjs" + } + }, + "./build/protos/protos": { + "import": { + "types": "./build/protos/protos/protos.d.ts", + "default": "./build/protos/protos/protos.js" + }, + "require": { + "types": "./build/protos/protos/protos.d.ts", + "default": "./build/protos/protos/protos.cjs" + } + } + }, + "files": [ + "build/esm", + "build/cjs", + "build/protos", + "!build/esm/**/*.map", + "!build/cjs/**/*.map" + ], + "keywords": [ + "google apis client", + "google api client", + "google apis", + "google api", + "google", + "google cloud platform", + "google cloud", + "cloud", + "google resumable", + "resumable", + "resumable upload service" + ], + "scripts": { + "clean": "gts clean", + "compile-protos": "compileProtos esm/src --esm ", + "docs": "jsdoc -c .jsdoc.cjs", + "postpack": "minifyProtoJson build/cjs && minifyProtoJson build/esm", + "fix": "gts fix", + "lint": "gts check", + "prepare": "npm run compile-protos && npm run compile", + "system-test:cjs": "c8 mocha --config ../../.mocharc.cjs --no-parallel build/cjs/system-test", + "system-test:esm": "c8 mocha --config ../../.mocharc.cjs --no-parallel build/esm/system-test", + "system-test": "npm run system-test:esm && npm run system-test:cjs", + "test:cjs": "c8 mocha --config ../../.mocharc.cjs build/cjs/test", + "test:esm": "c8 mocha --config ../../.mocharc.cjs build/esm/test", + "test": "npm run test:cjs && npm run test:esm", + "compile:esm": "tsc -p ./tsconfig.esm.json && cp -r esm/src/json-helper.cjs build/esm/src/json-helper.cjs", + "babel": "babel esm --out-dir build/cjs --ignore \"esm/**/*.d.ts\" --extensions \".ts\" --out-file-extension .cjs --copy-files", + "compile:cjs": "tsc -p ./tsconfig.json && npm run babel", + "compile": "npm run compile:esm && rm -rf esm/src/json-helper.d.cts && npm run compile:cjs && rm -rf build/protos && cp -r protos build/protos", + "samples-test": "cd samples/ && npm link ../ && npm i && npm test" + }, + "dependencies": { + "google-gax": "^6.0.0" + }, + "devDependencies": { + "@babel/cli": "^7.28.3", + "@babel/core": "^7.28.5", + "@babel/preset-env": "^7.28.5", + "@babel/preset-typescript": "^7.28.5", + "@types/mocha": "^10.0.10", + "@types/node": "^22.18.12", + "@types/sinon": "^20.0.0", + "babel-plugin-replace-import-extension": "^1.1.5", + "c8": "^10.1.3", + "gapic-tools": "^1.0.3", + "gts": "^6.0.2", + "jsdoc": "^4.0.5", + "jsdoc-region-tag": "^4.0.1", + "jsdoc-fresh": "^5.0.2", + "long": "^5.3.2", + "mocha": "^11.7.4", + "typescript": "5.8.3", + "pack-n-play": "^4.2.1", + "sinon": "^20.0.0", + "ts-loader": "^8.4.0", + "webpack": "^5.102.1", + "webpack-cli": "^6.0.1" + }, + "engines": { + "node": ">=22" + } +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/package.json.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/package.json.baseline new file mode 120000 index 000000000000..2ff8622f1722 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/package.json.baseline @@ -0,0 +1 @@ +package.json \ No newline at end of file diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/protos/google/api/media_upload.proto.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/protos/google/api/media_upload.proto.baseline new file mode 100644 index 000000000000..f2deed02e29f --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/protos/google/api/media_upload.proto.baseline @@ -0,0 +1,63 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// NOTE: This is a local copy of the pending `google/api/media_upload.proto` +// definition used to describe resumable upload methods. +// The official proto has not been published to googleapis yet; when it is, +// this file should be replaced by the upstream version and the protos bundle +// regenerated. Detection in the generator matches on the option name +// (`.google.api.mediaUpload`), so the extension number below is a +// placeholder that does not affect method identification. + +syntax = "proto3"; + +package google.api; + +import "google/api/annotations.proto"; +import "google/protobuf/descriptor.proto"; + +option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; + +// MediaUpload describes the media upload configuration for a method that +// opts into the resumable upload protocol. +message MediaUpload { + // Whether the method supports media upload. + bool enabled = 1; + + // The paths to which media upload commands are sent. When present, the + // first path is used as the upload prefix for the resumable upload + // session (for example, `/resumable/upload`). + repeated string media_upload_paths = 2; + + // Whether the server notifies the client when the session is started. + bool start_notification = 3; + + // Whether the server notifies the client on each upload command. + bool upload_notification = 4; + + // Whether the server notifies the client when the upload is finalized. + bool finalize_notification = 5; + + // The direct upload service to use, if any. + string direct_upload_service = 6; + + // How long, in seconds, an upload session may remain active. + int64 max_upload_session_duration_seconds = 7; +} + +// Defines a method as a media upload method. Methods annotated with this +// option are routed through the resumable upload protocol. +extend google.protobuf.MethodOptions { + MediaUpload media_upload = 1052; +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/protos/google/samples/resumable/v1/resumable.proto.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/protos/google/samples/resumable/v1/resumable.proto.baseline new file mode 100644 index 000000000000..75409923f7ef --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/protos/google/samples/resumable/v1/resumable.proto.baseline @@ -0,0 +1,78 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Synthetic fixture used by the baseline tests to exercise resumable upload +// method generation. The google.api.media_upload annotation is defined by +// the local copy of google/api/media_upload.proto. + +syntax = "proto3"; + +package google.samples.resumable.v1; + +import "google/api/annotations.proto"; +import "google/api/client.proto"; +import "google/api/media_upload.proto"; + +option csharp_namespace = "Google.Samples.Resumable.V1"; +option go_package = "google.golang.org/genproto/googleapis/samples/resumable/v1;resumable"; +option java_multiple_files = true; +option java_outer_classname = "ResumableProto"; +option java_package = "com.google.samples.resumable.v1"; +option php_namespace = "Google\\Samples\\Resumable\\V1"; +option ruby_package = "Google::Samples::Resumable::V1"; + +service ResumableUploadService { + option (google.api.default_host) = "resumable.googleapis.com"; + option (google.api.oauth_scopes) = + "https://www.googleapis.com/auth/cloud-platform"; + + // Creates a resumable upload session. + rpc CreateResumableUpload(CreateResumableUploadRequest) + returns (CreateResumableUploadResponse) { + option (google.api.http) = { + post: "/v1/uploads" + body: "*" + }; + option (google.api.media_upload) = { + enabled: true + media_upload_paths: "/resumable/upload" + }; + } + + // Returns the status of a previously created upload session. + rpc GetUploadStatus(GetUploadStatusRequest) + returns (GetUploadStatusResponse) { + option (google.api.http) = { + get: "/v1/uploads/{upload_url}" + }; + } +} + +message CreateResumableUploadRequest { + string name = 1; + string description = 2; +} + +message CreateResumableUploadResponse { + string upload_url = 1; + string status = 2; +} + +message GetUploadStatusRequest { + string upload_url = 1; +} + +message GetUploadStatusResponse { + string status = 1; +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/samples/generated/v1/resumable_upload_service.create_resumable_upload.js.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/samples/generated/v1/resumable_upload_service.create_resumable_upload.js.baseline new file mode 100644 index 000000000000..e551587f1ed3 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/samples/generated/v1/resumable_upload_service.create_resumable_upload.js.baseline @@ -0,0 +1,68 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + + + +'use strict'; + +function main() { + // [START resumable_v1_generated_ResumableUploadService_CreateResumableUpload_async] + /** + * This snippet has been automatically generated and should be regarded as a code template only. + * It will require modifications to work. + * It may require correct/in-range values for request initialization. + * TODO(developer): Uncomment these variables before running the sample. + */ + /** + */ + // const name = 'abc123' + /** + */ + // const description = 'abc123' + + // Imports the Resumable library + const {ResumableUploadServiceClient} = require('resumable').v1; + + const fs = require('fs'); + + // Instantiates a client + const resumableClient = new ResumableUploadServiceClient(); + + async function callCreateResumableUpload() { + // Construct request + const request = { + }; + + // Run request + const helper = await resumableClient.createResumableUpload(request); + await helper.start({ + uploadStream: fs.createReadStream('/path/to/file'), + }); + const response = await helper.finished(); + console.log(response); + } + + callCreateResumableUpload(); + // [END resumable_v1_generated_ResumableUploadService_CreateResumableUpload_async] +} + +process.on('unhandledRejection', err => { + console.error(err.message); + process.exitCode = 1; +}); +main(...process.argv.slice(2)); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/samples/generated/v1/resumable_upload_service.get_upload_status.js.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/samples/generated/v1/resumable_upload_service.get_upload_status.js.baseline new file mode 100644 index 000000000000..1bc4435b7075 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/samples/generated/v1/resumable_upload_service.get_upload_status.js.baseline @@ -0,0 +1,59 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + + + +'use strict'; + +function main() { + // [START resumable_v1_generated_ResumableUploadService_GetUploadStatus_async] + /** + * This snippet has been automatically generated and should be regarded as a code template only. + * It will require modifications to work. + * It may require correct/in-range values for request initialization. + * TODO(developer): Uncomment these variables before running the sample. + */ + /** + */ + // const uploadUrl = 'abc123' + + // Imports the Resumable library + const {ResumableUploadServiceClient} = require('resumable').v1; + + // Instantiates a client + const resumableClient = new ResumableUploadServiceClient(); + + async function callGetUploadStatus() { + // Construct request + const request = { + }; + + // Run request + const response = await resumableClient.getUploadStatus(request); + console.log(response); + } + + callGetUploadStatus(); + // [END resumable_v1_generated_ResumableUploadService_GetUploadStatus_async] +} + +process.on('unhandledRejection', err => { + console.error(err.message); + process.exitCode = 1; +}); +main(...process.argv.slice(2)); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/tsconfig.esm.json.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/tsconfig.esm.json.baseline new file mode 100644 index 000000000000..9ea46f074fa2 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/tsconfig.esm.json.baseline @@ -0,0 +1,27 @@ +{ + "extends": "./node_modules/gts/tsconfig-google.json", + "compilerOptions": { + "rootDir": ".", + "outDir": "build", + "resolveJsonModule": true, + "module": "es2020", + "moduleResolution": "node", + "esModuleInterop": true, + "sourceMap": false, + "allowJs": true, + "lib": [ + "es2020", + "DOM" + ] + }, + "include": [ + "esm/src/*.ts", + "esm/src/**/*.ts", + "esm/test/*.ts", + "esm/test/**/*.ts", + "esm/system-test/*.ts", + "esm/src/**/*.json", + "protos/protos.json", + "esm/src/*.cjs" + ] +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/tsconfig.json.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/tsconfig.json.baseline new file mode 100644 index 000000000000..110f6eccd41b --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/tsconfig.json.baseline @@ -0,0 +1,32 @@ +{ + "extends": "./node_modules/gts/tsconfig-google.json", + "compilerOptions": { + "rootDir": ".", + "resolveJsonModule": true, + "moduleResolution": "node", + "allowJs": true, + "esModuleInterop": true, + "sourceMap": false, + "target": "esnext", + "module": "CommonJS", + "declaration": true, + "strict": true, + "isolatedModules": false, + "emitDeclarationOnly": true, + "lib": [ + "es2023", + "dom" + ] + }, + "include": [ + "esm/src/*.ts", + "esm/src/**/*.ts", + "esm/test/*.ts", + "esm/test/**/*.ts", + "esm/src/**/*.json", + "esm/system-test/*.ts", + "esm/src/*.cjs", + "samples/**/*.json", + "protos/protos.json" + ] +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/webpack.config.cjs.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/webpack.config.cjs.baseline new file mode 100644 index 000000000000..0a553e060843 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload-esm/webpack.config.cjs.baseline @@ -0,0 +1,64 @@ +// Copyright 2021 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +const path = require('path'); + +module.exports = { + entry: './src/index.ts', + output: { + library: 'ResumableUploadService', + filename: './resumable-upload-service.js', + }, + node: { + child_process: 'empty', + fs: 'empty', + crypto: 'empty', + }, + resolve: { + alias: { + '../../../package.json': path.resolve(__dirname, 'package.json'), + }, + extensions: ['.js', '.json', '.ts'], + }, + module: { + rules: [ + { + test: /\.tsx?$/, + use: 'ts-loader', + exclude: /node_modules/ + }, + { + test: /node_modules[\\/]@grpc[\\/]grpc-js/, + use: 'null-loader' + }, + { + test: /node_modules[\\/]grpc/, + use: 'null-loader' + }, + { + test: /node_modules[\\/]retry-request/, + use: 'null-loader' + }, + { + test: /node_modules[\\/]https?-proxy-agent/, + use: 'null-loader' + }, + { + test: /node_modules[\\/]gtoken/, + use: 'null-loader' + }, + ], + }, + mode: 'production', +}; diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/.OwlBot.yaml.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/.OwlBot.yaml.baseline new file mode 100644 index 000000000000..7feea79e8531 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/.OwlBot.yaml.baseline @@ -0,0 +1,19 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +deep-copy-regex: + - source: /google/samples/resumable/google-samples-resumable-nodejs + dest: /owl-bot-staging/google-samples-resumable + +api-name: resumable \ No newline at end of file diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/.gitignore.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/.gitignore.baseline new file mode 100644 index 000000000000..d4f03a0df2e8 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/.gitignore.baseline @@ -0,0 +1,14 @@ +**/*.log +**/node_modules +/.coverage +/coverage +/.nyc_output +/docs/ +/out/ +/build/ +system-test/secrets.js +system-test/*key.json +*.lock +.DS_Store +package-lock.json +__pycache__ diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/.jsdoc.js.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/.jsdoc.js.baseline new file mode 100644 index 000000000000..4b3b51f5549b --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/.jsdoc.js.baseline @@ -0,0 +1,55 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +'use strict'; + +module.exports = { + opts: { + readme: './README.md', + package: './package.json', + template: './node_modules/jsdoc-fresh', + recurse: true, + verbose: true, + destination: './docs/' + }, + plugins: [ + 'plugins/markdown', + 'jsdoc-region-tag' + ], + source: { + excludePattern: '(^|\\/|\\\\)[._]', + include: [ + 'build/src', + 'protos' + ], + includePattern: '\\.js$' + }, + templates: { + copyright: 'Copyright 2026 Google LLC', + includeDate: false, + sourceFiles: false, + systemName: 'resumable', + theme: 'lumen', + default: { + outputSourceFiles: false + } + }, + markdown: { + idInHeadings: true + } +}; diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/.nycrc.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/.nycrc.baseline new file mode 100644 index 000000000000..81a95fc94b00 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/.nycrc.baseline @@ -0,0 +1,24 @@ +{ + "report-dir": "./.coverage", + "reporter": ["text", "lcov"], + "exclude": [ + "**/*-test", + "**/.coverage", + "**/apis", + "**/benchmark", + "**/conformance", + "**/docs", + "**/samples", + "**/scripts", + "**/protos", + "**/test", + "**/*.d.ts", + ".jsdoc.js", + "**/.jsdoc.js", + "karma.conf.js", + "webpack-tests.config.js", + "webpack.config.js" + ], + "exclude-after-remap": false, + "all": true +} \ No newline at end of file diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/README.md.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/README.md.baseline new file mode 100644 index 000000000000..582e319d972b --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/README.md.baseline @@ -0,0 +1,108 @@ +[//]: # "This README.md file is auto-generated, all changes to this file will be lost." +[//]: # "The comments you see below are used to generate those parts of the template in later states." +Google Cloud Platform logo + +# [Resumable: Nodejs Client][homepage] + +[//]: # "releaseLevel" + +[![npm version](https://img.shields.io/npm/v/resumable.svg)](https://www.npmjs.org/package/resumable) + +Resumable client for Node.js + +[//]: # "partials.introduction" + +A comprehensive list of changes in each version may be found in +[the CHANGELOG][homepage_changelog]. + +* [Resumable Nodejs Client API Reference](https://cloud.google.com/nodejs/docs/reference/resumable/latest) + + +Read more about the client libraries for Cloud APIs, including the older +Google APIs Client Libraries, in [Client Libraries Explained][explained]. + +[explained]: https://cloud.google.com/apis/docs/client-libraries-explained + +**Table of contents:** + +* [Quickstart](#quickstart) + * [Before you begin](#before-you-begin) + * [Installing the client library](#installing-the-client-library) + +* [Versioning](#versioning) +* [Contributing](#contributing) +* [License](#license) + +## Quickstart +### Before you begin + +1. [Select or create a Cloud Platform project][projects]. +1. [Enable billing for your project][billing]. +1. [Enable the Resumable API][enable_api]. +1. [Set up authentication][auth] so you can access the + API from your local workstation. +### Installing the client library + +```bash +npm install resumable +``` + +[//]: # "partials.body" + +## Samples + +Samples are in the [`samples/`][homepage_samples] directory. Each sample's `README.md` has instructions for running its sample. + +[//]: # "samples" + +## Supported Node.js Versions + +Our client libraries follow the [Node.js release schedule](https://github.com/nodejs/release#release-schedule). +Libraries are compatible with all current _active_ and _maintenance_ versions of +Node.js. +If you are using an end-of-life version of Node.js, we recommend that you update +as soon as possible to an actively supported LTS version. + +Google's client libraries support legacy versions of Node.js runtimes on a +best-efforts basis with the following warnings: + +* Legacy versions are not tested in continuous integration. +* Some security patches and features cannot be backported. +* Dependencies cannot be kept up-to-date. + +Client libraries targeting some end-of-life versions of Node.js are available, and +can be installed through npm [dist-tags](https://docs.npmjs.com/cli/dist-tag). +The dist-tags follow the naming convention `legacy-(version)`. +For example, `npm install resumable@legacy-8` installs client libraries +for versions compatible with Node.js 8. + +## Versioning + +This library follows [Semantic Versioning](http://semver.org/). + +More Information: [Google Cloud Platform Launch Stages][launch_stages] + +[launch_stages]: https://cloud.google.com/terms/launch-stages + +## Contributing + +Contributions welcome! See the [Contributing Guide](https://github.com/googleapis/google-cloud-node/blob/main/CONTRIBUTING.md). + +Please note that this `README.md` +and a variety of configuration files in this repository (including `.nycrc` and `tsconfig.json`) +are generated from a central template. + +## License + +Apache Version 2.0 + +See [LICENSE](https://github.com/googleapis/google-cloud-node/blob/main/LICENSE) + +[shell_img]: https://gstatic.com/cloudssh/images/open-btn.png +[projects]: https://console.cloud.google.com/project +[billing]: https://support.google.com/cloud/answer/6293499#enable-billing +[enable_api]: https://console.cloud.google.com/flows/enableapi?apiid=resumable.googleapis.com +[auth]: https://cloud.google.com/docs/authentication/external/set-up-adc-local +[homepage_samples]: https://github.com/googleapis/google-cloud-node/blob/main/packages/google-samples-resumable/samples +[homepage_changelog]: https://github.com/googleapis/google-cloud-node/blob/main/packages/google-samples-resumable/CHANGELOG.md +[homepage]: https://github.com/googleapis/google-cloud-node/blob/main/packages/google-samples-resumable diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/package.json b/core/generator/gapic-generator-typescript/baselines/resumable-upload/package.json new file mode 100644 index 000000000000..80d3e15f57ec --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/package.json @@ -0,0 +1,64 @@ +{ + "name": "resumable", + "version": "0.1.0", + "description": "Resumable client for Node.js", + "repository": { + "type": "git", + "directory": "packages/google-samples-resumable", + "url": "https://github.com/googleapis/google-cloud-node.git" + }, + "license": "Apache-2.0", + "homepage": "https://github.com/googleapis/google-cloud-node/tree/main/packages/google-samples-resumable", + "author": "Google LLC", + "main": "build/src/index.js", + "files": [ + "build/src", + "build/protos" + ], + "keywords": [ + "google apis client", + "google api client", + "google apis", + "google api", + "google", + "google cloud platform", + "google cloud", + "cloud", + "google resumable", + "resumable", + "resumable upload service" + ], + "scripts": { + "clean": "gts clean", + "compile": "tsc -p . && cp -r protos build/ && minifyProtoJson", + "compile-protos": "compileProtos src", + "docs": "jsdoc -c .jsdoc.js", + "fix": "gts fix", + "lint": "gts check", + "prepare": "npm run compile-protos && npm run compile", + "system-test": "c8 mocha --config ../../.mocharc.cjs --no-parallel build/system-test", + "test": "c8 mocha --config ../../.mocharc.cjs build/test" + }, + "dependencies": { + "google-gax": "^6.0.0" + }, + "devDependencies": { + "@types/mocha": "^10.0.10", + "@types/node": "^22.18.12", + "@types/sinon": "^20.0.0", + "c8": "^10.1.3", + "gapic-tools": "^1.0.3", + "gts": "^6.0.2", + "jsdoc": "^4.0.5", + "jsdoc-fresh": "^5.0.2", + "jsdoc-region-tag": "^4.0.1", + "long": "^5.3.2", + "mocha": "^11.7.4", + "pack-n-play": "^4.2.1", + "typescript": "5.8.3", + "sinon": "^20.0.0" + }, + "engines": { + "node": ">=22" + } +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/package.json.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/package.json.baseline new file mode 120000 index 000000000000..2ff8622f1722 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/package.json.baseline @@ -0,0 +1 @@ +package.json \ No newline at end of file diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/protos/google/api/media_upload.proto.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/protos/google/api/media_upload.proto.baseline new file mode 100644 index 000000000000..f2deed02e29f --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/protos/google/api/media_upload.proto.baseline @@ -0,0 +1,63 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// NOTE: This is a local copy of the pending `google/api/media_upload.proto` +// definition used to describe resumable upload methods. +// The official proto has not been published to googleapis yet; when it is, +// this file should be replaced by the upstream version and the protos bundle +// regenerated. Detection in the generator matches on the option name +// (`.google.api.mediaUpload`), so the extension number below is a +// placeholder that does not affect method identification. + +syntax = "proto3"; + +package google.api; + +import "google/api/annotations.proto"; +import "google/protobuf/descriptor.proto"; + +option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; + +// MediaUpload describes the media upload configuration for a method that +// opts into the resumable upload protocol. +message MediaUpload { + // Whether the method supports media upload. + bool enabled = 1; + + // The paths to which media upload commands are sent. When present, the + // first path is used as the upload prefix for the resumable upload + // session (for example, `/resumable/upload`). + repeated string media_upload_paths = 2; + + // Whether the server notifies the client when the session is started. + bool start_notification = 3; + + // Whether the server notifies the client on each upload command. + bool upload_notification = 4; + + // Whether the server notifies the client when the upload is finalized. + bool finalize_notification = 5; + + // The direct upload service to use, if any. + string direct_upload_service = 6; + + // How long, in seconds, an upload session may remain active. + int64 max_upload_session_duration_seconds = 7; +} + +// Defines a method as a media upload method. Methods annotated with this +// option are routed through the resumable upload protocol. +extend google.protobuf.MethodOptions { + MediaUpload media_upload = 1052; +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/protos/google/samples/resumable/v1/resumable.proto.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/protos/google/samples/resumable/v1/resumable.proto.baseline new file mode 100644 index 000000000000..75409923f7ef --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/protos/google/samples/resumable/v1/resumable.proto.baseline @@ -0,0 +1,78 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Synthetic fixture used by the baseline tests to exercise resumable upload +// method generation. The google.api.media_upload annotation is defined by +// the local copy of google/api/media_upload.proto. + +syntax = "proto3"; + +package google.samples.resumable.v1; + +import "google/api/annotations.proto"; +import "google/api/client.proto"; +import "google/api/media_upload.proto"; + +option csharp_namespace = "Google.Samples.Resumable.V1"; +option go_package = "google.golang.org/genproto/googleapis/samples/resumable/v1;resumable"; +option java_multiple_files = true; +option java_outer_classname = "ResumableProto"; +option java_package = "com.google.samples.resumable.v1"; +option php_namespace = "Google\\Samples\\Resumable\\V1"; +option ruby_package = "Google::Samples::Resumable::V1"; + +service ResumableUploadService { + option (google.api.default_host) = "resumable.googleapis.com"; + option (google.api.oauth_scopes) = + "https://www.googleapis.com/auth/cloud-platform"; + + // Creates a resumable upload session. + rpc CreateResumableUpload(CreateResumableUploadRequest) + returns (CreateResumableUploadResponse) { + option (google.api.http) = { + post: "/v1/uploads" + body: "*" + }; + option (google.api.media_upload) = { + enabled: true + media_upload_paths: "/resumable/upload" + }; + } + + // Returns the status of a previously created upload session. + rpc GetUploadStatus(GetUploadStatusRequest) + returns (GetUploadStatusResponse) { + option (google.api.http) = { + get: "/v1/uploads/{upload_url}" + }; + } +} + +message CreateResumableUploadRequest { + string name = 1; + string description = 2; +} + +message CreateResumableUploadResponse { + string upload_url = 1; + string status = 2; +} + +message GetUploadStatusRequest { + string upload_url = 1; +} + +message GetUploadStatusResponse { + string status = 1; +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/samples/generated/v1/resumable_upload_service.create_resumable_upload.js.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/samples/generated/v1/resumable_upload_service.create_resumable_upload.js.baseline new file mode 100644 index 000000000000..e551587f1ed3 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/samples/generated/v1/resumable_upload_service.create_resumable_upload.js.baseline @@ -0,0 +1,68 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + + + +'use strict'; + +function main() { + // [START resumable_v1_generated_ResumableUploadService_CreateResumableUpload_async] + /** + * This snippet has been automatically generated and should be regarded as a code template only. + * It will require modifications to work. + * It may require correct/in-range values for request initialization. + * TODO(developer): Uncomment these variables before running the sample. + */ + /** + */ + // const name = 'abc123' + /** + */ + // const description = 'abc123' + + // Imports the Resumable library + const {ResumableUploadServiceClient} = require('resumable').v1; + + const fs = require('fs'); + + // Instantiates a client + const resumableClient = new ResumableUploadServiceClient(); + + async function callCreateResumableUpload() { + // Construct request + const request = { + }; + + // Run request + const helper = await resumableClient.createResumableUpload(request); + await helper.start({ + uploadStream: fs.createReadStream('/path/to/file'), + }); + const response = await helper.finished(); + console.log(response); + } + + callCreateResumableUpload(); + // [END resumable_v1_generated_ResumableUploadService_CreateResumableUpload_async] +} + +process.on('unhandledRejection', err => { + console.error(err.message); + process.exitCode = 1; +}); +main(...process.argv.slice(2)); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/samples/generated/v1/resumable_upload_service.get_upload_status.js.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/samples/generated/v1/resumable_upload_service.get_upload_status.js.baseline new file mode 100644 index 000000000000..1bc4435b7075 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/samples/generated/v1/resumable_upload_service.get_upload_status.js.baseline @@ -0,0 +1,59 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + + + +'use strict'; + +function main() { + // [START resumable_v1_generated_ResumableUploadService_GetUploadStatus_async] + /** + * This snippet has been automatically generated and should be regarded as a code template only. + * It will require modifications to work. + * It may require correct/in-range values for request initialization. + * TODO(developer): Uncomment these variables before running the sample. + */ + /** + */ + // const uploadUrl = 'abc123' + + // Imports the Resumable library + const {ResumableUploadServiceClient} = require('resumable').v1; + + // Instantiates a client + const resumableClient = new ResumableUploadServiceClient(); + + async function callGetUploadStatus() { + // Construct request + const request = { + }; + + // Run request + const response = await resumableClient.getUploadStatus(request); + console.log(response); + } + + callGetUploadStatus(); + // [END resumable_v1_generated_ResumableUploadService_GetUploadStatus_async] +} + +process.on('unhandledRejection', err => { + console.error(err.message); + process.exitCode = 1; +}); +main(...process.argv.slice(2)); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/index.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/index.ts.baseline new file mode 100644 index 000000000000..cc5b9d541edd --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/index.ts.baseline @@ -0,0 +1,25 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +import * as v1 from './v1'; +const ResumableUploadServiceClient = v1.ResumableUploadServiceClient; +type ResumableUploadServiceClient = v1.ResumableUploadServiceClient; +export { v1, ResumableUploadServiceClient }; +export default { v1, ResumableUploadServiceClient }; +import * as protos from '../protos/protos'; +export { protos }; diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/index.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/index.ts.baseline new file mode 100644 index 000000000000..f092ac6ac16e --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/index.ts.baseline @@ -0,0 +1,19 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +export { ResumableUploadServiceClient } from './resumable_upload_service_client'; diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_client.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_client.ts.baseline new file mode 100644 index 000000000000..66c13aeeda7a --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_client.ts.baseline @@ -0,0 +1,576 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +/* global window */ +import type * as gax from 'google-gax'; +import type { + Callback, + CallOptions, + Descriptors, + ClientOptions, +} from 'google-gax'; + +import * as protos from '../../protos/protos'; +import jsonProtos = require('../../protos/protos.json'); +import { loggingUtils as logging, decodeAnyProtosInArray } from 'google-gax'; + +/** + * Client JSON configuration object, loaded from + * `src/v1/resumable_upload_service_client_config.json`. + * This file defines retry strategy and timeouts for all API methods in this library. + */ +import * as gapicConfig from './resumable_upload_service_client_config.json'; +const version = require('../../../package.json').version; + +/** + * @class + * @memberof v1 + */ +export class ResumableUploadServiceClient { + private _terminated = false; + private _opts: ClientOptions; + private _providedCustomServicePath: boolean; + private _gaxModule: typeof gax | typeof gax.fallback; + private _gaxGrpc: gax.GrpcClient | gax.fallback.GrpcClient; + private _fallbackRest?: gax.GrpcClient | gax.fallback.GrpcClient; + private _protos: {}; + private _defaults: { [method: string]: gax.CallSettings }; + private _universeDomain: string; + private _servicePath: string; + private _log = logging.log('resumable'); + + auth: gax.GoogleAuth; + descriptors: Descriptors = { + page: {}, + stream: {}, + longrunning: {}, + batching: {}, + resumableUpload: {}, + }; + warn: (code: string, message: string, warnType?: string) => void; + innerApiCalls: { [name: string]: Function }; + resumableUploadServiceStub?: Promise<{ [name: string]: Function }>; + + /** + * Construct an instance of ResumableUploadServiceClient. + * + * @param {object} [options] - The configuration object. + * The options accepted by the constructor are described in detail + * in [this document](https://github.com/googleapis/gax-nodejs/blob/main/client-libraries.md#creating-the-client-instance). + * The common options are: + * @param {object} [options.credentials] - Credentials object. + * @param {string} [options.credentials.client_email] + * @param {string} [options.credentials.private_key] + * @param {string} [options.email] - Account email address. Required when + * using a .pem or .p12 keyFilename. + * @param {string} [options.keyFilename] - Full path to the a .json, .pem, or + * .p12 key downloaded from the Google Developers Console. If you provide + * a path to a JSON file, the projectId option below is not necessary. + * NOTE: .pem and .p12 require you to specify options.email as well. + * @param {number} [options.port] - The port on which to connect to + * the remote host. + * @param {string} [options.projectId] - The project ID from the Google + * Developer's Console, e.g. 'grape-spaceship-123'. We will also check + * the environment variable GCLOUD_PROJECT for your project ID. If your + * app is running in an environment which supports + * {@link https://cloud.google.com/docs/authentication/application-default-credentials Application Default Credentials}, + * your project ID will be detected automatically. + * @param {string} [options.apiEndpoint] - The domain name of the + * API remote host. + * @param {gax.ClientConfig} [options.clientConfig] - Client configuration override. + * Follows the structure of {@link gapicConfig}. + * @param {boolean} [options.fallback] - Use HTTP/1.1 REST mode. + * For more information, please check the + * {@link https://github.com/googleapis/gax-nodejs/blob/main/client-libraries.md#http11-rest-api-mode documentation}. + * @param {gax} [gaxInstance]: loaded instance of `google-gax`. Useful if you + * need to avoid loading the default gRPC version and want to use the fallback + * HTTP implementation. Load only fallback version and pass it to the constructor: + * ``` + * const gax = require('google-gax/build/src/fallback'); // avoids loading google-gax with gRPC + * const client = new ResumableUploadServiceClient({fallback: true}, gax); + * ``` + */ + constructor( + opts?: ClientOptions, + gaxInstance?: typeof gax | typeof gax.fallback, + ) { + // Ensure that options include all the required fields. + const staticMembers = this + .constructor as typeof ResumableUploadServiceClient; + if ( + opts?.universe_domain && + opts?.universeDomain && + opts?.universe_domain !== opts?.universeDomain + ) { + throw new Error( + 'Please set either universe_domain or universeDomain, but not both.', + ); + } + const universeDomainEnvVar = + typeof process === 'object' && typeof process.env === 'object' + ? process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN'] + : undefined; + this._universeDomain = + opts?.universeDomain ?? + opts?.universe_domain ?? + universeDomainEnvVar ?? + 'googleapis.com'; + this._servicePath = 'resumable.' + this._universeDomain; + const servicePath = + opts?.servicePath || opts?.apiEndpoint || this._servicePath; + this._providedCustomServicePath = !!( + opts?.servicePath || opts?.apiEndpoint + ); + const port = opts?.port || staticMembers.port; + const clientConfig = opts?.clientConfig ?? {}; + const fallback = + opts?.fallback ?? + (typeof window !== 'undefined' && typeof window?.fetch === 'function'); + opts = Object.assign({ servicePath, port, clientConfig, fallback }, opts); + + // If scopes are unset in options and we're connecting to a non-default endpoint, set scopes just in case. + if (servicePath !== this._servicePath && !('scopes' in opts)) { + opts['scopes'] = staticMembers.scopes; + } + + // Load google-gax module synchronously if needed + if (!gaxInstance) { + gaxInstance = require('google-gax') as typeof gax; + } + + // Choose either gRPC or proto-over-HTTP implementation of google-gax. + this._gaxModule = opts.fallback ? gaxInstance.fallback : gaxInstance; + + // Create a `gaxGrpc` object, with any grpc-specific options sent to the client. + this._gaxGrpc = new this._gaxModule.GrpcClient(opts); + + // This service contains resumable upload methods, which are HTTPS-only. + // Make sure the REST transport is available even when the client was + // configured for gRPC. + this._fallbackRest = opts.fallback + ? this._gaxGrpc + : new gaxInstance.fallback.GrpcClient({ ...opts, fallback: true }); + + // Save options to use in initialize() method. + this._opts = opts; + + // Save the auth object to the client, for use by other methods. + this.auth = this._gaxGrpc.auth as gax.GoogleAuth; + + // Set useJWTAccessWithScope on the auth object. + this.auth.useJWTAccessWithScope = true; + + // Set defaultServicePath on the auth object. + this.auth.defaultServicePath = this._servicePath; + + // Set the default scopes in auth client if needed. + if (servicePath === this._servicePath) { + this.auth.defaultScopes = staticMembers.scopes; + } + + // Determine the client header string. + const clientHeader = [`gax/${this._gaxModule.version}`, `gapic/${version}`]; + if (typeof process === 'object' && 'versions' in process) { + clientHeader.push(`gl-node/${process.versions.node}`); + } else { + clientHeader.push(`gl-web/${this._gaxModule.version}`); + } + if (!opts.fallback) { + clientHeader.push(`grpc/${this._gaxGrpc.grpcVersion}`); + } else { + clientHeader.push(`rest/${this._gaxGrpc.grpcVersion}`); + } + if (opts.libName && opts.libVersion) { + clientHeader.push(`${opts.libName}/${opts.libVersion}`); + } + // Load the applicable protos. + this._protos = this._gaxGrpc.loadProtoJSON(jsonProtos); + + // Some methods on this API support resumable uploads; provide + // descriptors for these methods. + this.descriptors.resumableUpload = { + createResumableUpload: new this._gaxModule.ResumableUploadDescriptor( + '/resumable/upload', + ), + }; + + // Put together the default options sent with requests. + this._defaults = this._gaxGrpc.constructSettings( + 'google.samples.resumable.v1.ResumableUploadService', + gapicConfig as gax.ClientConfig, + opts.clientConfig || {}, + { 'x-goog-api-client': clientHeader.join(' ') }, + ); + + // Set up a dictionary of "inner API calls"; the core implementation + // of calling the API is handled in `google-gax`, with this code + // merely providing the destination and request information. + this.innerApiCalls = {}; + + // Add a warn function to the client constructor so it can be easily tested. + this.warn = this._gaxModule.warn; + } + + /** + * Initialize the client. + * Performs asynchronous operations (such as authentication) and prepares the client. + * This function will be called automatically when any class method is called for the + * first time, but if you need to initialize it before calling an actual method, + * feel free to call initialize() directly. + * + * You can await on this method if you want to make sure the client is initialized. + * + * @returns {Promise} A promise that resolves to an authenticated service stub. + */ + initialize() { + // If the client stub promise is already initialized, return immediately. + if (this.resumableUploadServiceStub) { + return this.resumableUploadServiceStub; + } + + // Put together the "service stub" for + // google.samples.resumable.v1.ResumableUploadService. + this.resumableUploadServiceStub = this._gaxGrpc.createStub( + this._opts.fallback + ? (this._protos as protobuf.Root).lookupService( + 'google.samples.resumable.v1.ResumableUploadService', + ) + : // eslint-disable-next-line @typescript-eslint/no-explicit-any + (this._protos as any).google.samples.resumable.v1 + .ResumableUploadService, + this._opts, + this._providedCustomServicePath, + ) as Promise<{ [method: string]: Function }>; + + // Iterate over each of the methods that the service provides + // and create an API call method for each. + const resumableUploadServiceStubMethods = ['getUploadStatus']; + for (const methodName of resumableUploadServiceStubMethods) { + const callPromise = this.resumableUploadServiceStub.then( + (stub) => + (...args: Array<{}>) => { + if (this._terminated) { + return Promise.reject('The client has already been closed.'); + } + const func = stub[methodName]; + return func.apply(stub, args); + }, + (err: Error | null | undefined) => () => { + throw err; + }, + ); + + const descriptor = undefined; + const apiCall = this._gaxModule.createApiCall( + callPromise, + this._defaults[methodName], + descriptor, + this._opts.fallback, + ); + + this.innerApiCalls[methodName] = apiCall; + } + + // Resumable upload methods do not use the gRPC/REST service stub; the + // ResumableUpload helper performs its own HTTP requests. + this.innerApiCalls['createResumableUpload'] = this._gaxModule.createApiCall( + this._gaxModule.resumableUploadStub, + this._defaults['createResumableUpload'], + this.descriptors.resumableUpload['createResumableUpload'], + this._opts.fallback, + ); + + return this.resumableUploadServiceStub; + } + + /** + * The DNS address for this API service. + * @deprecated Use the apiEndpoint method of the client instance. + * @returns {string} The DNS address for this service. + */ + static get servicePath() { + if ( + typeof process === 'object' && + typeof process.emitWarning === 'function' + ) { + process.emitWarning( + 'Static servicePath is deprecated, please use the instance method instead.', + 'DeprecationWarning', + ); + } + return 'resumable.googleapis.com'; + } + + /** + * The DNS address for this API service - same as servicePath. + * @deprecated Use the apiEndpoint method of the client instance. + * @returns {string} The DNS address for this service. + */ + static get apiEndpoint() { + if ( + typeof process === 'object' && + typeof process.emitWarning === 'function' + ) { + process.emitWarning( + 'Static apiEndpoint is deprecated, please use the instance method instead.', + 'DeprecationWarning', + ); + } + return 'resumable.googleapis.com'; + } + + /** + * The DNS address for this API service. + * @returns {string} The DNS address for this service. + */ + get apiEndpoint() { + return this._servicePath; + } + + get universeDomain() { + return this._universeDomain; + } + + /** + * The port for this API service. + * @returns {number} The default port for this service. + */ + static get port() { + return 443; + } + + /** + * The scopes needed to make gRPC calls for every method defined + * in this service. + * @returns {string[]} List of default scopes. + */ + static get scopes() { + return ['https://www.googleapis.com/auth/cloud-platform']; + } + + getProjectId(): Promise; + getProjectId(callback: Callback): void; + /** + * Return the project ID used by this class. + * @returns {Promise} A promise that resolves to string containing the project ID. + */ + getProjectId( + callback?: Callback, + ): Promise | void { + if (callback) { + this.auth.getProjectId(callback); + return; + } + return this.auth.getProjectId(); + } + + // ------------------- + // -- Service calls -- + // ------------------- + /** + * Returns the status of a previously created upload session. + * + * @param {Object} request + * The request object that will be sent. + * @param {string} request.uploadUrl + * @param {object} [options] + * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. + * @returns {Promise} - The promise which resolves to an array. + * The first element of the array is an object representing {@link protos.google.samples.resumable.v1.GetUploadStatusResponse|GetUploadStatusResponse}. + * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation } + * for more details and examples. + * @example include:samples/generated/v1/resumable_upload_service.get_upload_status.js + * region_tag:resumable_v1_generated_ResumableUploadService_GetUploadStatus_async + */ + getUploadStatus( + request?: protos.google.samples.resumable.v1.IGetUploadStatusRequest, + options?: CallOptions, + ): Promise< + [ + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + protos.google.samples.resumable.v1.IGetUploadStatusRequest | undefined, + {} | undefined, + ] + >; + getUploadStatus( + request: protos.google.samples.resumable.v1.IGetUploadStatusRequest, + options: CallOptions, + callback: Callback< + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | null + | undefined, + {} | null | undefined + >, + ): void; + getUploadStatus( + request: protos.google.samples.resumable.v1.IGetUploadStatusRequest, + callback: Callback< + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | null + | undefined, + {} | null | undefined + >, + ): void; + getUploadStatus( + request?: protos.google.samples.resumable.v1.IGetUploadStatusRequest, + optionsOrCallback?: + | CallOptions + | Callback< + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | null + | undefined, + {} | null | undefined + >, + callback?: Callback< + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | null + | undefined, + {} | null | undefined + >, + ): Promise< + [ + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + protos.google.samples.resumable.v1.IGetUploadStatusRequest | undefined, + {} | undefined, + ] + > | void { + request = request || {}; + let options: CallOptions; + if (typeof optionsOrCallback === 'function' && callback === undefined) { + callback = optionsOrCallback; + options = {}; + } else { + options = optionsOrCallback as CallOptions; + } + options = options || {}; + options.otherArgs = options.otherArgs || {}; + options.otherArgs.headers = options.otherArgs.headers || {}; + options.otherArgs.headers['x-goog-request-params'] = + this._gaxModule.routingHeader.fromParams({ + upload_url: request.uploadUrl ?? '', + }); + this.initialize().catch((err) => { + throw err; + }); + this._log.info('getUploadStatus request %j', request); + const wrappedCallback: + | Callback< + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | null + | undefined, + {} | null | undefined + > + | undefined = callback + ? (error, response, options, rawResponse) => { + this._log.info('getUploadStatus response %j', response); + callback!(error, response, options, rawResponse); // We verified callback above. + } + : undefined; + return this.innerApiCalls + .getUploadStatus(request, options, wrappedCallback) + ?.then( + ([response, options, rawResponse]: [ + protos.google.samples.resumable.v1.IGetUploadStatusResponse, + ( + | protos.google.samples.resumable.v1.IGetUploadStatusRequest + | undefined + ), + {} | undefined, + ]) => { + this._log.info('getUploadStatus response %j', response); + return [response, options, rawResponse]; + }, + ) + .catch((error: any) => { + if ( + error && + 'statusDetails' in error && + error.statusDetails instanceof Array + ) { + const protos = this._gaxModule.protobuf.Root.fromJSON( + jsonProtos, + ) as unknown as gax.protobuf.Type; + error.statusDetails = decodeAnyProtosInArray( + error.statusDetails, + protos, + ); + } + throw error; + }); + } + /** + * Creates a resumable upload session. + * + * @param {object} [request] - The request object. + * @param {object} [options] - Optional parameters. The upload stream, + * chunk size, progress callback, and resume URL are passed to + * {@link gax.ResumableUpload#start} instead. + * @returns {Promise} A resumable upload helper. Call + * `.start(uploadParams)` with the stream to upload, then await + * `.finished()` for the final RPC response. + */ + createResumableUpload( + request?: protos.google.samples.resumable.v1.ICreateResumableUploadRequest, + options?: CallOptions, + ): Promise { + request = request || {}; + options = options || {}; + this.initialize().catch((err) => { + throw err; + }); + this._log.info('createResumableUpload request %j', request); + return this.innerApiCalls['createResumableUpload'](request, { + ...options, + resumableUpload: { + auth: this._fallbackRest!.auth as gax.GoogleAuth, + servicePath: this._opts.servicePath ?? this._servicePath, + servicePort: this._opts.port || 443, + protocol: this._opts.protocol || 'https', + rpc: this._gaxModule.protobuf.Root.fromJSON(jsonProtos).lookupService( + 'google.samples.resumable.v1.ResumableUploadService', + ).methods['CreateResumableUpload'], + request, + uploadPrefix: '/resumable/upload', + numericEnums: this._opts.numericEnums, + minifyJson: this._opts.minifyJson, + }, + }).then(([helper]) => helper); + } + + /** + * Terminate the gRPC channel and close the client. + * + * The client will no longer be usable and all future behavior is undefined. + * @returns {Promise} A promise that resolves when the client is closed. + */ + close(): Promise { + if (this.resumableUploadServiceStub && !this._terminated) { + return this.resumableUploadServiceStub.then((stub) => { + this._log.info('ending gRPC channel'); + this._terminated = true; + stub.close(); + }); + } + return Promise.resolve(); + } +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_client_config.json.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_client_config.json.baseline new file mode 100644 index 000000000000..de3f9fed6441 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_client_config.json.baseline @@ -0,0 +1,34 @@ +{ + "interfaces": { + "google.samples.resumable.v1.ResumableUploadService": { + "retry_codes": { + "non_idempotent": [], + "idempotent": [ + "DEADLINE_EXCEEDED", + "UNAVAILABLE" + ] + }, + "retry_params": { + "default": { + "initial_retry_delay_millis": 100, + "retry_delay_multiplier": 1.3, + "max_retry_delay_millis": 60000, + "initial_rpc_timeout_millis": 60000, + "rpc_timeout_multiplier": 1, + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 600000 + } + }, + "methods": { + "CreateResumableUpload": { + "retry_codes_name": "non_idempotent", + "retry_params_name": "default" + }, + "GetUploadStatus": { + "retry_codes_name": "non_idempotent", + "retry_params_name": "default" + } + } + } + } +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_proto_list.json.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_proto_list.json.baseline new file mode 100644 index 000000000000..4acc3ac38ace --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/src/v1/resumable_upload_service_proto_list.json.baseline @@ -0,0 +1,3 @@ +[ + "../../protos/google/samples/resumable/v1/resumable.proto" +] diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/fixtures/sample/src/index.js.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/fixtures/sample/src/index.js.baseline new file mode 100644 index 000000000000..49a3b15d7ff1 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/fixtures/sample/src/index.js.baseline @@ -0,0 +1,27 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + + +/* eslint-disable node/no-missing-require, no-unused-vars */ +const resumable = require('resumable'); + +function main() { + const resumableUploadServiceClient = new resumable.ResumableUploadServiceClient(); +} + +main(); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/fixtures/sample/src/index.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/fixtures/sample/src/index.ts.baseline new file mode 100644 index 000000000000..696d7e2eda80 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/fixtures/sample/src/index.ts.baseline @@ -0,0 +1,34 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +import { ResumableUploadServiceClient } from 'resumable'; + +// check that the client class type name can be used +function doStuffWithResumableUploadServiceClient( + client: ResumableUploadServiceClient, +) { + client.close(); +} + +function main() { + // check that the client instance can be created + const resumableUploadServiceClient = new ResumableUploadServiceClient(); + doStuffWithResumableUploadServiceClient(resumableUploadServiceClient); +} + +main(); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/install.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/install.ts.baseline new file mode 100644 index 000000000000..ccf167042d2e --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/system-test/install.ts.baseline @@ -0,0 +1,51 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +import { packNTest } from 'pack-n-play'; +import { readFileSync } from 'fs'; +import { describe, it } from 'mocha'; + +describe('📦 pack-n-play test', () => { + it('TypeScript code', async function () { + this.timeout(300000); + const options = { + packageDir: process.cwd(), + sample: { + description: 'TypeScript user can use the type definitions', + ts: readFileSync( + './system-test/fixtures/sample/src/index.ts', + ).toString(), + }, + }; + await packNTest(options); + }); + + it('JavaScript code', async function () { + this.timeout(300000); + const options = { + packageDir: process.cwd(), + sample: { + description: 'JavaScript user can use the library', + cjs: readFileSync( + './system-test/fixtures/sample/src/index.js', + ).toString(), + }, + }; + await packNTest(options); + }); +}); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/test/gapic_resumable_upload_service_v1.ts.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/test/gapic_resumable_upload_service_v1.ts.baseline new file mode 100644 index 000000000000..eef22807a8df --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/test/gapic_resumable_upload_service_v1.ts.baseline @@ -0,0 +1,408 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// ** This file is automatically generated by gapic-generator-typescript. ** +// ** https://github.com/googleapis/gapic-generator-typescript ** +// ** All changes to this file may be overwritten. ** + +import * as protos from '../protos/protos'; +import * as assert from 'assert'; +import * as sinon from 'sinon'; +import { SinonStub } from 'sinon'; +import { describe, it } from 'mocha'; +import * as resumableuploadserviceModule from '../src'; + +import { protobuf } from 'google-gax'; + +// Dynamically loaded proto JSON is needed to get the type information +// to fill in default values for request objects +const root = protobuf.Root.fromJSON( + require('../protos/protos.json'), +).resolveAll(); + +// eslint-disable-next-line @typescript-eslint/no-unused-vars +function getTypeDefaultValue(typeName: string, fields: string[]) { + let type = root.lookupType(typeName) as protobuf.Type; + for (const field of fields.slice(0, -1)) { + type = type.fields[field]?.resolvedType as protobuf.Type; + } + return type.fields[fields[fields.length - 1]]?.defaultValue; +} + +function generateSampleMessage(instance: T) { + const filledObject = ( + instance.constructor as typeof protobuf.Message + ).toObject(instance as protobuf.Message, { defaults: true }); + return (instance.constructor as typeof protobuf.Message).fromObject( + filledObject, + ) as T; +} + +function stubSimpleCall(response?: ResponseType, error?: Error) { + return error + ? sinon.stub().rejects(error) + : sinon.stub().resolves([response]); +} + +function stubSimpleCallWithCallback( + response?: ResponseType, + error?: Error, +) { + return error + ? sinon.stub().callsArgWith(2, error) + : sinon.stub().callsArgWith(2, null, response); +} + +describe('v1.ResumableUploadServiceClient', () => { + describe('Common methods', () => { + it('has apiEndpoint', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient(); + const apiEndpoint = client.apiEndpoint; + assert.strictEqual(apiEndpoint, 'resumable.googleapis.com'); + }); + + it('has universeDomain', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient(); + const universeDomain = client.universeDomain; + assert.strictEqual(universeDomain, 'googleapis.com'); + }); + + if ( + typeof process === 'object' && + typeof process.emitWarning === 'function' + ) { + it('throws DeprecationWarning if static servicePath is used', () => { + const stub = sinon.stub(process, 'emitWarning'); + const servicePath = + resumableuploadserviceModule.v1.ResumableUploadServiceClient + .servicePath; + assert.strictEqual(servicePath, 'resumable.googleapis.com'); + assert(stub.called); + stub.restore(); + }); + + it('throws DeprecationWarning if static apiEndpoint is used', () => { + const stub = sinon.stub(process, 'emitWarning'); + const apiEndpoint = + resumableuploadserviceModule.v1.ResumableUploadServiceClient + .apiEndpoint; + assert.strictEqual(apiEndpoint, 'resumable.googleapis.com'); + assert(stub.called); + stub.restore(); + }); + } + it('sets apiEndpoint according to universe domain camelCase', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + universeDomain: 'example.com', + }); + const servicePath = client.apiEndpoint; + assert.strictEqual(servicePath, 'resumable.example.com'); + }); + + it('sets apiEndpoint according to universe domain snakeCase', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + universe_domain: 'example.com', + }); + const servicePath = client.apiEndpoint; + assert.strictEqual(servicePath, 'resumable.example.com'); + }); + + if (typeof process === 'object' && 'env' in process) { + describe('GOOGLE_CLOUD_UNIVERSE_DOMAIN environment variable', () => { + it('sets apiEndpoint from environment variable', () => { + const saved = process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN']; + process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN'] = 'example.com'; + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient(); + const servicePath = client.apiEndpoint; + assert.strictEqual(servicePath, 'resumable.example.com'); + if (saved) { + process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN'] = saved; + } else { + delete process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN']; + } + }); + + it('value configured in code has priority over environment variable', () => { + const saved = process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN']; + process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN'] = 'example.com'; + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + universeDomain: 'configured.example.com', + }); + const servicePath = client.apiEndpoint; + assert.strictEqual(servicePath, 'resumable.configured.example.com'); + if (saved) { + process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN'] = saved; + } else { + delete process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN']; + } + }); + }); + } + it('does not allow setting both universeDomain and universe_domain', () => { + assert.throws(() => { + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + universe_domain: 'example.com', + universeDomain: 'example.net', + }); + }); + }); + + it('has port', () => { + const port = + resumableuploadserviceModule.v1.ResumableUploadServiceClient.port; + assert(port); + assert(typeof port === 'number'); + }); + + it('should create a client with no option', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient(); + assert(client); + }); + + it('should create a client with gRPC fallback', () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + fallback: true, + }); + assert(client); + }); + + it('has initialize method and supports deferred initialization', async () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + assert.strictEqual(client.resumableUploadServiceStub, undefined); + await client.initialize(); + assert(client.resumableUploadServiceStub); + }); + + it('has close method for the initialized client', (done) => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + client.initialize().catch((err) => { + throw err; + }); + assert(client.resumableUploadServiceStub); + client + .close() + .then(() => { + done(); + }) + .catch((err) => { + throw err; + }); + }); + + it('has close method for the non-initialized client', (done) => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + assert.strictEqual(client.resumableUploadServiceStub, undefined); + client + .close() + .then(() => { + done(); + }) + .catch((err) => { + throw err; + }); + }); + + it('has getProjectId method', async () => { + const fakeProjectId = 'fake-project-id'; + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + client.auth.getProjectId = sinon.stub().resolves(fakeProjectId); + const result = await client.getProjectId(); + assert.strictEqual(result, fakeProjectId); + assert((client.auth.getProjectId as SinonStub).calledWithExactly()); + }); + + it('has getProjectId method with callback', async () => { + const fakeProjectId = 'fake-project-id'; + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + client.auth.getProjectId = sinon + .stub() + .callsArgWith(0, null, fakeProjectId); + const promise = new Promise((resolve, reject) => { + client.getProjectId((err?: Error | null, projectId?: string | null) => { + if (err) { + reject(err); + } else { + resolve(projectId); + } + }); + }); + const result = await promise; + assert.strictEqual(result, fakeProjectId); + }); + }); + + describe('getUploadStatus', () => { + it('invokes getUploadStatus without error', async () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + await client.initialize(); + const request = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusRequest(), + ); + const defaultValue1 = getTypeDefaultValue( + '.google.samples.resumable.v1.GetUploadStatusRequest', + ['uploadUrl'], + ); + request.uploadUrl = defaultValue1; + const expectedHeaderRequestParams = `upload_url=${defaultValue1 ?? ''}`; + const expectedResponse = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusResponse(), + ); + client.innerApiCalls.getUploadStatus = stubSimpleCall(expectedResponse); + const [response] = await client.getUploadStatus(request); + assert.deepStrictEqual(response, expectedResponse); + const actualRequest = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[0]; + assert.deepStrictEqual(actualRequest, request); + const actualHeaderRequestParams = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[1].otherArgs.headers['x-goog-request-params']; + assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams)); + }); + + it('invokes getUploadStatus without error using callback', async () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + await client.initialize(); + const request = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusRequest(), + ); + const defaultValue1 = getTypeDefaultValue( + '.google.samples.resumable.v1.GetUploadStatusRequest', + ['uploadUrl'], + ); + request.uploadUrl = defaultValue1; + const expectedHeaderRequestParams = `upload_url=${defaultValue1 ?? ''}`; + const expectedResponse = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusResponse(), + ); + client.innerApiCalls.getUploadStatus = + stubSimpleCallWithCallback(expectedResponse); + const promise = new Promise((resolve, reject) => { + client.getUploadStatus( + request, + ( + err?: Error | null, + result?: protos.google.samples.resumable.v1.IGetUploadStatusResponse | null, + ) => { + if (err) { + reject(err); + } else { + resolve(result); + } + }, + ); + }); + const response = await promise; + assert.deepStrictEqual(response, expectedResponse); + const actualRequest = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[0]; + assert.deepStrictEqual(actualRequest, request); + const actualHeaderRequestParams = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[1].otherArgs.headers['x-goog-request-params']; + assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams)); + }); + + it('invokes getUploadStatus with error', async () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + await client.initialize(); + const request = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusRequest(), + ); + const defaultValue1 = getTypeDefaultValue( + '.google.samples.resumable.v1.GetUploadStatusRequest', + ['uploadUrl'], + ); + request.uploadUrl = defaultValue1; + const expectedHeaderRequestParams = `upload_url=${defaultValue1 ?? ''}`; + const expectedError = new Error('expected'); + client.innerApiCalls.getUploadStatus = stubSimpleCall( + undefined, + expectedError, + ); + await assert.rejects(client.getUploadStatus(request), expectedError); + const actualRequest = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[0]; + assert.deepStrictEqual(actualRequest, request); + const actualHeaderRequestParams = ( + client.innerApiCalls.getUploadStatus as SinonStub + ).getCall(0).args[1].otherArgs.headers['x-goog-request-params']; + assert(actualHeaderRequestParams.includes(expectedHeaderRequestParams)); + }); + + it('invokes getUploadStatus with closed client', async () => { + const client = + new resumableuploadserviceModule.v1.ResumableUploadServiceClient({ + credentials: { client_email: 'bogus', private_key: 'bogus' }, + projectId: 'bogus', + }); + await client.initialize(); + const request = generateSampleMessage( + new protos.google.samples.resumable.v1.GetUploadStatusRequest(), + ); + const defaultValue1 = getTypeDefaultValue( + '.google.samples.resumable.v1.GetUploadStatusRequest', + ['uploadUrl'], + ); + request.uploadUrl = defaultValue1; + const expectedError = new Error('The client has already been closed.'); + client.close().catch((err) => { + throw err; + }); + await assert.rejects(client.getUploadStatus(request), expectedError); + }); + }); +}); diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/tsconfig.json.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/tsconfig.json.baseline new file mode 100644 index 000000000000..ca73e7bfc824 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/tsconfig.json.baseline @@ -0,0 +1,22 @@ +{ + "extends": "./node_modules/gts/tsconfig-google.json", + "compilerOptions": { + "rootDir": ".", + "outDir": "build", + "resolveJsonModule": true, + "lib": [ + "es2023", + "dom" + ] + }, + "include": [ + "src/*.ts", + "src/**/*.ts", + "test/*.ts", + "test/**/*.ts", + "system-test/*.ts", + "src/**/*.json", + "samples/**/*.json", + "protos/protos.json" + ] +} diff --git a/core/generator/gapic-generator-typescript/baselines/resumable-upload/webpack.config.js.baseline b/core/generator/gapic-generator-typescript/baselines/resumable-upload/webpack.config.js.baseline new file mode 100644 index 000000000000..0a553e060843 --- /dev/null +++ b/core/generator/gapic-generator-typescript/baselines/resumable-upload/webpack.config.js.baseline @@ -0,0 +1,64 @@ +// Copyright 2021 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +const path = require('path'); + +module.exports = { + entry: './src/index.ts', + output: { + library: 'ResumableUploadService', + filename: './resumable-upload-service.js', + }, + node: { + child_process: 'empty', + fs: 'empty', + crypto: 'empty', + }, + resolve: { + alias: { + '../../../package.json': path.resolve(__dirname, 'package.json'), + }, + extensions: ['.js', '.json', '.ts'], + }, + module: { + rules: [ + { + test: /\.tsx?$/, + use: 'ts-loader', + exclude: /node_modules/ + }, + { + test: /node_modules[\\/]@grpc[\\/]grpc-js/, + use: 'null-loader' + }, + { + test: /node_modules[\\/]grpc/, + use: 'null-loader' + }, + { + test: /node_modules[\\/]retry-request/, + use: 'null-loader' + }, + { + test: /node_modules[\\/]https?-proxy-agent/, + use: 'null-loader' + }, + { + test: /node_modules[\\/]gtoken/, + use: 'null-loader' + }, + ], + }, + mode: 'production', +}; diff --git a/core/generator/gapic-generator-typescript/package.json b/core/generator/gapic-generator-typescript/package.json index 4f5a44fefb6c..1d5824d8a9fb 100644 --- a/core/generator/gapic-generator-typescript/package.json +++ b/core/generator/gapic-generator-typescript/package.json @@ -30,8 +30,8 @@ "clean": "rm -rf build", "codecov": "c8 --reporter=lcov mocha build/typescript/test/unit && c8 report", "compile": "tsc && chmod +x build/typescript/src/gapic-generator-typescript.js build/typescript/src/protoc-plugin.js && cp -rf templates protos build/", - "compile-protos-json": "pbjs -t json -o protos/protos.json -p node_modules/google-gax/build/protos -p protos google/api/annotations.proto google/api/field_behavior.proto google/api/field_info.proto google/api/resource.proto google/api/routing.proto google/longrunning/operations.proto google/protobuf/compiler/plugin.proto service_config.proto snippet_index.proto", - "compile-protos-js": "pbjs -t static-module -o protos/index.js -p node_modules/google-gax/build/protos -p protos google/api/annotations.proto google/api/field_behavior.proto google/api/field_info.proto google/api/resource.proto google/api/routing.proto google/longrunning/operations.proto google/protobuf/compiler/plugin.proto service_config.proto snippet_index.proto", + "compile-protos-json": "pbjs -t json -o protos/protos.json -p node_modules/google-gax/build/protos -p protos google/api/annotations.proto google/api/field_behavior.proto google/api/field_info.proto google/api/media_upload.proto google/api/resource.proto google/api/routing.proto google/longrunning/operations.proto google/protobuf/compiler/plugin.proto service_config.proto snippet_index.proto", + "compile-protos-js": "pbjs -t static-module -o protos/index.js -p node_modules/google-gax/build/protos -p protos google/api/annotations.proto google/api/field_behavior.proto google/api/field_info.proto google/api/media_upload.proto google/api/resource.proto google/api/routing.proto google/longrunning/operations.proto google/protobuf/compiler/plugin.proto service_config.proto snippet_index.proto", "compile-protos-dts": "pbts protos/index.js -o protos/index.d.ts", "docker-test": "sh docker/test.sh", "fix": "gts fix", diff --git a/core/generator/gapic-generator-typescript/protos/google/api/media_upload.proto b/core/generator/gapic-generator-typescript/protos/google/api/media_upload.proto new file mode 100644 index 000000000000..f2deed02e29f --- /dev/null +++ b/core/generator/gapic-generator-typescript/protos/google/api/media_upload.proto @@ -0,0 +1,63 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// NOTE: This is a local copy of the pending `google/api/media_upload.proto` +// definition used to describe resumable upload methods. +// The official proto has not been published to googleapis yet; when it is, +// this file should be replaced by the upstream version and the protos bundle +// regenerated. Detection in the generator matches on the option name +// (`.google.api.mediaUpload`), so the extension number below is a +// placeholder that does not affect method identification. + +syntax = "proto3"; + +package google.api; + +import "google/api/annotations.proto"; +import "google/protobuf/descriptor.proto"; + +option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; + +// MediaUpload describes the media upload configuration for a method that +// opts into the resumable upload protocol. +message MediaUpload { + // Whether the method supports media upload. + bool enabled = 1; + + // The paths to which media upload commands are sent. When present, the + // first path is used as the upload prefix for the resumable upload + // session (for example, `/resumable/upload`). + repeated string media_upload_paths = 2; + + // Whether the server notifies the client when the session is started. + bool start_notification = 3; + + // Whether the server notifies the client on each upload command. + bool upload_notification = 4; + + // Whether the server notifies the client when the upload is finalized. + bool finalize_notification = 5; + + // The direct upload service to use, if any. + string direct_upload_service = 6; + + // How long, in seconds, an upload session may remain active. + int64 max_upload_session_duration_seconds = 7; +} + +// Defines a method as a media upload method. Methods annotated with this +// option are routed through the resumable upload protocol. +extend google.protobuf.MethodOptions { + MediaUpload media_upload = 1052; +} diff --git a/core/generator/gapic-generator-typescript/protos/index.d.ts b/core/generator/gapic-generator-typescript/protos/index.d.ts index 4e6264e440bb..d1b33625ff11 100644 --- a/core/generator/gapic-generator-typescript/protos/index.d.ts +++ b/core/generator/gapic-generator-typescript/protos/index.d.ts @@ -1810,6 +1810,139 @@ export namespace google { } } + /** Properties of a MediaUpload. */ + interface IMediaUpload { + + /** MediaUpload enabled */ + enabled?: (boolean|null); + + /** MediaUpload mediaUploadPaths */ + mediaUploadPaths?: (string[]|null); + + /** MediaUpload startNotification */ + startNotification?: (boolean|null); + + /** MediaUpload uploadNotification */ + uploadNotification?: (boolean|null); + + /** MediaUpload finalizeNotification */ + finalizeNotification?: (boolean|null); + + /** MediaUpload directUploadService */ + directUploadService?: (string|null); + + /** MediaUpload maxUploadSessionDurationSeconds */ + maxUploadSessionDurationSeconds?: (number|Long|null); + } + + /** Represents a MediaUpload. */ + class MediaUpload implements IMediaUpload { + + /** + * Constructs a new MediaUpload. + * @param [properties] Properties to set + */ + constructor(properties?: google.api.IMediaUpload); + + /** MediaUpload enabled. */ + public enabled: boolean; + + /** MediaUpload mediaUploadPaths. */ + public mediaUploadPaths: string[]; + + /** MediaUpload startNotification. */ + public startNotification: boolean; + + /** MediaUpload uploadNotification. */ + public uploadNotification: boolean; + + /** MediaUpload finalizeNotification. */ + public finalizeNotification: boolean; + + /** MediaUpload directUploadService. */ + public directUploadService: string; + + /** MediaUpload maxUploadSessionDurationSeconds. */ + public maxUploadSessionDurationSeconds: (number|Long); + + /** + * Creates a new MediaUpload instance using the specified properties. + * @param [properties] Properties to set + * @returns MediaUpload instance + */ + public static create(properties?: google.api.IMediaUpload): google.api.MediaUpload; + + /** + * Encodes the specified MediaUpload message. Does not implicitly {@link google.api.MediaUpload.verify|verify} messages. + * @param message MediaUpload message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: google.api.IMediaUpload, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified MediaUpload message, length delimited. Does not implicitly {@link google.api.MediaUpload.verify|verify} messages. + * @param message MediaUpload message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: google.api.IMediaUpload, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MediaUpload message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns MediaUpload + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): google.api.MediaUpload; + + /** + * Decodes a MediaUpload message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns MediaUpload + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): google.api.MediaUpload; + + /** + * Verifies a MediaUpload message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a MediaUpload message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns MediaUpload + */ + public static fromObject(object: { [k: string]: any }): google.api.MediaUpload; + + /** + * Creates a plain object from a MediaUpload message. Also converts values to other types if specified. + * @param message MediaUpload + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: google.api.MediaUpload, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this MediaUpload to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; + + /** + * Gets the default type url for MediaUpload + * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns The default type url + */ + public static getTypeUrl(typeUrlPrefix?: string): string; + } + /** Properties of a ResourceDescriptor. */ interface IResourceDescriptor { @@ -6675,6 +6808,9 @@ export namespace google { /** MethodOptions .google.api.http */ ".google.api.http"?: (google.api.IHttpRule|null); + /** MethodOptions .google.api.mediaUpload */ + ".google.api.mediaUpload"?: (google.api.IMediaUpload|null); + /** MethodOptions .google.api.routing */ ".google.api.routing"?: (google.api.IRoutingRule|null); diff --git a/core/generator/gapic-generator-typescript/protos/index.js b/core/generator/gapic-generator-typescript/protos/index.js index 1dec016c5e2a..c3060e8988d5 100644 --- a/core/generator/gapic-generator-typescript/protos/index.js +++ b/core/generator/gapic-generator-typescript/protos/index.js @@ -61,7 +61,7 @@ this.name = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -156,24 +156,28 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - MethodConfig.encode = function encode(message, writer) { + MethodConfig.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && message.name.length) for (var i = 0; i < message.name.length; ++i) - $root.grpc.service_config.MethodConfig.Name.encode(message.name[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.grpc.service_config.MethodConfig.Name.encode(message.name[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); if (message.waitForReady != null && Object.hasOwnProperty.call(message, "waitForReady")) - $root.google.protobuf.BoolValue.encode(message.waitForReady, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.BoolValue.encode(message.waitForReady, writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.timeout != null && Object.hasOwnProperty.call(message, "timeout")) - $root.google.protobuf.Duration.encode(message.timeout, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.protobuf.Duration.encode(message.timeout, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); if (message.maxRequestMessageBytes != null && Object.hasOwnProperty.call(message, "maxRequestMessageBytes")) - $root.google.protobuf.UInt32Value.encode(message.maxRequestMessageBytes, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.google.protobuf.UInt32Value.encode(message.maxRequestMessageBytes, writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); if (message.maxResponseMessageBytes != null && Object.hasOwnProperty.call(message, "maxResponseMessageBytes")) - $root.google.protobuf.UInt32Value.encode(message.maxResponseMessageBytes, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); + $root.google.protobuf.UInt32Value.encode(message.maxResponseMessageBytes, writer.uint32(/* id 5, wireType 2 =*/42).fork(), q + 1).ldelim(); if (message.retryPolicy != null && Object.hasOwnProperty.call(message, "retryPolicy")) - $root.grpc.service_config.MethodConfig.RetryPolicy.encode(message.retryPolicy, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim(); + $root.grpc.service_config.MethodConfig.RetryPolicy.encode(message.retryPolicy, writer.uint32(/* id 6, wireType 2 =*/50).fork(), q + 1).ldelim(); if (message.hedgingPolicy != null && Object.hasOwnProperty.call(message, "hedgingPolicy")) - $root.grpc.service_config.MethodConfig.HedgingPolicy.encode(message.hedgingPolicy, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim(); + $root.grpc.service_config.MethodConfig.HedgingPolicy.encode(message.hedgingPolicy, writer.uint32(/* id 7, wireType 2 =*/58).fork(), q + 1).ldelim(); return writer; }; @@ -201,45 +205,51 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - MethodConfig.decode = function decode(reader, length) { + MethodConfig.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.MethodConfig(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.name && message.name.length)) message.name = []; - message.name.push($root.grpc.service_config.MethodConfig.Name.decode(reader, reader.uint32())); + message.name.push($root.grpc.service_config.MethodConfig.Name.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 2: { - message.waitForReady = $root.google.protobuf.BoolValue.decode(reader, reader.uint32()); + message.waitForReady = $root.google.protobuf.BoolValue.decode(reader, reader.uint32(), undefined, long + 1); break; } case 3: { - message.timeout = $root.google.protobuf.Duration.decode(reader, reader.uint32()); + message.timeout = $root.google.protobuf.Duration.decode(reader, reader.uint32(), undefined, long + 1); break; } case 4: { - message.maxRequestMessageBytes = $root.google.protobuf.UInt32Value.decode(reader, reader.uint32()); + message.maxRequestMessageBytes = $root.google.protobuf.UInt32Value.decode(reader, reader.uint32(), undefined, long + 1); break; } case 5: { - message.maxResponseMessageBytes = $root.google.protobuf.UInt32Value.decode(reader, reader.uint32()); + message.maxResponseMessageBytes = $root.google.protobuf.UInt32Value.decode(reader, reader.uint32(), undefined, long + 1); break; } case 6: { - message.retryPolicy = $root.grpc.service_config.MethodConfig.RetryPolicy.decode(reader, reader.uint32()); + message.retryPolicy = $root.grpc.service_config.MethodConfig.RetryPolicy.decode(reader, reader.uint32(), undefined, long + 1); break; } case 7: { - message.hedgingPolicy = $root.grpc.service_config.MethodConfig.HedgingPolicy.decode(reader, reader.uint32()); + message.hedgingPolicy = $root.grpc.service_config.MethodConfig.HedgingPolicy.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -270,53 +280,57 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - MethodConfig.verify = function verify(message) { + MethodConfig.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; var properties = {}; - if (message.name != null && message.hasOwnProperty("name")) { + if (message.name != null && Object.hasOwnProperty.call(message, "name")) { if (!Array.isArray(message.name)) return "name: array expected"; for (var i = 0; i < message.name.length; ++i) { - var error = $root.grpc.service_config.MethodConfig.Name.verify(message.name[i]); + var error = $root.grpc.service_config.MethodConfig.Name.verify(message.name[i], long + 1); if (error) return "name." + error; } } - if (message.waitForReady != null && message.hasOwnProperty("waitForReady")) { - var error = $root.google.protobuf.BoolValue.verify(message.waitForReady); + if (message.waitForReady != null && Object.hasOwnProperty.call(message, "waitForReady")) { + var error = $root.google.protobuf.BoolValue.verify(message.waitForReady, long + 1); if (error) return "waitForReady." + error; } - if (message.timeout != null && message.hasOwnProperty("timeout")) { - var error = $root.google.protobuf.Duration.verify(message.timeout); + if (message.timeout != null && Object.hasOwnProperty.call(message, "timeout")) { + var error = $root.google.protobuf.Duration.verify(message.timeout, long + 1); if (error) return "timeout." + error; } - if (message.maxRequestMessageBytes != null && message.hasOwnProperty("maxRequestMessageBytes")) { - var error = $root.google.protobuf.UInt32Value.verify(message.maxRequestMessageBytes); + if (message.maxRequestMessageBytes != null && Object.hasOwnProperty.call(message, "maxRequestMessageBytes")) { + var error = $root.google.protobuf.UInt32Value.verify(message.maxRequestMessageBytes, long + 1); if (error) return "maxRequestMessageBytes." + error; } - if (message.maxResponseMessageBytes != null && message.hasOwnProperty("maxResponseMessageBytes")) { - var error = $root.google.protobuf.UInt32Value.verify(message.maxResponseMessageBytes); + if (message.maxResponseMessageBytes != null && Object.hasOwnProperty.call(message, "maxResponseMessageBytes")) { + var error = $root.google.protobuf.UInt32Value.verify(message.maxResponseMessageBytes, long + 1); if (error) return "maxResponseMessageBytes." + error; } - if (message.retryPolicy != null && message.hasOwnProperty("retryPolicy")) { + if (message.retryPolicy != null && Object.hasOwnProperty.call(message, "retryPolicy")) { properties.retryOrHedgingPolicy = 1; { - var error = $root.grpc.service_config.MethodConfig.RetryPolicy.verify(message.retryPolicy); + var error = $root.grpc.service_config.MethodConfig.RetryPolicy.verify(message.retryPolicy, long + 1); if (error) return "retryPolicy." + error; } } - if (message.hedgingPolicy != null && message.hasOwnProperty("hedgingPolicy")) { + if (message.hedgingPolicy != null && Object.hasOwnProperty.call(message, "hedgingPolicy")) { if (properties.retryOrHedgingPolicy === 1) return "retryOrHedgingPolicy: multiple values"; properties.retryOrHedgingPolicy = 1; { - var error = $root.grpc.service_config.MethodConfig.HedgingPolicy.verify(message.hedgingPolicy); + var error = $root.grpc.service_config.MethodConfig.HedgingPolicy.verify(message.hedgingPolicy, long + 1); if (error) return "hedgingPolicy." + error; } @@ -332,49 +346,55 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.MethodConfig} MethodConfig */ - MethodConfig.fromObject = function fromObject(object) { + MethodConfig.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.MethodConfig) return object; + if (!$util.isObject(object)) + throw TypeError(".grpc.service_config.MethodConfig: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.grpc.service_config.MethodConfig(); if (object.name) { if (!Array.isArray(object.name)) throw TypeError(".grpc.service_config.MethodConfig.name: array expected"); message.name = []; for (var i = 0; i < object.name.length; ++i) { - if (typeof object.name[i] !== "object") + if (!$util.isObject(object.name[i])) throw TypeError(".grpc.service_config.MethodConfig.name: object expected"); - message.name[i] = $root.grpc.service_config.MethodConfig.Name.fromObject(object.name[i]); + message.name[i] = $root.grpc.service_config.MethodConfig.Name.fromObject(object.name[i], long + 1); } } if (object.waitForReady != null) { - if (typeof object.waitForReady !== "object") + if (!$util.isObject(object.waitForReady)) throw TypeError(".grpc.service_config.MethodConfig.waitForReady: object expected"); - message.waitForReady = $root.google.protobuf.BoolValue.fromObject(object.waitForReady); + message.waitForReady = $root.google.protobuf.BoolValue.fromObject(object.waitForReady, long + 1); } if (object.timeout != null) { - if (typeof object.timeout !== "object") + if (!$util.isObject(object.timeout)) throw TypeError(".grpc.service_config.MethodConfig.timeout: object expected"); - message.timeout = $root.google.protobuf.Duration.fromObject(object.timeout); + message.timeout = $root.google.protobuf.Duration.fromObject(object.timeout, long + 1); } if (object.maxRequestMessageBytes != null) { - if (typeof object.maxRequestMessageBytes !== "object") + if (!$util.isObject(object.maxRequestMessageBytes)) throw TypeError(".grpc.service_config.MethodConfig.maxRequestMessageBytes: object expected"); - message.maxRequestMessageBytes = $root.google.protobuf.UInt32Value.fromObject(object.maxRequestMessageBytes); + message.maxRequestMessageBytes = $root.google.protobuf.UInt32Value.fromObject(object.maxRequestMessageBytes, long + 1); } if (object.maxResponseMessageBytes != null) { - if (typeof object.maxResponseMessageBytes !== "object") + if (!$util.isObject(object.maxResponseMessageBytes)) throw TypeError(".grpc.service_config.MethodConfig.maxResponseMessageBytes: object expected"); - message.maxResponseMessageBytes = $root.google.protobuf.UInt32Value.fromObject(object.maxResponseMessageBytes); + message.maxResponseMessageBytes = $root.google.protobuf.UInt32Value.fromObject(object.maxResponseMessageBytes, long + 1); } if (object.retryPolicy != null) { - if (typeof object.retryPolicy !== "object") + if (!$util.isObject(object.retryPolicy)) throw TypeError(".grpc.service_config.MethodConfig.retryPolicy: object expected"); - message.retryPolicy = $root.grpc.service_config.MethodConfig.RetryPolicy.fromObject(object.retryPolicy); + message.retryPolicy = $root.grpc.service_config.MethodConfig.RetryPolicy.fromObject(object.retryPolicy, long + 1); } if (object.hedgingPolicy != null) { - if (typeof object.hedgingPolicy !== "object") + if (!$util.isObject(object.hedgingPolicy)) throw TypeError(".grpc.service_config.MethodConfig.hedgingPolicy: object expected"); - message.hedgingPolicy = $root.grpc.service_config.MethodConfig.HedgingPolicy.fromObject(object.hedgingPolicy); + message.hedgingPolicy = $root.grpc.service_config.MethodConfig.HedgingPolicy.fromObject(object.hedgingPolicy, long + 1); } return message; }; @@ -388,9 +408,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - MethodConfig.toObject = function toObject(message, options) { + MethodConfig.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.name = []; @@ -403,23 +427,23 @@ if (message.name && message.name.length) { object.name = []; for (var j = 0; j < message.name.length; ++j) - object.name[j] = $root.grpc.service_config.MethodConfig.Name.toObject(message.name[j], options); - } - if (message.waitForReady != null && message.hasOwnProperty("waitForReady")) - object.waitForReady = $root.google.protobuf.BoolValue.toObject(message.waitForReady, options); - if (message.timeout != null && message.hasOwnProperty("timeout")) - object.timeout = $root.google.protobuf.Duration.toObject(message.timeout, options); - if (message.maxRequestMessageBytes != null && message.hasOwnProperty("maxRequestMessageBytes")) - object.maxRequestMessageBytes = $root.google.protobuf.UInt32Value.toObject(message.maxRequestMessageBytes, options); - if (message.maxResponseMessageBytes != null && message.hasOwnProperty("maxResponseMessageBytes")) - object.maxResponseMessageBytes = $root.google.protobuf.UInt32Value.toObject(message.maxResponseMessageBytes, options); - if (message.retryPolicy != null && message.hasOwnProperty("retryPolicy")) { - object.retryPolicy = $root.grpc.service_config.MethodConfig.RetryPolicy.toObject(message.retryPolicy, options); + object.name[j] = $root.grpc.service_config.MethodConfig.Name.toObject(message.name[j], options, q + 1); + } + if (message.waitForReady != null && Object.hasOwnProperty.call(message, "waitForReady")) + object.waitForReady = $root.google.protobuf.BoolValue.toObject(message.waitForReady, options, q + 1); + if (message.timeout != null && Object.hasOwnProperty.call(message, "timeout")) + object.timeout = $root.google.protobuf.Duration.toObject(message.timeout, options, q + 1); + if (message.maxRequestMessageBytes != null && Object.hasOwnProperty.call(message, "maxRequestMessageBytes")) + object.maxRequestMessageBytes = $root.google.protobuf.UInt32Value.toObject(message.maxRequestMessageBytes, options, q + 1); + if (message.maxResponseMessageBytes != null && Object.hasOwnProperty.call(message, "maxResponseMessageBytes")) + object.maxResponseMessageBytes = $root.google.protobuf.UInt32Value.toObject(message.maxResponseMessageBytes, options, q + 1); + if (message.retryPolicy != null && Object.hasOwnProperty.call(message, "retryPolicy")) { + object.retryPolicy = $root.grpc.service_config.MethodConfig.RetryPolicy.toObject(message.retryPolicy, options, q + 1); if (options.oneofs) object.retryOrHedgingPolicy = "retryPolicy"; } - if (message.hedgingPolicy != null && message.hasOwnProperty("hedgingPolicy")) { - object.hedgingPolicy = $root.grpc.service_config.MethodConfig.HedgingPolicy.toObject(message.hedgingPolicy, options); + if (message.hedgingPolicy != null && Object.hasOwnProperty.call(message, "hedgingPolicy")) { + object.hedgingPolicy = $root.grpc.service_config.MethodConfig.HedgingPolicy.toObject(message.hedgingPolicy, options, q + 1); if (options.oneofs) object.retryOrHedgingPolicy = "hedgingPolicy"; } @@ -473,7 +497,7 @@ function Name(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -514,9 +538,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Name.encode = function encode(message, writer) { + Name.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.service != null && Object.hasOwnProperty.call(message, "service")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.service); if (message.method != null && Object.hasOwnProperty.call(message, "method")) @@ -548,12 +576,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Name.decode = function decode(reader, length) { + Name.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.MethodConfig.Name(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.service = reader.string(); @@ -564,7 +598,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -595,13 +629,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Name.verify = function verify(message) { + Name.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.service != null && message.hasOwnProperty("service")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.service != null && Object.hasOwnProperty.call(message, "service")) if (!$util.isString(message.service)) return "service: string expected"; - if (message.method != null && message.hasOwnProperty("method")) + if (message.method != null && Object.hasOwnProperty.call(message, "method")) if (!$util.isString(message.method)) return "method: string expected"; return null; @@ -615,9 +653,15 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.MethodConfig.Name} Name */ - Name.fromObject = function fromObject(object) { + Name.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.MethodConfig.Name) return object; + if (!$util.isObject(object)) + throw TypeError(".grpc.service_config.MethodConfig.Name: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.grpc.service_config.MethodConfig.Name(); if (object.service != null) message.service = String(object.service); @@ -635,17 +679,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Name.toObject = function toObject(message, options) { + Name.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.service = ""; object.method = ""; } - if (message.service != null && message.hasOwnProperty("service")) + if (message.service != null && Object.hasOwnProperty.call(message, "service")) object.service = message.service; - if (message.method != null && message.hasOwnProperty("method")) + if (message.method != null && Object.hasOwnProperty.call(message, "method")) object.method = message.method; return object; }; @@ -704,7 +752,7 @@ this.retryableStatusCodes = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -769,15 +817,19 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - RetryPolicy.encode = function encode(message, writer) { + RetryPolicy.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.maxAttempts != null && Object.hasOwnProperty.call(message, "maxAttempts")) writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.maxAttempts); if (message.initialBackoff != null && Object.hasOwnProperty.call(message, "initialBackoff")) - $root.google.protobuf.Duration.encode(message.initialBackoff, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.Duration.encode(message.initialBackoff, writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.maxBackoff != null && Object.hasOwnProperty.call(message, "maxBackoff")) - $root.google.protobuf.Duration.encode(message.maxBackoff, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.protobuf.Duration.encode(message.maxBackoff, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); if (message.backoffMultiplier != null && Object.hasOwnProperty.call(message, "backoffMultiplier")) writer.uint32(/* id 4, wireType 5 =*/37).float(message.backoffMultiplier); if (message.retryableStatusCodes != null && message.retryableStatusCodes.length) { @@ -813,23 +865,29 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - RetryPolicy.decode = function decode(reader, length) { + RetryPolicy.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.MethodConfig.RetryPolicy(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.maxAttempts = reader.uint32(); break; } case 2: { - message.initialBackoff = $root.google.protobuf.Duration.decode(reader, reader.uint32()); + message.initialBackoff = $root.google.protobuf.Duration.decode(reader, reader.uint32(), undefined, long + 1); break; } case 3: { - message.maxBackoff = $root.google.protobuf.Duration.decode(reader, reader.uint32()); + message.maxBackoff = $root.google.protobuf.Duration.decode(reader, reader.uint32(), undefined, long + 1); break; } case 4: { @@ -848,7 +906,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -879,26 +937,30 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - RetryPolicy.verify = function verify(message) { + RetryPolicy.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.maxAttempts != null && message.hasOwnProperty("maxAttempts")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.maxAttempts != null && Object.hasOwnProperty.call(message, "maxAttempts")) if (!$util.isInteger(message.maxAttempts)) return "maxAttempts: integer expected"; - if (message.initialBackoff != null && message.hasOwnProperty("initialBackoff")) { - var error = $root.google.protobuf.Duration.verify(message.initialBackoff); + if (message.initialBackoff != null && Object.hasOwnProperty.call(message, "initialBackoff")) { + var error = $root.google.protobuf.Duration.verify(message.initialBackoff, long + 1); if (error) return "initialBackoff." + error; } - if (message.maxBackoff != null && message.hasOwnProperty("maxBackoff")) { - var error = $root.google.protobuf.Duration.verify(message.maxBackoff); + if (message.maxBackoff != null && Object.hasOwnProperty.call(message, "maxBackoff")) { + var error = $root.google.protobuf.Duration.verify(message.maxBackoff, long + 1); if (error) return "maxBackoff." + error; } - if (message.backoffMultiplier != null && message.hasOwnProperty("backoffMultiplier")) + if (message.backoffMultiplier != null && Object.hasOwnProperty.call(message, "backoffMultiplier")) if (typeof message.backoffMultiplier !== "number") return "backoffMultiplier: number expected"; - if (message.retryableStatusCodes != null && message.hasOwnProperty("retryableStatusCodes")) { + if (message.retryableStatusCodes != null && Object.hasOwnProperty.call(message, "retryableStatusCodes")) { if (!Array.isArray(message.retryableStatusCodes)) return "retryableStatusCodes: array expected"; for (var i = 0; i < message.retryableStatusCodes.length; ++i) @@ -936,21 +998,27 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.MethodConfig.RetryPolicy} RetryPolicy */ - RetryPolicy.fromObject = function fromObject(object) { + RetryPolicy.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.MethodConfig.RetryPolicy) return object; + if (!$util.isObject(object)) + throw TypeError(".grpc.service_config.MethodConfig.RetryPolicy: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.grpc.service_config.MethodConfig.RetryPolicy(); if (object.maxAttempts != null) message.maxAttempts = object.maxAttempts >>> 0; if (object.initialBackoff != null) { - if (typeof object.initialBackoff !== "object") + if (!$util.isObject(object.initialBackoff)) throw TypeError(".grpc.service_config.MethodConfig.RetryPolicy.initialBackoff: object expected"); - message.initialBackoff = $root.google.protobuf.Duration.fromObject(object.initialBackoff); + message.initialBackoff = $root.google.protobuf.Duration.fromObject(object.initialBackoff, long + 1); } if (object.maxBackoff != null) { - if (typeof object.maxBackoff !== "object") + if (!$util.isObject(object.maxBackoff)) throw TypeError(".grpc.service_config.MethodConfig.RetryPolicy.maxBackoff: object expected"); - message.maxBackoff = $root.google.protobuf.Duration.fromObject(object.maxBackoff); + message.maxBackoff = $root.google.protobuf.Duration.fromObject(object.maxBackoff, long + 1); } if (object.backoffMultiplier != null) message.backoffMultiplier = Number(object.backoffMultiplier); @@ -1047,9 +1115,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - RetryPolicy.toObject = function toObject(message, options) { + RetryPolicy.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.retryableStatusCodes = []; @@ -1059,13 +1131,13 @@ object.maxBackoff = null; object.backoffMultiplier = 0; } - if (message.maxAttempts != null && message.hasOwnProperty("maxAttempts")) + if (message.maxAttempts != null && Object.hasOwnProperty.call(message, "maxAttempts")) object.maxAttempts = message.maxAttempts; - if (message.initialBackoff != null && message.hasOwnProperty("initialBackoff")) - object.initialBackoff = $root.google.protobuf.Duration.toObject(message.initialBackoff, options); - if (message.maxBackoff != null && message.hasOwnProperty("maxBackoff")) - object.maxBackoff = $root.google.protobuf.Duration.toObject(message.maxBackoff, options); - if (message.backoffMultiplier != null && message.hasOwnProperty("backoffMultiplier")) + if (message.initialBackoff != null && Object.hasOwnProperty.call(message, "initialBackoff")) + object.initialBackoff = $root.google.protobuf.Duration.toObject(message.initialBackoff, options, q + 1); + if (message.maxBackoff != null && Object.hasOwnProperty.call(message, "maxBackoff")) + object.maxBackoff = $root.google.protobuf.Duration.toObject(message.maxBackoff, options, q + 1); + if (message.backoffMultiplier != null && Object.hasOwnProperty.call(message, "backoffMultiplier")) object.backoffMultiplier = options.json && !isFinite(message.backoffMultiplier) ? String(message.backoffMultiplier) : message.backoffMultiplier; if (message.retryableStatusCodes && message.retryableStatusCodes.length) { object.retryableStatusCodes = []; @@ -1127,7 +1199,7 @@ this.nonFatalStatusCodes = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -1176,13 +1248,17 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - HedgingPolicy.encode = function encode(message, writer) { + HedgingPolicy.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.maxAttempts != null && Object.hasOwnProperty.call(message, "maxAttempts")) writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.maxAttempts); if (message.hedgingDelay != null && Object.hasOwnProperty.call(message, "hedgingDelay")) - $root.google.protobuf.Duration.encode(message.hedgingDelay, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.Duration.encode(message.hedgingDelay, writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.nonFatalStatusCodes != null && message.nonFatalStatusCodes.length) { writer.uint32(/* id 3, wireType 2 =*/26).fork(); for (var i = 0; i < message.nonFatalStatusCodes.length; ++i) @@ -1216,19 +1292,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - HedgingPolicy.decode = function decode(reader, length) { + HedgingPolicy.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.MethodConfig.HedgingPolicy(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.maxAttempts = reader.uint32(); break; } case 2: { - message.hedgingDelay = $root.google.protobuf.Duration.decode(reader, reader.uint32()); + message.hedgingDelay = $root.google.protobuf.Duration.decode(reader, reader.uint32(), undefined, long + 1); break; } case 3: { @@ -1243,7 +1325,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -1274,18 +1356,22 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - HedgingPolicy.verify = function verify(message) { + HedgingPolicy.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.maxAttempts != null && message.hasOwnProperty("maxAttempts")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.maxAttempts != null && Object.hasOwnProperty.call(message, "maxAttempts")) if (!$util.isInteger(message.maxAttempts)) return "maxAttempts: integer expected"; - if (message.hedgingDelay != null && message.hasOwnProperty("hedgingDelay")) { - var error = $root.google.protobuf.Duration.verify(message.hedgingDelay); + if (message.hedgingDelay != null && Object.hasOwnProperty.call(message, "hedgingDelay")) { + var error = $root.google.protobuf.Duration.verify(message.hedgingDelay, long + 1); if (error) return "hedgingDelay." + error; } - if (message.nonFatalStatusCodes != null && message.hasOwnProperty("nonFatalStatusCodes")) { + if (message.nonFatalStatusCodes != null && Object.hasOwnProperty.call(message, "nonFatalStatusCodes")) { if (!Array.isArray(message.nonFatalStatusCodes)) return "nonFatalStatusCodes: array expected"; for (var i = 0; i < message.nonFatalStatusCodes.length; ++i) @@ -1323,16 +1409,22 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.MethodConfig.HedgingPolicy} HedgingPolicy */ - HedgingPolicy.fromObject = function fromObject(object) { + HedgingPolicy.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.MethodConfig.HedgingPolicy) return object; + if (!$util.isObject(object)) + throw TypeError(".grpc.service_config.MethodConfig.HedgingPolicy: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.grpc.service_config.MethodConfig.HedgingPolicy(); if (object.maxAttempts != null) message.maxAttempts = object.maxAttempts >>> 0; if (object.hedgingDelay != null) { - if (typeof object.hedgingDelay !== "object") + if (!$util.isObject(object.hedgingDelay)) throw TypeError(".grpc.service_config.MethodConfig.HedgingPolicy.hedgingDelay: object expected"); - message.hedgingDelay = $root.google.protobuf.Duration.fromObject(object.hedgingDelay); + message.hedgingDelay = $root.google.protobuf.Duration.fromObject(object.hedgingDelay, long + 1); } if (object.nonFatalStatusCodes) { if (!Array.isArray(object.nonFatalStatusCodes)) @@ -1427,9 +1519,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - HedgingPolicy.toObject = function toObject(message, options) { + HedgingPolicy.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.nonFatalStatusCodes = []; @@ -1437,10 +1533,10 @@ object.maxAttempts = 0; object.hedgingDelay = null; } - if (message.maxAttempts != null && message.hasOwnProperty("maxAttempts")) + if (message.maxAttempts != null && Object.hasOwnProperty.call(message, "maxAttempts")) object.maxAttempts = message.maxAttempts; - if (message.hedgingDelay != null && message.hasOwnProperty("hedgingDelay")) - object.hedgingDelay = $root.google.protobuf.Duration.toObject(message.hedgingDelay, options); + if (message.hedgingDelay != null && Object.hasOwnProperty.call(message, "hedgingDelay")) + object.hedgingDelay = $root.google.protobuf.Duration.toObject(message.hedgingDelay, options, q + 1); if (message.nonFatalStatusCodes && message.nonFatalStatusCodes.length) { object.nonFatalStatusCodes = []; for (var j = 0; j < message.nonFatalStatusCodes.length; ++j) @@ -1500,7 +1596,7 @@ function PickFirstConfig(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -1525,9 +1621,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - PickFirstConfig.encode = function encode(message, writer) { + PickFirstConfig.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); return writer; }; @@ -1555,15 +1655,21 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - PickFirstConfig.decode = function decode(reader, length) { + PickFirstConfig.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.PickFirstConfig(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -1594,9 +1700,13 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - PickFirstConfig.verify = function verify(message) { + PickFirstConfig.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; return null; }; @@ -1608,7 +1718,7 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.PickFirstConfig} PickFirstConfig */ - PickFirstConfig.fromObject = function fromObject(object) { + PickFirstConfig.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.PickFirstConfig) return object; return new $root.grpc.service_config.PickFirstConfig(); @@ -1675,7 +1785,7 @@ function RoundRobinConfig(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -1700,9 +1810,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - RoundRobinConfig.encode = function encode(message, writer) { + RoundRobinConfig.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); return writer; }; @@ -1730,15 +1844,21 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - RoundRobinConfig.decode = function decode(reader, length) { + RoundRobinConfig.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.RoundRobinConfig(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -1769,9 +1889,13 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - RoundRobinConfig.verify = function verify(message) { + RoundRobinConfig.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; return null; }; @@ -1783,7 +1907,7 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.RoundRobinConfig} RoundRobinConfig */ - RoundRobinConfig.fromObject = function fromObject(object) { + RoundRobinConfig.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.RoundRobinConfig) return object; return new $root.grpc.service_config.RoundRobinConfig(); @@ -1852,7 +1976,7 @@ this.childPolicy = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -1885,12 +2009,16 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - GrpcLbConfig.encode = function encode(message, writer) { + GrpcLbConfig.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.childPolicy != null && message.childPolicy.length) for (var i = 0; i < message.childPolicy.length; ++i) - $root.grpc.service_config.LoadBalancingConfig.encode(message.childPolicy[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.grpc.service_config.LoadBalancingConfig.encode(message.childPolicy[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -1918,21 +2046,27 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - GrpcLbConfig.decode = function decode(reader, length) { + GrpcLbConfig.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.GrpcLbConfig(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.childPolicy && message.childPolicy.length)) message.childPolicy = []; - message.childPolicy.push($root.grpc.service_config.LoadBalancingConfig.decode(reader, reader.uint32())); + message.childPolicy.push($root.grpc.service_config.LoadBalancingConfig.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -1963,14 +2097,18 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - GrpcLbConfig.verify = function verify(message) { + GrpcLbConfig.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.childPolicy != null && message.hasOwnProperty("childPolicy")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.childPolicy != null && Object.hasOwnProperty.call(message, "childPolicy")) { if (!Array.isArray(message.childPolicy)) return "childPolicy: array expected"; for (var i = 0; i < message.childPolicy.length; ++i) { - var error = $root.grpc.service_config.LoadBalancingConfig.verify(message.childPolicy[i]); + var error = $root.grpc.service_config.LoadBalancingConfig.verify(message.childPolicy[i], long + 1); if (error) return "childPolicy." + error; } @@ -1986,18 +2124,24 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.GrpcLbConfig} GrpcLbConfig */ - GrpcLbConfig.fromObject = function fromObject(object) { + GrpcLbConfig.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.GrpcLbConfig) return object; + if (!$util.isObject(object)) + throw TypeError(".grpc.service_config.GrpcLbConfig: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.grpc.service_config.GrpcLbConfig(); if (object.childPolicy) { if (!Array.isArray(object.childPolicy)) throw TypeError(".grpc.service_config.GrpcLbConfig.childPolicy: array expected"); message.childPolicy = []; for (var i = 0; i < object.childPolicy.length; ++i) { - if (typeof object.childPolicy[i] !== "object") + if (!$util.isObject(object.childPolicy[i])) throw TypeError(".grpc.service_config.GrpcLbConfig.childPolicy: object expected"); - message.childPolicy[i] = $root.grpc.service_config.LoadBalancingConfig.fromObject(object.childPolicy[i]); + message.childPolicy[i] = $root.grpc.service_config.LoadBalancingConfig.fromObject(object.childPolicy[i], long + 1); } } return message; @@ -2012,16 +2156,20 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - GrpcLbConfig.toObject = function toObject(message, options) { + GrpcLbConfig.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.childPolicy = []; if (message.childPolicy && message.childPolicy.length) { object.childPolicy = []; for (var j = 0; j < message.childPolicy.length; ++j) - object.childPolicy[j] = $root.grpc.service_config.LoadBalancingConfig.toObject(message.childPolicy[j], options); + object.childPolicy[j] = $root.grpc.service_config.LoadBalancingConfig.toObject(message.childPolicy[j], options, q + 1); } return object; }; @@ -2079,7 +2227,7 @@ this.fallbackPolicy = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -2128,17 +2276,21 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - XdsConfig.encode = function encode(message, writer) { + XdsConfig.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.balancerName != null && Object.hasOwnProperty.call(message, "balancerName")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.balancerName); if (message.childPolicy != null && message.childPolicy.length) for (var i = 0; i < message.childPolicy.length; ++i) - $root.grpc.service_config.LoadBalancingConfig.encode(message.childPolicy[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.grpc.service_config.LoadBalancingConfig.encode(message.childPolicy[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.fallbackPolicy != null && message.fallbackPolicy.length) for (var i = 0; i < message.fallbackPolicy.length; ++i) - $root.grpc.service_config.LoadBalancingConfig.encode(message.fallbackPolicy[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.grpc.service_config.LoadBalancingConfig.encode(message.fallbackPolicy[i], writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); return writer; }; @@ -2166,12 +2318,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - XdsConfig.decode = function decode(reader, length) { + XdsConfig.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.XdsConfig(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.balancerName = reader.string(); @@ -2180,17 +2338,17 @@ case 2: { if (!(message.childPolicy && message.childPolicy.length)) message.childPolicy = []; - message.childPolicy.push($root.grpc.service_config.LoadBalancingConfig.decode(reader, reader.uint32())); + message.childPolicy.push($root.grpc.service_config.LoadBalancingConfig.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 3: { if (!(message.fallbackPolicy && message.fallbackPolicy.length)) message.fallbackPolicy = []; - message.fallbackPolicy.push($root.grpc.service_config.LoadBalancingConfig.decode(reader, reader.uint32())); + message.fallbackPolicy.push($root.grpc.service_config.LoadBalancingConfig.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -2221,26 +2379,30 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - XdsConfig.verify = function verify(message) { + XdsConfig.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.balancerName != null && message.hasOwnProperty("balancerName")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.balancerName != null && Object.hasOwnProperty.call(message, "balancerName")) if (!$util.isString(message.balancerName)) return "balancerName: string expected"; - if (message.childPolicy != null && message.hasOwnProperty("childPolicy")) { + if (message.childPolicy != null && Object.hasOwnProperty.call(message, "childPolicy")) { if (!Array.isArray(message.childPolicy)) return "childPolicy: array expected"; for (var i = 0; i < message.childPolicy.length; ++i) { - var error = $root.grpc.service_config.LoadBalancingConfig.verify(message.childPolicy[i]); + var error = $root.grpc.service_config.LoadBalancingConfig.verify(message.childPolicy[i], long + 1); if (error) return "childPolicy." + error; } } - if (message.fallbackPolicy != null && message.hasOwnProperty("fallbackPolicy")) { + if (message.fallbackPolicy != null && Object.hasOwnProperty.call(message, "fallbackPolicy")) { if (!Array.isArray(message.fallbackPolicy)) return "fallbackPolicy: array expected"; for (var i = 0; i < message.fallbackPolicy.length; ++i) { - var error = $root.grpc.service_config.LoadBalancingConfig.verify(message.fallbackPolicy[i]); + var error = $root.grpc.service_config.LoadBalancingConfig.verify(message.fallbackPolicy[i], long + 1); if (error) return "fallbackPolicy." + error; } @@ -2256,9 +2418,15 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.XdsConfig} XdsConfig */ - XdsConfig.fromObject = function fromObject(object) { + XdsConfig.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.XdsConfig) return object; + if (!$util.isObject(object)) + throw TypeError(".grpc.service_config.XdsConfig: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.grpc.service_config.XdsConfig(); if (object.balancerName != null) message.balancerName = String(object.balancerName); @@ -2267,9 +2435,9 @@ throw TypeError(".grpc.service_config.XdsConfig.childPolicy: array expected"); message.childPolicy = []; for (var i = 0; i < object.childPolicy.length; ++i) { - if (typeof object.childPolicy[i] !== "object") + if (!$util.isObject(object.childPolicy[i])) throw TypeError(".grpc.service_config.XdsConfig.childPolicy: object expected"); - message.childPolicy[i] = $root.grpc.service_config.LoadBalancingConfig.fromObject(object.childPolicy[i]); + message.childPolicy[i] = $root.grpc.service_config.LoadBalancingConfig.fromObject(object.childPolicy[i], long + 1); } } if (object.fallbackPolicy) { @@ -2277,9 +2445,9 @@ throw TypeError(".grpc.service_config.XdsConfig.fallbackPolicy: array expected"); message.fallbackPolicy = []; for (var i = 0; i < object.fallbackPolicy.length; ++i) { - if (typeof object.fallbackPolicy[i] !== "object") + if (!$util.isObject(object.fallbackPolicy[i])) throw TypeError(".grpc.service_config.XdsConfig.fallbackPolicy: object expected"); - message.fallbackPolicy[i] = $root.grpc.service_config.LoadBalancingConfig.fromObject(object.fallbackPolicy[i]); + message.fallbackPolicy[i] = $root.grpc.service_config.LoadBalancingConfig.fromObject(object.fallbackPolicy[i], long + 1); } } return message; @@ -2294,9 +2462,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - XdsConfig.toObject = function toObject(message, options) { + XdsConfig.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.childPolicy = []; @@ -2304,17 +2476,17 @@ } if (options.defaults) object.balancerName = ""; - if (message.balancerName != null && message.hasOwnProperty("balancerName")) + if (message.balancerName != null && Object.hasOwnProperty.call(message, "balancerName")) object.balancerName = message.balancerName; if (message.childPolicy && message.childPolicy.length) { object.childPolicy = []; for (var j = 0; j < message.childPolicy.length; ++j) - object.childPolicy[j] = $root.grpc.service_config.LoadBalancingConfig.toObject(message.childPolicy[j], options); + object.childPolicy[j] = $root.grpc.service_config.LoadBalancingConfig.toObject(message.childPolicy[j], options, q + 1); } if (message.fallbackPolicy && message.fallbackPolicy.length) { object.fallbackPolicy = []; for (var j = 0; j < message.fallbackPolicy.length; ++j) - object.fallbackPolicy[j] = $root.grpc.service_config.LoadBalancingConfig.toObject(message.fallbackPolicy[j], options); + object.fallbackPolicy[j] = $root.grpc.service_config.LoadBalancingConfig.toObject(message.fallbackPolicy[j], options, q + 1); } return object; }; @@ -2372,7 +2544,7 @@ function LoadBalancingConfig(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -2451,19 +2623,23 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - LoadBalancingConfig.encode = function encode(message, writer) { + LoadBalancingConfig.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.roundRobin != null && Object.hasOwnProperty.call(message, "roundRobin")) - $root.grpc.service_config.RoundRobinConfig.encode(message.roundRobin, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.grpc.service_config.RoundRobinConfig.encode(message.roundRobin, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); if (message.xds != null && Object.hasOwnProperty.call(message, "xds")) - $root.grpc.service_config.XdsConfig.encode(message.xds, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.grpc.service_config.XdsConfig.encode(message.xds, writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.grpclb != null && Object.hasOwnProperty.call(message, "grpclb")) - $root.grpc.service_config.GrpcLbConfig.encode(message.grpclb, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.grpc.service_config.GrpcLbConfig.encode(message.grpclb, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); if (message.pickFirst != null && Object.hasOwnProperty.call(message, "pickFirst")) - $root.grpc.service_config.PickFirstConfig.encode(message.pickFirst, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.grpc.service_config.PickFirstConfig.encode(message.pickFirst, writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); if (message.xdsExperimental != null && Object.hasOwnProperty.call(message, "xdsExperimental")) - $root.grpc.service_config.XdsConfig.encode(message.xdsExperimental, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); + $root.grpc.service_config.XdsConfig.encode(message.xdsExperimental, writer.uint32(/* id 5, wireType 2 =*/42).fork(), q + 1).ldelim(); return writer; }; @@ -2491,35 +2667,41 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - LoadBalancingConfig.decode = function decode(reader, length) { + LoadBalancingConfig.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.LoadBalancingConfig(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 4: { - message.pickFirst = $root.grpc.service_config.PickFirstConfig.decode(reader, reader.uint32()); + message.pickFirst = $root.grpc.service_config.PickFirstConfig.decode(reader, reader.uint32(), undefined, long + 1); break; } case 1: { - message.roundRobin = $root.grpc.service_config.RoundRobinConfig.decode(reader, reader.uint32()); + message.roundRobin = $root.grpc.service_config.RoundRobinConfig.decode(reader, reader.uint32(), undefined, long + 1); break; } case 3: { - message.grpclb = $root.grpc.service_config.GrpcLbConfig.decode(reader, reader.uint32()); + message.grpclb = $root.grpc.service_config.GrpcLbConfig.decode(reader, reader.uint32(), undefined, long + 1); break; } case 2: { - message.xds = $root.grpc.service_config.XdsConfig.decode(reader, reader.uint32()); + message.xds = $root.grpc.service_config.XdsConfig.decode(reader, reader.uint32(), undefined, long + 1); break; } case 5: { - message.xdsExperimental = $root.grpc.service_config.XdsConfig.decode(reader, reader.uint32()); + message.xdsExperimental = $root.grpc.service_config.XdsConfig.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -2550,54 +2732,58 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - LoadBalancingConfig.verify = function verify(message) { + LoadBalancingConfig.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; var properties = {}; - if (message.pickFirst != null && message.hasOwnProperty("pickFirst")) { + if (message.pickFirst != null && Object.hasOwnProperty.call(message, "pickFirst")) { properties.policy = 1; { - var error = $root.grpc.service_config.PickFirstConfig.verify(message.pickFirst); + var error = $root.grpc.service_config.PickFirstConfig.verify(message.pickFirst, long + 1); if (error) return "pickFirst." + error; } } - if (message.roundRobin != null && message.hasOwnProperty("roundRobin")) { + if (message.roundRobin != null && Object.hasOwnProperty.call(message, "roundRobin")) { if (properties.policy === 1) return "policy: multiple values"; properties.policy = 1; { - var error = $root.grpc.service_config.RoundRobinConfig.verify(message.roundRobin); + var error = $root.grpc.service_config.RoundRobinConfig.verify(message.roundRobin, long + 1); if (error) return "roundRobin." + error; } } - if (message.grpclb != null && message.hasOwnProperty("grpclb")) { + if (message.grpclb != null && Object.hasOwnProperty.call(message, "grpclb")) { if (properties.policy === 1) return "policy: multiple values"; properties.policy = 1; { - var error = $root.grpc.service_config.GrpcLbConfig.verify(message.grpclb); + var error = $root.grpc.service_config.GrpcLbConfig.verify(message.grpclb, long + 1); if (error) return "grpclb." + error; } } - if (message.xds != null && message.hasOwnProperty("xds")) { + if (message.xds != null && Object.hasOwnProperty.call(message, "xds")) { if (properties.policy === 1) return "policy: multiple values"; properties.policy = 1; { - var error = $root.grpc.service_config.XdsConfig.verify(message.xds); + var error = $root.grpc.service_config.XdsConfig.verify(message.xds, long + 1); if (error) return "xds." + error; } } - if (message.xdsExperimental != null && message.hasOwnProperty("xdsExperimental")) { + if (message.xdsExperimental != null && Object.hasOwnProperty.call(message, "xdsExperimental")) { if (properties.policy === 1) return "policy: multiple values"; properties.policy = 1; { - var error = $root.grpc.service_config.XdsConfig.verify(message.xdsExperimental); + var error = $root.grpc.service_config.XdsConfig.verify(message.xdsExperimental, long + 1); if (error) return "xdsExperimental." + error; } @@ -2613,34 +2799,40 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.LoadBalancingConfig} LoadBalancingConfig */ - LoadBalancingConfig.fromObject = function fromObject(object) { + LoadBalancingConfig.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.LoadBalancingConfig) return object; + if (!$util.isObject(object)) + throw TypeError(".grpc.service_config.LoadBalancingConfig: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.grpc.service_config.LoadBalancingConfig(); if (object.pickFirst != null) { - if (typeof object.pickFirst !== "object") + if (!$util.isObject(object.pickFirst)) throw TypeError(".grpc.service_config.LoadBalancingConfig.pickFirst: object expected"); - message.pickFirst = $root.grpc.service_config.PickFirstConfig.fromObject(object.pickFirst); + message.pickFirst = $root.grpc.service_config.PickFirstConfig.fromObject(object.pickFirst, long + 1); } if (object.roundRobin != null) { - if (typeof object.roundRobin !== "object") + if (!$util.isObject(object.roundRobin)) throw TypeError(".grpc.service_config.LoadBalancingConfig.roundRobin: object expected"); - message.roundRobin = $root.grpc.service_config.RoundRobinConfig.fromObject(object.roundRobin); + message.roundRobin = $root.grpc.service_config.RoundRobinConfig.fromObject(object.roundRobin, long + 1); } if (object.grpclb != null) { - if (typeof object.grpclb !== "object") + if (!$util.isObject(object.grpclb)) throw TypeError(".grpc.service_config.LoadBalancingConfig.grpclb: object expected"); - message.grpclb = $root.grpc.service_config.GrpcLbConfig.fromObject(object.grpclb); + message.grpclb = $root.grpc.service_config.GrpcLbConfig.fromObject(object.grpclb, long + 1); } if (object.xds != null) { - if (typeof object.xds !== "object") + if (!$util.isObject(object.xds)) throw TypeError(".grpc.service_config.LoadBalancingConfig.xds: object expected"); - message.xds = $root.grpc.service_config.XdsConfig.fromObject(object.xds); + message.xds = $root.grpc.service_config.XdsConfig.fromObject(object.xds, long + 1); } if (object.xdsExperimental != null) { - if (typeof object.xdsExperimental !== "object") + if (!$util.isObject(object.xdsExperimental)) throw TypeError(".grpc.service_config.LoadBalancingConfig.xdsExperimental: object expected"); - message.xdsExperimental = $root.grpc.service_config.XdsConfig.fromObject(object.xdsExperimental); + message.xdsExperimental = $root.grpc.service_config.XdsConfig.fromObject(object.xdsExperimental, long + 1); } return message; }; @@ -2654,32 +2846,36 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - LoadBalancingConfig.toObject = function toObject(message, options) { + LoadBalancingConfig.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; - if (message.roundRobin != null && message.hasOwnProperty("roundRobin")) { - object.roundRobin = $root.grpc.service_config.RoundRobinConfig.toObject(message.roundRobin, options); + if (message.roundRobin != null && Object.hasOwnProperty.call(message, "roundRobin")) { + object.roundRobin = $root.grpc.service_config.RoundRobinConfig.toObject(message.roundRobin, options, q + 1); if (options.oneofs) object.policy = "roundRobin"; } - if (message.xds != null && message.hasOwnProperty("xds")) { - object.xds = $root.grpc.service_config.XdsConfig.toObject(message.xds, options); + if (message.xds != null && Object.hasOwnProperty.call(message, "xds")) { + object.xds = $root.grpc.service_config.XdsConfig.toObject(message.xds, options, q + 1); if (options.oneofs) object.policy = "xds"; } - if (message.grpclb != null && message.hasOwnProperty("grpclb")) { - object.grpclb = $root.grpc.service_config.GrpcLbConfig.toObject(message.grpclb, options); + if (message.grpclb != null && Object.hasOwnProperty.call(message, "grpclb")) { + object.grpclb = $root.grpc.service_config.GrpcLbConfig.toObject(message.grpclb, options, q + 1); if (options.oneofs) object.policy = "grpclb"; } - if (message.pickFirst != null && message.hasOwnProperty("pickFirst")) { - object.pickFirst = $root.grpc.service_config.PickFirstConfig.toObject(message.pickFirst, options); + if (message.pickFirst != null && Object.hasOwnProperty.call(message, "pickFirst")) { + object.pickFirst = $root.grpc.service_config.PickFirstConfig.toObject(message.pickFirst, options, q + 1); if (options.oneofs) object.policy = "pickFirst"; } - if (message.xdsExperimental != null && message.hasOwnProperty("xdsExperimental")) { - object.xdsExperimental = $root.grpc.service_config.XdsConfig.toObject(message.xdsExperimental, options); + if (message.xdsExperimental != null && Object.hasOwnProperty.call(message, "xdsExperimental")) { + object.xdsExperimental = $root.grpc.service_config.XdsConfig.toObject(message.xdsExperimental, options, q + 1); if (options.oneofs) object.policy = "xdsExperimental"; } @@ -2741,7 +2937,7 @@ this.methodConfig = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -2806,21 +3002,25 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ServiceConfig.encode = function encode(message, writer) { + ServiceConfig.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.loadBalancingPolicy != null && Object.hasOwnProperty.call(message, "loadBalancingPolicy")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.loadBalancingPolicy); if (message.methodConfig != null && message.methodConfig.length) for (var i = 0; i < message.methodConfig.length; ++i) - $root.grpc.service_config.MethodConfig.encode(message.methodConfig[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.grpc.service_config.MethodConfig.encode(message.methodConfig[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.retryThrottling != null && Object.hasOwnProperty.call(message, "retryThrottling")) - $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy.encode(message.retryThrottling, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy.encode(message.retryThrottling, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); if (message.loadBalancingConfig != null && message.loadBalancingConfig.length) for (var i = 0; i < message.loadBalancingConfig.length; ++i) - $root.grpc.service_config.LoadBalancingConfig.encode(message.loadBalancingConfig[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.grpc.service_config.LoadBalancingConfig.encode(message.loadBalancingConfig[i], writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); if (message.healthCheckConfig != null && Object.hasOwnProperty.call(message, "healthCheckConfig")) - $root.grpc.service_config.ServiceConfig.HealthCheckConfig.encode(message.healthCheckConfig, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); + $root.grpc.service_config.ServiceConfig.HealthCheckConfig.encode(message.healthCheckConfig, writer.uint32(/* id 5, wireType 2 =*/42).fork(), q + 1).ldelim(); return writer; }; @@ -2848,12 +3048,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ServiceConfig.decode = function decode(reader, length) { + ServiceConfig.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.ServiceConfig(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.loadBalancingPolicy = reader.int32(); @@ -2862,25 +3068,25 @@ case 4: { if (!(message.loadBalancingConfig && message.loadBalancingConfig.length)) message.loadBalancingConfig = []; - message.loadBalancingConfig.push($root.grpc.service_config.LoadBalancingConfig.decode(reader, reader.uint32())); + message.loadBalancingConfig.push($root.grpc.service_config.LoadBalancingConfig.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 2: { if (!(message.methodConfig && message.methodConfig.length)) message.methodConfig = []; - message.methodConfig.push($root.grpc.service_config.MethodConfig.decode(reader, reader.uint32())); + message.methodConfig.push($root.grpc.service_config.MethodConfig.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 3: { - message.retryThrottling = $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy.decode(reader, reader.uint32()); + message.retryThrottling = $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy.decode(reader, reader.uint32(), undefined, long + 1); break; } case 5: { - message.healthCheckConfig = $root.grpc.service_config.ServiceConfig.HealthCheckConfig.decode(reader, reader.uint32()); + message.healthCheckConfig = $root.grpc.service_config.ServiceConfig.HealthCheckConfig.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -2911,10 +3117,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ServiceConfig.verify = function verify(message) { + ServiceConfig.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.loadBalancingPolicy != null && message.hasOwnProperty("loadBalancingPolicy")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.loadBalancingPolicy != null && Object.hasOwnProperty.call(message, "loadBalancingPolicy")) switch (message.loadBalancingPolicy) { default: return "loadBalancingPolicy: enum value expected"; @@ -2922,31 +3132,31 @@ case 1: break; } - if (message.loadBalancingConfig != null && message.hasOwnProperty("loadBalancingConfig")) { + if (message.loadBalancingConfig != null && Object.hasOwnProperty.call(message, "loadBalancingConfig")) { if (!Array.isArray(message.loadBalancingConfig)) return "loadBalancingConfig: array expected"; for (var i = 0; i < message.loadBalancingConfig.length; ++i) { - var error = $root.grpc.service_config.LoadBalancingConfig.verify(message.loadBalancingConfig[i]); + var error = $root.grpc.service_config.LoadBalancingConfig.verify(message.loadBalancingConfig[i], long + 1); if (error) return "loadBalancingConfig." + error; } } - if (message.methodConfig != null && message.hasOwnProperty("methodConfig")) { + if (message.methodConfig != null && Object.hasOwnProperty.call(message, "methodConfig")) { if (!Array.isArray(message.methodConfig)) return "methodConfig: array expected"; for (var i = 0; i < message.methodConfig.length; ++i) { - var error = $root.grpc.service_config.MethodConfig.verify(message.methodConfig[i]); + var error = $root.grpc.service_config.MethodConfig.verify(message.methodConfig[i], long + 1); if (error) return "methodConfig." + error; } } - if (message.retryThrottling != null && message.hasOwnProperty("retryThrottling")) { - var error = $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy.verify(message.retryThrottling); + if (message.retryThrottling != null && Object.hasOwnProperty.call(message, "retryThrottling")) { + var error = $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy.verify(message.retryThrottling, long + 1); if (error) return "retryThrottling." + error; } - if (message.healthCheckConfig != null && message.hasOwnProperty("healthCheckConfig")) { - var error = $root.grpc.service_config.ServiceConfig.HealthCheckConfig.verify(message.healthCheckConfig); + if (message.healthCheckConfig != null && Object.hasOwnProperty.call(message, "healthCheckConfig")) { + var error = $root.grpc.service_config.ServiceConfig.HealthCheckConfig.verify(message.healthCheckConfig, long + 1); if (error) return "healthCheckConfig." + error; } @@ -2961,9 +3171,15 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.ServiceConfig} ServiceConfig */ - ServiceConfig.fromObject = function fromObject(object) { + ServiceConfig.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.ServiceConfig) return object; + if (!$util.isObject(object)) + throw TypeError(".grpc.service_config.ServiceConfig: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.grpc.service_config.ServiceConfig(); switch (object.loadBalancingPolicy) { default: @@ -2986,9 +3202,9 @@ throw TypeError(".grpc.service_config.ServiceConfig.loadBalancingConfig: array expected"); message.loadBalancingConfig = []; for (var i = 0; i < object.loadBalancingConfig.length; ++i) { - if (typeof object.loadBalancingConfig[i] !== "object") + if (!$util.isObject(object.loadBalancingConfig[i])) throw TypeError(".grpc.service_config.ServiceConfig.loadBalancingConfig: object expected"); - message.loadBalancingConfig[i] = $root.grpc.service_config.LoadBalancingConfig.fromObject(object.loadBalancingConfig[i]); + message.loadBalancingConfig[i] = $root.grpc.service_config.LoadBalancingConfig.fromObject(object.loadBalancingConfig[i], long + 1); } } if (object.methodConfig) { @@ -2996,20 +3212,20 @@ throw TypeError(".grpc.service_config.ServiceConfig.methodConfig: array expected"); message.methodConfig = []; for (var i = 0; i < object.methodConfig.length; ++i) { - if (typeof object.methodConfig[i] !== "object") + if (!$util.isObject(object.methodConfig[i])) throw TypeError(".grpc.service_config.ServiceConfig.methodConfig: object expected"); - message.methodConfig[i] = $root.grpc.service_config.MethodConfig.fromObject(object.methodConfig[i]); + message.methodConfig[i] = $root.grpc.service_config.MethodConfig.fromObject(object.methodConfig[i], long + 1); } } if (object.retryThrottling != null) { - if (typeof object.retryThrottling !== "object") + if (!$util.isObject(object.retryThrottling)) throw TypeError(".grpc.service_config.ServiceConfig.retryThrottling: object expected"); - message.retryThrottling = $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy.fromObject(object.retryThrottling); + message.retryThrottling = $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy.fromObject(object.retryThrottling, long + 1); } if (object.healthCheckConfig != null) { - if (typeof object.healthCheckConfig !== "object") + if (!$util.isObject(object.healthCheckConfig)) throw TypeError(".grpc.service_config.ServiceConfig.healthCheckConfig: object expected"); - message.healthCheckConfig = $root.grpc.service_config.ServiceConfig.HealthCheckConfig.fromObject(object.healthCheckConfig); + message.healthCheckConfig = $root.grpc.service_config.ServiceConfig.HealthCheckConfig.fromObject(object.healthCheckConfig, long + 1); } return message; }; @@ -3023,9 +3239,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ServiceConfig.toObject = function toObject(message, options) { + ServiceConfig.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.methodConfig = []; @@ -3036,22 +3256,22 @@ object.retryThrottling = null; object.healthCheckConfig = null; } - if (message.loadBalancingPolicy != null && message.hasOwnProperty("loadBalancingPolicy")) + if (message.loadBalancingPolicy != null && Object.hasOwnProperty.call(message, "loadBalancingPolicy")) object.loadBalancingPolicy = options.enums === String ? $root.grpc.service_config.ServiceConfig.LoadBalancingPolicy[message.loadBalancingPolicy] === undefined ? message.loadBalancingPolicy : $root.grpc.service_config.ServiceConfig.LoadBalancingPolicy[message.loadBalancingPolicy] : message.loadBalancingPolicy; if (message.methodConfig && message.methodConfig.length) { object.methodConfig = []; for (var j = 0; j < message.methodConfig.length; ++j) - object.methodConfig[j] = $root.grpc.service_config.MethodConfig.toObject(message.methodConfig[j], options); + object.methodConfig[j] = $root.grpc.service_config.MethodConfig.toObject(message.methodConfig[j], options, q + 1); } - if (message.retryThrottling != null && message.hasOwnProperty("retryThrottling")) - object.retryThrottling = $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy.toObject(message.retryThrottling, options); + if (message.retryThrottling != null && Object.hasOwnProperty.call(message, "retryThrottling")) + object.retryThrottling = $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy.toObject(message.retryThrottling, options, q + 1); if (message.loadBalancingConfig && message.loadBalancingConfig.length) { object.loadBalancingConfig = []; for (var j = 0; j < message.loadBalancingConfig.length; ++j) - object.loadBalancingConfig[j] = $root.grpc.service_config.LoadBalancingConfig.toObject(message.loadBalancingConfig[j], options); + object.loadBalancingConfig[j] = $root.grpc.service_config.LoadBalancingConfig.toObject(message.loadBalancingConfig[j], options, q + 1); } - if (message.healthCheckConfig != null && message.hasOwnProperty("healthCheckConfig")) - object.healthCheckConfig = $root.grpc.service_config.ServiceConfig.HealthCheckConfig.toObject(message.healthCheckConfig, options); + if (message.healthCheckConfig != null && Object.hasOwnProperty.call(message, "healthCheckConfig")) + object.healthCheckConfig = $root.grpc.service_config.ServiceConfig.HealthCheckConfig.toObject(message.healthCheckConfig, options, q + 1); return object; }; @@ -3116,7 +3336,7 @@ function RetryThrottlingPolicy(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -3157,9 +3377,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - RetryThrottlingPolicy.encode = function encode(message, writer) { + RetryThrottlingPolicy.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.maxTokens != null && Object.hasOwnProperty.call(message, "maxTokens")) writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.maxTokens); if (message.tokenRatio != null && Object.hasOwnProperty.call(message, "tokenRatio")) @@ -3191,12 +3415,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - RetryThrottlingPolicy.decode = function decode(reader, length) { + RetryThrottlingPolicy.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.maxTokens = reader.uint32(); @@ -3207,7 +3437,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -3238,13 +3468,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - RetryThrottlingPolicy.verify = function verify(message) { + RetryThrottlingPolicy.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.maxTokens != null && message.hasOwnProperty("maxTokens")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.maxTokens != null && Object.hasOwnProperty.call(message, "maxTokens")) if (!$util.isInteger(message.maxTokens)) return "maxTokens: integer expected"; - if (message.tokenRatio != null && message.hasOwnProperty("tokenRatio")) + if (message.tokenRatio != null && Object.hasOwnProperty.call(message, "tokenRatio")) if (typeof message.tokenRatio !== "number") return "tokenRatio: number expected"; return null; @@ -3258,9 +3492,15 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.ServiceConfig.RetryThrottlingPolicy} RetryThrottlingPolicy */ - RetryThrottlingPolicy.fromObject = function fromObject(object) { + RetryThrottlingPolicy.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy) return object; + if (!$util.isObject(object)) + throw TypeError(".grpc.service_config.ServiceConfig.RetryThrottlingPolicy: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.grpc.service_config.ServiceConfig.RetryThrottlingPolicy(); if (object.maxTokens != null) message.maxTokens = object.maxTokens >>> 0; @@ -3278,17 +3518,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - RetryThrottlingPolicy.toObject = function toObject(message, options) { + RetryThrottlingPolicy.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.maxTokens = 0; object.tokenRatio = 0; } - if (message.maxTokens != null && message.hasOwnProperty("maxTokens")) + if (message.maxTokens != null && Object.hasOwnProperty.call(message, "maxTokens")) object.maxTokens = message.maxTokens; - if (message.tokenRatio != null && message.hasOwnProperty("tokenRatio")) + if (message.tokenRatio != null && Object.hasOwnProperty.call(message, "tokenRatio")) object.tokenRatio = options.json && !isFinite(message.tokenRatio) ? String(message.tokenRatio) : message.tokenRatio; return object; }; @@ -3342,7 +3586,7 @@ function HealthCheckConfig(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -3375,11 +3619,15 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - HealthCheckConfig.encode = function encode(message, writer) { + HealthCheckConfig.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.serviceName != null && Object.hasOwnProperty.call(message, "serviceName")) - $root.google.protobuf.StringValue.encode(message.serviceName, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.protobuf.StringValue.encode(message.serviceName, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -3407,19 +3655,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - HealthCheckConfig.decode = function decode(reader, length) { + HealthCheckConfig.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.grpc.service_config.ServiceConfig.HealthCheckConfig(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.serviceName = $root.google.protobuf.StringValue.decode(reader, reader.uint32()); + message.serviceName = $root.google.protobuf.StringValue.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -3450,11 +3704,15 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - HealthCheckConfig.verify = function verify(message) { + HealthCheckConfig.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.serviceName != null && message.hasOwnProperty("serviceName")) { - var error = $root.google.protobuf.StringValue.verify(message.serviceName); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.serviceName != null && Object.hasOwnProperty.call(message, "serviceName")) { + var error = $root.google.protobuf.StringValue.verify(message.serviceName, long + 1); if (error) return "serviceName." + error; } @@ -3469,14 +3727,20 @@ * @param {Object.} object Plain object * @returns {grpc.service_config.ServiceConfig.HealthCheckConfig} HealthCheckConfig */ - HealthCheckConfig.fromObject = function fromObject(object) { + HealthCheckConfig.fromObject = function fromObject(object, long) { if (object instanceof $root.grpc.service_config.ServiceConfig.HealthCheckConfig) return object; + if (!$util.isObject(object)) + throw TypeError(".grpc.service_config.ServiceConfig.HealthCheckConfig: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.grpc.service_config.ServiceConfig.HealthCheckConfig(); if (object.serviceName != null) { - if (typeof object.serviceName !== "object") + if (!$util.isObject(object.serviceName)) throw TypeError(".grpc.service_config.ServiceConfig.HealthCheckConfig.serviceName: object expected"); - message.serviceName = $root.google.protobuf.StringValue.fromObject(object.serviceName); + message.serviceName = $root.google.protobuf.StringValue.fromObject(object.serviceName, long + 1); } return message; }; @@ -3490,14 +3754,18 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - HealthCheckConfig.toObject = function toObject(message, options) { + HealthCheckConfig.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.serviceName = null; - if (message.serviceName != null && message.hasOwnProperty("serviceName")) - object.serviceName = $root.google.protobuf.StringValue.toObject(message.serviceName, options); + if (message.serviceName != null && Object.hasOwnProperty.call(message, "serviceName")) + object.serviceName = $root.google.protobuf.StringValue.toObject(message.serviceName, options, q + 1); return object; }; @@ -3579,7 +3847,7 @@ this.rules = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -3620,12 +3888,16 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Http.encode = function encode(message, writer) { + Http.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.rules != null && message.rules.length) for (var i = 0; i < message.rules.length; ++i) - $root.google.api.HttpRule.encode(message.rules[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.api.HttpRule.encode(message.rules[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); if (message.fullyDecodeReservedExpansion != null && Object.hasOwnProperty.call(message, "fullyDecodeReservedExpansion")) writer.uint32(/* id 2, wireType 0 =*/16).bool(message.fullyDecodeReservedExpansion); return writer; @@ -3655,17 +3927,23 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Http.decode = function decode(reader, length) { + Http.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.Http(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.rules && message.rules.length)) message.rules = []; - message.rules.push($root.google.api.HttpRule.decode(reader, reader.uint32())); + message.rules.push($root.google.api.HttpRule.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 2: { @@ -3673,7 +3951,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -3704,19 +3982,23 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Http.verify = function verify(message) { + Http.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.rules != null && message.hasOwnProperty("rules")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.rules != null && Object.hasOwnProperty.call(message, "rules")) { if (!Array.isArray(message.rules)) return "rules: array expected"; for (var i = 0; i < message.rules.length; ++i) { - var error = $root.google.api.HttpRule.verify(message.rules[i]); + var error = $root.google.api.HttpRule.verify(message.rules[i], long + 1); if (error) return "rules." + error; } } - if (message.fullyDecodeReservedExpansion != null && message.hasOwnProperty("fullyDecodeReservedExpansion")) + if (message.fullyDecodeReservedExpansion != null && Object.hasOwnProperty.call(message, "fullyDecodeReservedExpansion")) if (typeof message.fullyDecodeReservedExpansion !== "boolean") return "fullyDecodeReservedExpansion: boolean expected"; return null; @@ -3730,18 +4012,24 @@ * @param {Object.} object Plain object * @returns {google.api.Http} Http */ - Http.fromObject = function fromObject(object) { + Http.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.Http) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.Http: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.Http(); if (object.rules) { if (!Array.isArray(object.rules)) throw TypeError(".google.api.Http.rules: array expected"); message.rules = []; for (var i = 0; i < object.rules.length; ++i) { - if (typeof object.rules[i] !== "object") + if (!$util.isObject(object.rules[i])) throw TypeError(".google.api.Http.rules: object expected"); - message.rules[i] = $root.google.api.HttpRule.fromObject(object.rules[i]); + message.rules[i] = $root.google.api.HttpRule.fromObject(object.rules[i], long + 1); } } if (object.fullyDecodeReservedExpansion != null) @@ -3758,9 +4046,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Http.toObject = function toObject(message, options) { + Http.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.rules = []; @@ -3769,9 +4061,9 @@ if (message.rules && message.rules.length) { object.rules = []; for (var j = 0; j < message.rules.length; ++j) - object.rules[j] = $root.google.api.HttpRule.toObject(message.rules[j], options); + object.rules[j] = $root.google.api.HttpRule.toObject(message.rules[j], options, q + 1); } - if (message.fullyDecodeReservedExpansion != null && message.hasOwnProperty("fullyDecodeReservedExpansion")) + if (message.fullyDecodeReservedExpansion != null && Object.hasOwnProperty.call(message, "fullyDecodeReservedExpansion")) object.fullyDecodeReservedExpansion = message.fullyDecodeReservedExpansion; return object; }; @@ -3835,7 +4127,7 @@ this.additionalBindings = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -3954,9 +4246,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - HttpRule.encode = function encode(message, writer) { + HttpRule.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.selector != null && Object.hasOwnProperty.call(message, "selector")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.selector); if (message.get != null && Object.hasOwnProperty.call(message, "get")) @@ -3972,10 +4268,10 @@ if (message.body != null && Object.hasOwnProperty.call(message, "body")) writer.uint32(/* id 7, wireType 2 =*/58).string(message.body); if (message.custom != null && Object.hasOwnProperty.call(message, "custom")) - $root.google.api.CustomHttpPattern.encode(message.custom, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim(); + $root.google.api.CustomHttpPattern.encode(message.custom, writer.uint32(/* id 8, wireType 2 =*/66).fork(), q + 1).ldelim(); if (message.additionalBindings != null && message.additionalBindings.length) for (var i = 0; i < message.additionalBindings.length; ++i) - $root.google.api.HttpRule.encode(message.additionalBindings[i], writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim(); + $root.google.api.HttpRule.encode(message.additionalBindings[i], writer.uint32(/* id 11, wireType 2 =*/90).fork(), q + 1).ldelim(); if (message.responseBody != null && Object.hasOwnProperty.call(message, "responseBody")) writer.uint32(/* id 12, wireType 2 =*/98).string(message.responseBody); return writer; @@ -4005,12 +4301,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - HttpRule.decode = function decode(reader, length) { + HttpRule.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.HttpRule(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.selector = reader.string(); @@ -4037,7 +4339,7 @@ break; } case 8: { - message.custom = $root.google.api.CustomHttpPattern.decode(reader, reader.uint32()); + message.custom = $root.google.api.CustomHttpPattern.decode(reader, reader.uint32(), undefined, long + 1); break; } case 7: { @@ -4051,11 +4353,11 @@ case 11: { if (!(message.additionalBindings && message.additionalBindings.length)) message.additionalBindings = []; - message.additionalBindings.push($root.google.api.HttpRule.decode(reader, reader.uint32())); + message.additionalBindings.push($root.google.api.HttpRule.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -4086,67 +4388,71 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - HttpRule.verify = function verify(message) { + HttpRule.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; var properties = {}; - if (message.selector != null && message.hasOwnProperty("selector")) + if (message.selector != null && Object.hasOwnProperty.call(message, "selector")) if (!$util.isString(message.selector)) return "selector: string expected"; - if (message.get != null && message.hasOwnProperty("get")) { + if (message.get != null && Object.hasOwnProperty.call(message, "get")) { properties.pattern = 1; if (!$util.isString(message.get)) return "get: string expected"; } - if (message.put != null && message.hasOwnProperty("put")) { + if (message.put != null && Object.hasOwnProperty.call(message, "put")) { if (properties.pattern === 1) return "pattern: multiple values"; properties.pattern = 1; if (!$util.isString(message.put)) return "put: string expected"; } - if (message.post != null && message.hasOwnProperty("post")) { + if (message.post != null && Object.hasOwnProperty.call(message, "post")) { if (properties.pattern === 1) return "pattern: multiple values"; properties.pattern = 1; if (!$util.isString(message.post)) return "post: string expected"; } - if (message["delete"] != null && message.hasOwnProperty("delete")) { + if (message["delete"] != null && Object.hasOwnProperty.call(message, "delete")) { if (properties.pattern === 1) return "pattern: multiple values"; properties.pattern = 1; if (!$util.isString(message["delete"])) return "delete: string expected"; } - if (message.patch != null && message.hasOwnProperty("patch")) { + if (message.patch != null && Object.hasOwnProperty.call(message, "patch")) { if (properties.pattern === 1) return "pattern: multiple values"; properties.pattern = 1; if (!$util.isString(message.patch)) return "patch: string expected"; } - if (message.custom != null && message.hasOwnProperty("custom")) { + if (message.custom != null && Object.hasOwnProperty.call(message, "custom")) { if (properties.pattern === 1) return "pattern: multiple values"; properties.pattern = 1; { - var error = $root.google.api.CustomHttpPattern.verify(message.custom); + var error = $root.google.api.CustomHttpPattern.verify(message.custom, long + 1); if (error) return "custom." + error; } } - if (message.body != null && message.hasOwnProperty("body")) + if (message.body != null && Object.hasOwnProperty.call(message, "body")) if (!$util.isString(message.body)) return "body: string expected"; - if (message.responseBody != null && message.hasOwnProperty("responseBody")) + if (message.responseBody != null && Object.hasOwnProperty.call(message, "responseBody")) if (!$util.isString(message.responseBody)) return "responseBody: string expected"; - if (message.additionalBindings != null && message.hasOwnProperty("additionalBindings")) { + if (message.additionalBindings != null && Object.hasOwnProperty.call(message, "additionalBindings")) { if (!Array.isArray(message.additionalBindings)) return "additionalBindings: array expected"; for (var i = 0; i < message.additionalBindings.length; ++i) { - var error = $root.google.api.HttpRule.verify(message.additionalBindings[i]); + var error = $root.google.api.HttpRule.verify(message.additionalBindings[i], long + 1); if (error) return "additionalBindings." + error; } @@ -4162,9 +4468,15 @@ * @param {Object.} object Plain object * @returns {google.api.HttpRule} HttpRule */ - HttpRule.fromObject = function fromObject(object) { + HttpRule.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.HttpRule) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.HttpRule: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.HttpRule(); if (object.selector != null) message.selector = String(object.selector); @@ -4179,9 +4491,9 @@ if (object.patch != null) message.patch = String(object.patch); if (object.custom != null) { - if (typeof object.custom !== "object") + if (!$util.isObject(object.custom)) throw TypeError(".google.api.HttpRule.custom: object expected"); - message.custom = $root.google.api.CustomHttpPattern.fromObject(object.custom); + message.custom = $root.google.api.CustomHttpPattern.fromObject(object.custom, long + 1); } if (object.body != null) message.body = String(object.body); @@ -4192,9 +4504,9 @@ throw TypeError(".google.api.HttpRule.additionalBindings: array expected"); message.additionalBindings = []; for (var i = 0; i < object.additionalBindings.length; ++i) { - if (typeof object.additionalBindings[i] !== "object") + if (!$util.isObject(object.additionalBindings[i])) throw TypeError(".google.api.HttpRule.additionalBindings: object expected"); - message.additionalBindings[i] = $root.google.api.HttpRule.fromObject(object.additionalBindings[i]); + message.additionalBindings[i] = $root.google.api.HttpRule.fromObject(object.additionalBindings[i], long + 1); } } return message; @@ -4209,9 +4521,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - HttpRule.toObject = function toObject(message, options) { + HttpRule.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.additionalBindings = []; @@ -4220,46 +4536,46 @@ object.body = ""; object.responseBody = ""; } - if (message.selector != null && message.hasOwnProperty("selector")) + if (message.selector != null && Object.hasOwnProperty.call(message, "selector")) object.selector = message.selector; - if (message.get != null && message.hasOwnProperty("get")) { + if (message.get != null && Object.hasOwnProperty.call(message, "get")) { object.get = message.get; if (options.oneofs) object.pattern = "get"; } - if (message.put != null && message.hasOwnProperty("put")) { + if (message.put != null && Object.hasOwnProperty.call(message, "put")) { object.put = message.put; if (options.oneofs) object.pattern = "put"; } - if (message.post != null && message.hasOwnProperty("post")) { + if (message.post != null && Object.hasOwnProperty.call(message, "post")) { object.post = message.post; if (options.oneofs) object.pattern = "post"; } - if (message["delete"] != null && message.hasOwnProperty("delete")) { + if (message["delete"] != null && Object.hasOwnProperty.call(message, "delete")) { object["delete"] = message["delete"]; if (options.oneofs) object.pattern = "delete"; } - if (message.patch != null && message.hasOwnProperty("patch")) { + if (message.patch != null && Object.hasOwnProperty.call(message, "patch")) { object.patch = message.patch; if (options.oneofs) object.pattern = "patch"; } - if (message.body != null && message.hasOwnProperty("body")) + if (message.body != null && Object.hasOwnProperty.call(message, "body")) object.body = message.body; - if (message.custom != null && message.hasOwnProperty("custom")) { - object.custom = $root.google.api.CustomHttpPattern.toObject(message.custom, options); + if (message.custom != null && Object.hasOwnProperty.call(message, "custom")) { + object.custom = $root.google.api.CustomHttpPattern.toObject(message.custom, options, q + 1); if (options.oneofs) object.pattern = "custom"; } if (message.additionalBindings && message.additionalBindings.length) { object.additionalBindings = []; for (var j = 0; j < message.additionalBindings.length; ++j) - object.additionalBindings[j] = $root.google.api.HttpRule.toObject(message.additionalBindings[j], options); + object.additionalBindings[j] = $root.google.api.HttpRule.toObject(message.additionalBindings[j], options, q + 1); } - if (message.responseBody != null && message.hasOwnProperty("responseBody")) + if (message.responseBody != null && Object.hasOwnProperty.call(message, "responseBody")) object.responseBody = message.responseBody; return object; }; @@ -4314,7 +4630,7 @@ function CustomHttpPattern(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -4355,9 +4671,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - CustomHttpPattern.encode = function encode(message, writer) { + CustomHttpPattern.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.kind != null && Object.hasOwnProperty.call(message, "kind")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.kind); if (message.path != null && Object.hasOwnProperty.call(message, "path")) @@ -4389,12 +4709,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - CustomHttpPattern.decode = function decode(reader, length) { + CustomHttpPattern.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.CustomHttpPattern(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.kind = reader.string(); @@ -4405,7 +4731,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -4436,13 +4762,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - CustomHttpPattern.verify = function verify(message) { + CustomHttpPattern.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.kind != null && message.hasOwnProperty("kind")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.kind != null && Object.hasOwnProperty.call(message, "kind")) if (!$util.isString(message.kind)) return "kind: string expected"; - if (message.path != null && message.hasOwnProperty("path")) + if (message.path != null && Object.hasOwnProperty.call(message, "path")) if (!$util.isString(message.path)) return "path: string expected"; return null; @@ -4456,9 +4786,15 @@ * @param {Object.} object Plain object * @returns {google.api.CustomHttpPattern} CustomHttpPattern */ - CustomHttpPattern.fromObject = function fromObject(object) { + CustomHttpPattern.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.CustomHttpPattern) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.CustomHttpPattern: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.CustomHttpPattern(); if (object.kind != null) message.kind = String(object.kind); @@ -4476,17 +4812,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - CustomHttpPattern.toObject = function toObject(message, options) { + CustomHttpPattern.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.kind = ""; object.path = ""; } - if (message.kind != null && message.hasOwnProperty("kind")) + if (message.kind != null && Object.hasOwnProperty.call(message, "kind")) object.kind = message.kind; - if (message.path != null && message.hasOwnProperty("path")) + if (message.path != null && Object.hasOwnProperty.call(message, "path")) object.path = message.path; return object; }; @@ -4568,7 +4908,7 @@ function FieldInfo(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -4601,9 +4941,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - FieldInfo.encode = function encode(message, writer) { + FieldInfo.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.format != null && Object.hasOwnProperty.call(message, "format")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.format); return writer; @@ -4633,19 +4977,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - FieldInfo.decode = function decode(reader, length) { + FieldInfo.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.FieldInfo(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.format = reader.int32(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -4676,10 +5026,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - FieldInfo.verify = function verify(message) { + FieldInfo.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.format != null && message.hasOwnProperty("format")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.format != null && Object.hasOwnProperty.call(message, "format")) switch (message.format) { default: return "format: enum value expected"; @@ -4701,9 +5055,15 @@ * @param {Object.} object Plain object * @returns {google.api.FieldInfo} FieldInfo */ - FieldInfo.fromObject = function fromObject(object) { + FieldInfo.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.FieldInfo) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.FieldInfo: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.FieldInfo(); switch (object.format) { default: @@ -4745,13 +5105,17 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - FieldInfo.toObject = function toObject(message, options) { + FieldInfo.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.format = options.enums === String ? "FORMAT_UNSPECIFIED" : 0; - if (message.format != null && message.hasOwnProperty("format")) + if (message.format != null && Object.hasOwnProperty.call(message, "format")) object.format = options.enums === String ? $root.google.api.FieldInfo.Format[message.format] === undefined ? message.format : $root.google.api.FieldInfo.Format[message.format] : message.format; return object; }; @@ -4805,6 +5169,405 @@ return FieldInfo; })(); + api.MediaUpload = (function() { + + /** + * Properties of a MediaUpload. + * @memberof google.api + * @interface IMediaUpload + * @property {boolean|null} [enabled] MediaUpload enabled + * @property {Array.|null} [mediaUploadPaths] MediaUpload mediaUploadPaths + * @property {boolean|null} [startNotification] MediaUpload startNotification + * @property {boolean|null} [uploadNotification] MediaUpload uploadNotification + * @property {boolean|null} [finalizeNotification] MediaUpload finalizeNotification + * @property {string|null} [directUploadService] MediaUpload directUploadService + * @property {number|Long|null} [maxUploadSessionDurationSeconds] MediaUpload maxUploadSessionDurationSeconds + */ + + /** + * Constructs a new MediaUpload. + * @memberof google.api + * @classdesc Represents a MediaUpload. + * @implements IMediaUpload + * @constructor + * @param {google.api.IMediaUpload=} [properties] Properties to set + */ + function MediaUpload(properties) { + this.mediaUploadPaths = []; + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null && keys[i] !== "__proto__") + this[keys[i]] = properties[keys[i]]; + } + + /** + * MediaUpload enabled. + * @member {boolean} enabled + * @memberof google.api.MediaUpload + * @instance + */ + MediaUpload.prototype.enabled = false; + + /** + * MediaUpload mediaUploadPaths. + * @member {Array.} mediaUploadPaths + * @memberof google.api.MediaUpload + * @instance + */ + MediaUpload.prototype.mediaUploadPaths = $util.emptyArray; + + /** + * MediaUpload startNotification. + * @member {boolean} startNotification + * @memberof google.api.MediaUpload + * @instance + */ + MediaUpload.prototype.startNotification = false; + + /** + * MediaUpload uploadNotification. + * @member {boolean} uploadNotification + * @memberof google.api.MediaUpload + * @instance + */ + MediaUpload.prototype.uploadNotification = false; + + /** + * MediaUpload finalizeNotification. + * @member {boolean} finalizeNotification + * @memberof google.api.MediaUpload + * @instance + */ + MediaUpload.prototype.finalizeNotification = false; + + /** + * MediaUpload directUploadService. + * @member {string} directUploadService + * @memberof google.api.MediaUpload + * @instance + */ + MediaUpload.prototype.directUploadService = ""; + + /** + * MediaUpload maxUploadSessionDurationSeconds. + * @member {number|Long} maxUploadSessionDurationSeconds + * @memberof google.api.MediaUpload + * @instance + */ + MediaUpload.prototype.maxUploadSessionDurationSeconds = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * Creates a new MediaUpload instance using the specified properties. + * @function create + * @memberof google.api.MediaUpload + * @static + * @param {google.api.IMediaUpload=} [properties] Properties to set + * @returns {google.api.MediaUpload} MediaUpload instance + */ + MediaUpload.create = function create(properties) { + return new MediaUpload(properties); + }; + + /** + * Encodes the specified MediaUpload message. Does not implicitly {@link google.api.MediaUpload.verify|verify} messages. + * @function encode + * @memberof google.api.MediaUpload + * @static + * @param {google.api.IMediaUpload} message MediaUpload message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + MediaUpload.encode = function encode(message, writer, q) { + if (!writer) + writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + if (message.enabled != null && Object.hasOwnProperty.call(message, "enabled")) + writer.uint32(/* id 1, wireType 0 =*/8).bool(message.enabled); + if (message.mediaUploadPaths != null && message.mediaUploadPaths.length) + for (var i = 0; i < message.mediaUploadPaths.length; ++i) + writer.uint32(/* id 2, wireType 2 =*/18).string(message.mediaUploadPaths[i]); + if (message.startNotification != null && Object.hasOwnProperty.call(message, "startNotification")) + writer.uint32(/* id 3, wireType 0 =*/24).bool(message.startNotification); + if (message.uploadNotification != null && Object.hasOwnProperty.call(message, "uploadNotification")) + writer.uint32(/* id 4, wireType 0 =*/32).bool(message.uploadNotification); + if (message.finalizeNotification != null && Object.hasOwnProperty.call(message, "finalizeNotification")) + writer.uint32(/* id 5, wireType 0 =*/40).bool(message.finalizeNotification); + if (message.directUploadService != null && Object.hasOwnProperty.call(message, "directUploadService")) + writer.uint32(/* id 6, wireType 2 =*/50).string(message.directUploadService); + if (message.maxUploadSessionDurationSeconds != null && Object.hasOwnProperty.call(message, "maxUploadSessionDurationSeconds")) + writer.uint32(/* id 7, wireType 0 =*/56).int64(message.maxUploadSessionDurationSeconds); + return writer; + }; + + /** + * Encodes the specified MediaUpload message, length delimited. Does not implicitly {@link google.api.MediaUpload.verify|verify} messages. + * @function encodeDelimited + * @memberof google.api.MediaUpload + * @static + * @param {google.api.IMediaUpload} message MediaUpload message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + MediaUpload.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a MediaUpload message from the specified reader or buffer. + * @function decode + * @memberof google.api.MediaUpload + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {google.api.MediaUpload} MediaUpload + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + MediaUpload.decode = function decode(reader, length, error, long) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.MediaUpload(); + while (reader.pos < end) { + var tag = reader.uint32(); + if (tag === error) + break; + switch (tag >>> 3) { + case 1: { + message.enabled = reader.bool(); + break; + } + case 2: { + if (!(message.mediaUploadPaths && message.mediaUploadPaths.length)) + message.mediaUploadPaths = []; + message.mediaUploadPaths.push(reader.string()); + break; + } + case 3: { + message.startNotification = reader.bool(); + break; + } + case 4: { + message.uploadNotification = reader.bool(); + break; + } + case 5: { + message.finalizeNotification = reader.bool(); + break; + } + case 6: { + message.directUploadService = reader.string(); + break; + } + case 7: { + message.maxUploadSessionDurationSeconds = reader.int64(); + break; + } + default: + reader.skipType(tag & 7, long); + break; + } + } + return message; + }; + + /** + * Decodes a MediaUpload message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof google.api.MediaUpload + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {google.api.MediaUpload} MediaUpload + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + MediaUpload.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a MediaUpload message. + * @function verify + * @memberof google.api.MediaUpload + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + MediaUpload.verify = function verify(message, long) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.enabled != null && Object.hasOwnProperty.call(message, "enabled")) + if (typeof message.enabled !== "boolean") + return "enabled: boolean expected"; + if (message.mediaUploadPaths != null && Object.hasOwnProperty.call(message, "mediaUploadPaths")) { + if (!Array.isArray(message.mediaUploadPaths)) + return "mediaUploadPaths: array expected"; + for (var i = 0; i < message.mediaUploadPaths.length; ++i) + if (!$util.isString(message.mediaUploadPaths[i])) + return "mediaUploadPaths: string[] expected"; + } + if (message.startNotification != null && Object.hasOwnProperty.call(message, "startNotification")) + if (typeof message.startNotification !== "boolean") + return "startNotification: boolean expected"; + if (message.uploadNotification != null && Object.hasOwnProperty.call(message, "uploadNotification")) + if (typeof message.uploadNotification !== "boolean") + return "uploadNotification: boolean expected"; + if (message.finalizeNotification != null && Object.hasOwnProperty.call(message, "finalizeNotification")) + if (typeof message.finalizeNotification !== "boolean") + return "finalizeNotification: boolean expected"; + if (message.directUploadService != null && Object.hasOwnProperty.call(message, "directUploadService")) + if (!$util.isString(message.directUploadService)) + return "directUploadService: string expected"; + if (message.maxUploadSessionDurationSeconds != null && Object.hasOwnProperty.call(message, "maxUploadSessionDurationSeconds")) + if (!$util.isInteger(message.maxUploadSessionDurationSeconds) && !(message.maxUploadSessionDurationSeconds && $util.isInteger(message.maxUploadSessionDurationSeconds.low) && $util.isInteger(message.maxUploadSessionDurationSeconds.high))) + return "maxUploadSessionDurationSeconds: integer|Long expected"; + return null; + }; + + /** + * Creates a MediaUpload message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof google.api.MediaUpload + * @static + * @param {Object.} object Plain object + * @returns {google.api.MediaUpload} MediaUpload + */ + MediaUpload.fromObject = function fromObject(object, long) { + if (object instanceof $root.google.api.MediaUpload) + return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.MediaUpload: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); + var message = new $root.google.api.MediaUpload(); + if (object.enabled != null) + message.enabled = Boolean(object.enabled); + if (object.mediaUploadPaths) { + if (!Array.isArray(object.mediaUploadPaths)) + throw TypeError(".google.api.MediaUpload.mediaUploadPaths: array expected"); + message.mediaUploadPaths = []; + for (var i = 0; i < object.mediaUploadPaths.length; ++i) + message.mediaUploadPaths[i] = String(object.mediaUploadPaths[i]); + } + if (object.startNotification != null) + message.startNotification = Boolean(object.startNotification); + if (object.uploadNotification != null) + message.uploadNotification = Boolean(object.uploadNotification); + if (object.finalizeNotification != null) + message.finalizeNotification = Boolean(object.finalizeNotification); + if (object.directUploadService != null) + message.directUploadService = String(object.directUploadService); + if (object.maxUploadSessionDurationSeconds != null) + if ($util.Long) + message.maxUploadSessionDurationSeconds = $util.Long.fromValue(object.maxUploadSessionDurationSeconds, false); + else if (typeof object.maxUploadSessionDurationSeconds === "string") + message.maxUploadSessionDurationSeconds = parseInt(object.maxUploadSessionDurationSeconds, 10); + else if (typeof object.maxUploadSessionDurationSeconds === "number") + message.maxUploadSessionDurationSeconds = object.maxUploadSessionDurationSeconds; + else if (typeof object.maxUploadSessionDurationSeconds === "object") + message.maxUploadSessionDurationSeconds = new $util.LongBits(object.maxUploadSessionDurationSeconds.low >>> 0, object.maxUploadSessionDurationSeconds.high >>> 0).toNumber(); + return message; + }; + + /** + * Creates a plain object from a MediaUpload message. Also converts values to other types if specified. + * @function toObject + * @memberof google.api.MediaUpload + * @static + * @param {google.api.MediaUpload} message MediaUpload + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + MediaUpload.toObject = function toObject(message, options, q) { + if (!options) + options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); + var object = {}; + if (options.arrays || options.defaults) + object.mediaUploadPaths = []; + if (options.defaults) { + object.enabled = false; + object.startNotification = false; + object.uploadNotification = false; + object.finalizeNotification = false; + object.directUploadService = ""; + if ($util.Long) { + var long = new $util.Long(0, 0, false); + object.maxUploadSessionDurationSeconds = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : typeof BigInt !== "undefined" && options.longs === BigInt ? long.toBigInt() : long; + } else + object.maxUploadSessionDurationSeconds = options.longs === String ? "0" : typeof BigInt !== "undefined" && options.longs === BigInt ? BigInt("0") : 0; + } + if (message.enabled != null && Object.hasOwnProperty.call(message, "enabled")) + object.enabled = message.enabled; + if (message.mediaUploadPaths && message.mediaUploadPaths.length) { + object.mediaUploadPaths = []; + for (var j = 0; j < message.mediaUploadPaths.length; ++j) + object.mediaUploadPaths[j] = message.mediaUploadPaths[j]; + } + if (message.startNotification != null && Object.hasOwnProperty.call(message, "startNotification")) + object.startNotification = message.startNotification; + if (message.uploadNotification != null && Object.hasOwnProperty.call(message, "uploadNotification")) + object.uploadNotification = message.uploadNotification; + if (message.finalizeNotification != null && Object.hasOwnProperty.call(message, "finalizeNotification")) + object.finalizeNotification = message.finalizeNotification; + if (message.directUploadService != null && Object.hasOwnProperty.call(message, "directUploadService")) + object.directUploadService = message.directUploadService; + if (message.maxUploadSessionDurationSeconds != null && Object.hasOwnProperty.call(message, "maxUploadSessionDurationSeconds")) + if (typeof BigInt !== "undefined" && options.longs === BigInt) + object.maxUploadSessionDurationSeconds = typeof message.maxUploadSessionDurationSeconds === "number" ? BigInt(message.maxUploadSessionDurationSeconds) : $util.Long.fromBits(message.maxUploadSessionDurationSeconds.low >>> 0, message.maxUploadSessionDurationSeconds.high >>> 0, false).toBigInt(); + else if (typeof message.maxUploadSessionDurationSeconds === "number") + object.maxUploadSessionDurationSeconds = options.longs === String ? String(message.maxUploadSessionDurationSeconds) : message.maxUploadSessionDurationSeconds; + else + object.maxUploadSessionDurationSeconds = options.longs === String ? $util.Long.prototype.toString.call(message.maxUploadSessionDurationSeconds) : options.longs === Number ? new $util.LongBits(message.maxUploadSessionDurationSeconds.low >>> 0, message.maxUploadSessionDurationSeconds.high >>> 0).toNumber() : message.maxUploadSessionDurationSeconds; + return object; + }; + + /** + * Converts this MediaUpload to JSON. + * @function toJSON + * @memberof google.api.MediaUpload + * @instance + * @returns {Object.} JSON object + */ + MediaUpload.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + /** + * Gets the default type url for MediaUpload + * @function getTypeUrl + * @memberof google.api.MediaUpload + * @static + * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns {string} The default type url + */ + MediaUpload.getTypeUrl = function getTypeUrl(typeUrlPrefix) { + if (typeUrlPrefix === undefined) { + typeUrlPrefix = "type.googleapis.com"; + } + return typeUrlPrefix + "/google.api.MediaUpload"; + }; + + return MediaUpload; + })(); + api.ResourceDescriptor = (function() { /** @@ -4833,7 +5596,7 @@ this.style = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -4914,9 +5677,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ResourceDescriptor.encode = function encode(message, writer) { + ResourceDescriptor.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.type != null && Object.hasOwnProperty.call(message, "type")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.type); if (message.pattern != null && message.pattern.length) @@ -4963,12 +5730,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ResourceDescriptor.decode = function decode(reader, length) { + ResourceDescriptor.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.ResourceDescriptor(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.type = reader.string(); @@ -5008,7 +5781,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -5039,23 +5812,27 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ResourceDescriptor.verify = function verify(message) { + ResourceDescriptor.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.type != null && message.hasOwnProperty("type")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.type != null && Object.hasOwnProperty.call(message, "type")) if (!$util.isString(message.type)) return "type: string expected"; - if (message.pattern != null && message.hasOwnProperty("pattern")) { + if (message.pattern != null && Object.hasOwnProperty.call(message, "pattern")) { if (!Array.isArray(message.pattern)) return "pattern: array expected"; for (var i = 0; i < message.pattern.length; ++i) if (!$util.isString(message.pattern[i])) return "pattern: string[] expected"; } - if (message.nameField != null && message.hasOwnProperty("nameField")) + if (message.nameField != null && Object.hasOwnProperty.call(message, "nameField")) if (!$util.isString(message.nameField)) return "nameField: string expected"; - if (message.history != null && message.hasOwnProperty("history")) + if (message.history != null && Object.hasOwnProperty.call(message, "history")) switch (message.history) { default: return "history: enum value expected"; @@ -5064,13 +5841,13 @@ case 2: break; } - if (message.plural != null && message.hasOwnProperty("plural")) + if (message.plural != null && Object.hasOwnProperty.call(message, "plural")) if (!$util.isString(message.plural)) return "plural: string expected"; - if (message.singular != null && message.hasOwnProperty("singular")) + if (message.singular != null && Object.hasOwnProperty.call(message, "singular")) if (!$util.isString(message.singular)) return "singular: string expected"; - if (message.style != null && message.hasOwnProperty("style")) { + if (message.style != null && Object.hasOwnProperty.call(message, "style")) { if (!Array.isArray(message.style)) return "style: array expected"; for (var i = 0; i < message.style.length; ++i) @@ -5093,9 +5870,15 @@ * @param {Object.} object Plain object * @returns {google.api.ResourceDescriptor} ResourceDescriptor */ - ResourceDescriptor.fromObject = function fromObject(object) { + ResourceDescriptor.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.ResourceDescriptor) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.ResourceDescriptor: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.ResourceDescriptor(); if (object.type != null) message.type = String(object.type); @@ -5165,9 +5948,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ResourceDescriptor.toObject = function toObject(message, options) { + ResourceDescriptor.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.pattern = []; @@ -5180,20 +5967,20 @@ object.plural = ""; object.singular = ""; } - if (message.type != null && message.hasOwnProperty("type")) + if (message.type != null && Object.hasOwnProperty.call(message, "type")) object.type = message.type; if (message.pattern && message.pattern.length) { object.pattern = []; for (var j = 0; j < message.pattern.length; ++j) object.pattern[j] = message.pattern[j]; } - if (message.nameField != null && message.hasOwnProperty("nameField")) + if (message.nameField != null && Object.hasOwnProperty.call(message, "nameField")) object.nameField = message.nameField; - if (message.history != null && message.hasOwnProperty("history")) + if (message.history != null && Object.hasOwnProperty.call(message, "history")) object.history = options.enums === String ? $root.google.api.ResourceDescriptor.History[message.history] === undefined ? message.history : $root.google.api.ResourceDescriptor.History[message.history] : message.history; - if (message.plural != null && message.hasOwnProperty("plural")) + if (message.plural != null && Object.hasOwnProperty.call(message, "plural")) object.plural = message.plural; - if (message.singular != null && message.hasOwnProperty("singular")) + if (message.singular != null && Object.hasOwnProperty.call(message, "singular")) object.singular = message.singular; if (message.style && message.style.length) { object.style = []; @@ -5283,7 +6070,7 @@ function ResourceReference(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -5324,9 +6111,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ResourceReference.encode = function encode(message, writer) { + ResourceReference.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.type != null && Object.hasOwnProperty.call(message, "type")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.type); if (message.childType != null && Object.hasOwnProperty.call(message, "childType")) @@ -5358,12 +6149,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ResourceReference.decode = function decode(reader, length) { + ResourceReference.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.ResourceReference(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.type = reader.string(); @@ -5374,7 +6171,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -5405,13 +6202,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ResourceReference.verify = function verify(message) { + ResourceReference.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.type != null && message.hasOwnProperty("type")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.type != null && Object.hasOwnProperty.call(message, "type")) if (!$util.isString(message.type)) return "type: string expected"; - if (message.childType != null && message.hasOwnProperty("childType")) + if (message.childType != null && Object.hasOwnProperty.call(message, "childType")) if (!$util.isString(message.childType)) return "childType: string expected"; return null; @@ -5425,9 +6226,15 @@ * @param {Object.} object Plain object * @returns {google.api.ResourceReference} ResourceReference */ - ResourceReference.fromObject = function fromObject(object) { + ResourceReference.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.ResourceReference) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.ResourceReference: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.ResourceReference(); if (object.type != null) message.type = String(object.type); @@ -5445,17 +6252,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ResourceReference.toObject = function toObject(message, options) { + ResourceReference.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.type = ""; object.childType = ""; } - if (message.type != null && message.hasOwnProperty("type")) + if (message.type != null && Object.hasOwnProperty.call(message, "type")) object.type = message.type; - if (message.childType != null && message.hasOwnProperty("childType")) + if (message.childType != null && Object.hasOwnProperty.call(message, "childType")) object.childType = message.childType; return object; }; @@ -5510,7 +6321,7 @@ this.routingParameters = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -5543,12 +6354,16 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - RoutingRule.encode = function encode(message, writer) { + RoutingRule.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.routingParameters != null && message.routingParameters.length) for (var i = 0; i < message.routingParameters.length; ++i) - $root.google.api.RoutingParameter.encode(message.routingParameters[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.api.RoutingParameter.encode(message.routingParameters[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); return writer; }; @@ -5576,21 +6391,27 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - RoutingRule.decode = function decode(reader, length) { + RoutingRule.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.RoutingRule(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 2: { if (!(message.routingParameters && message.routingParameters.length)) message.routingParameters = []; - message.routingParameters.push($root.google.api.RoutingParameter.decode(reader, reader.uint32())); + message.routingParameters.push($root.google.api.RoutingParameter.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -5621,14 +6442,18 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - RoutingRule.verify = function verify(message) { + RoutingRule.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.routingParameters != null && message.hasOwnProperty("routingParameters")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.routingParameters != null && Object.hasOwnProperty.call(message, "routingParameters")) { if (!Array.isArray(message.routingParameters)) return "routingParameters: array expected"; for (var i = 0; i < message.routingParameters.length; ++i) { - var error = $root.google.api.RoutingParameter.verify(message.routingParameters[i]); + var error = $root.google.api.RoutingParameter.verify(message.routingParameters[i], long + 1); if (error) return "routingParameters." + error; } @@ -5644,18 +6469,24 @@ * @param {Object.} object Plain object * @returns {google.api.RoutingRule} RoutingRule */ - RoutingRule.fromObject = function fromObject(object) { + RoutingRule.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.RoutingRule) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.RoutingRule: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.RoutingRule(); if (object.routingParameters) { if (!Array.isArray(object.routingParameters)) throw TypeError(".google.api.RoutingRule.routingParameters: array expected"); message.routingParameters = []; for (var i = 0; i < object.routingParameters.length; ++i) { - if (typeof object.routingParameters[i] !== "object") + if (!$util.isObject(object.routingParameters[i])) throw TypeError(".google.api.RoutingRule.routingParameters: object expected"); - message.routingParameters[i] = $root.google.api.RoutingParameter.fromObject(object.routingParameters[i]); + message.routingParameters[i] = $root.google.api.RoutingParameter.fromObject(object.routingParameters[i], long + 1); } } return message; @@ -5670,16 +6501,20 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - RoutingRule.toObject = function toObject(message, options) { + RoutingRule.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.routingParameters = []; if (message.routingParameters && message.routingParameters.length) { object.routingParameters = []; for (var j = 0; j < message.routingParameters.length; ++j) - object.routingParameters[j] = $root.google.api.RoutingParameter.toObject(message.routingParameters[j], options); + object.routingParameters[j] = $root.google.api.RoutingParameter.toObject(message.routingParameters[j], options, q + 1); } return object; }; @@ -5734,7 +6569,7 @@ function RoutingParameter(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -5775,9 +6610,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - RoutingParameter.encode = function encode(message, writer) { + RoutingParameter.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.field != null && Object.hasOwnProperty.call(message, "field")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.field); if (message.pathTemplate != null && Object.hasOwnProperty.call(message, "pathTemplate")) @@ -5809,12 +6648,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - RoutingParameter.decode = function decode(reader, length) { + RoutingParameter.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.RoutingParameter(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.field = reader.string(); @@ -5825,7 +6670,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -5856,13 +6701,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - RoutingParameter.verify = function verify(message) { + RoutingParameter.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.field != null && message.hasOwnProperty("field")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.field != null && Object.hasOwnProperty.call(message, "field")) if (!$util.isString(message.field)) return "field: string expected"; - if (message.pathTemplate != null && message.hasOwnProperty("pathTemplate")) + if (message.pathTemplate != null && Object.hasOwnProperty.call(message, "pathTemplate")) if (!$util.isString(message.pathTemplate)) return "pathTemplate: string expected"; return null; @@ -5876,9 +6725,15 @@ * @param {Object.} object Plain object * @returns {google.api.RoutingParameter} RoutingParameter */ - RoutingParameter.fromObject = function fromObject(object) { + RoutingParameter.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.RoutingParameter) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.RoutingParameter: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.RoutingParameter(); if (object.field != null) message.field = String(object.field); @@ -5896,17 +6751,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - RoutingParameter.toObject = function toObject(message, options) { + RoutingParameter.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.field = ""; object.pathTemplate = ""; } - if (message.field != null && message.hasOwnProperty("field")) + if (message.field != null && Object.hasOwnProperty.call(message, "field")) object.field = message.field; - if (message.pathTemplate != null && message.hasOwnProperty("pathTemplate")) + if (message.pathTemplate != null && Object.hasOwnProperty.call(message, "pathTemplate")) object.pathTemplate = message.pathTemplate; return object; }; @@ -5962,7 +6821,7 @@ this.destinations = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -6003,9 +6862,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - CommonLanguageSettings.encode = function encode(message, writer) { + CommonLanguageSettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.referenceDocsUri != null && Object.hasOwnProperty.call(message, "referenceDocsUri")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.referenceDocsUri); if (message.destinations != null && message.destinations.length) { @@ -6041,12 +6904,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - CommonLanguageSettings.decode = function decode(reader, length) { + CommonLanguageSettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.CommonLanguageSettings(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.referenceDocsUri = reader.string(); @@ -6064,7 +6933,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -6095,13 +6964,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - CommonLanguageSettings.verify = function verify(message) { + CommonLanguageSettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.referenceDocsUri != null && message.hasOwnProperty("referenceDocsUri")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.referenceDocsUri != null && Object.hasOwnProperty.call(message, "referenceDocsUri")) if (!$util.isString(message.referenceDocsUri)) return "referenceDocsUri: string expected"; - if (message.destinations != null && message.hasOwnProperty("destinations")) { + if (message.destinations != null && Object.hasOwnProperty.call(message, "destinations")) { if (!Array.isArray(message.destinations)) return "destinations: array expected"; for (var i = 0; i < message.destinations.length; ++i) @@ -6125,9 +6998,15 @@ * @param {Object.} object Plain object * @returns {google.api.CommonLanguageSettings} CommonLanguageSettings */ - CommonLanguageSettings.fromObject = function fromObject(object) { + CommonLanguageSettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.CommonLanguageSettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.CommonLanguageSettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.CommonLanguageSettings(); if (object.referenceDocsUri != null) message.referenceDocsUri = String(object.referenceDocsUri); @@ -6168,15 +7047,19 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - CommonLanguageSettings.toObject = function toObject(message, options) { + CommonLanguageSettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.destinations = []; if (options.defaults) object.referenceDocsUri = ""; - if (message.referenceDocsUri != null && message.hasOwnProperty("referenceDocsUri")) + if (message.referenceDocsUri != null && Object.hasOwnProperty.call(message, "referenceDocsUri")) object.referenceDocsUri = message.referenceDocsUri; if (message.destinations && message.destinations.length) { object.destinations = []; @@ -6245,7 +7128,7 @@ function ClientLibrarySettings(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -6358,9 +7241,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ClientLibrarySettings.encode = function encode(message, writer) { + ClientLibrarySettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.version != null && Object.hasOwnProperty.call(message, "version")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.version); if (message.launchStage != null && Object.hasOwnProperty.call(message, "launchStage")) @@ -6368,21 +7255,21 @@ if (message.restNumericEnums != null && Object.hasOwnProperty.call(message, "restNumericEnums")) writer.uint32(/* id 3, wireType 0 =*/24).bool(message.restNumericEnums); if (message.javaSettings != null && Object.hasOwnProperty.call(message, "javaSettings")) - $root.google.api.JavaSettings.encode(message.javaSettings, writer.uint32(/* id 21, wireType 2 =*/170).fork()).ldelim(); + $root.google.api.JavaSettings.encode(message.javaSettings, writer.uint32(/* id 21, wireType 2 =*/170).fork(), q + 1).ldelim(); if (message.cppSettings != null && Object.hasOwnProperty.call(message, "cppSettings")) - $root.google.api.CppSettings.encode(message.cppSettings, writer.uint32(/* id 22, wireType 2 =*/178).fork()).ldelim(); + $root.google.api.CppSettings.encode(message.cppSettings, writer.uint32(/* id 22, wireType 2 =*/178).fork(), q + 1).ldelim(); if (message.phpSettings != null && Object.hasOwnProperty.call(message, "phpSettings")) - $root.google.api.PhpSettings.encode(message.phpSettings, writer.uint32(/* id 23, wireType 2 =*/186).fork()).ldelim(); + $root.google.api.PhpSettings.encode(message.phpSettings, writer.uint32(/* id 23, wireType 2 =*/186).fork(), q + 1).ldelim(); if (message.pythonSettings != null && Object.hasOwnProperty.call(message, "pythonSettings")) - $root.google.api.PythonSettings.encode(message.pythonSettings, writer.uint32(/* id 24, wireType 2 =*/194).fork()).ldelim(); + $root.google.api.PythonSettings.encode(message.pythonSettings, writer.uint32(/* id 24, wireType 2 =*/194).fork(), q + 1).ldelim(); if (message.nodeSettings != null && Object.hasOwnProperty.call(message, "nodeSettings")) - $root.google.api.NodeSettings.encode(message.nodeSettings, writer.uint32(/* id 25, wireType 2 =*/202).fork()).ldelim(); + $root.google.api.NodeSettings.encode(message.nodeSettings, writer.uint32(/* id 25, wireType 2 =*/202).fork(), q + 1).ldelim(); if (message.dotnetSettings != null && Object.hasOwnProperty.call(message, "dotnetSettings")) - $root.google.api.DotnetSettings.encode(message.dotnetSettings, writer.uint32(/* id 26, wireType 2 =*/210).fork()).ldelim(); + $root.google.api.DotnetSettings.encode(message.dotnetSettings, writer.uint32(/* id 26, wireType 2 =*/210).fork(), q + 1).ldelim(); if (message.rubySettings != null && Object.hasOwnProperty.call(message, "rubySettings")) - $root.google.api.RubySettings.encode(message.rubySettings, writer.uint32(/* id 27, wireType 2 =*/218).fork()).ldelim(); + $root.google.api.RubySettings.encode(message.rubySettings, writer.uint32(/* id 27, wireType 2 =*/218).fork(), q + 1).ldelim(); if (message.goSettings != null && Object.hasOwnProperty.call(message, "goSettings")) - $root.google.api.GoSettings.encode(message.goSettings, writer.uint32(/* id 28, wireType 2 =*/226).fork()).ldelim(); + $root.google.api.GoSettings.encode(message.goSettings, writer.uint32(/* id 28, wireType 2 =*/226).fork(), q + 1).ldelim(); return writer; }; @@ -6410,12 +7297,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ClientLibrarySettings.decode = function decode(reader, length) { + ClientLibrarySettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.ClientLibrarySettings(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.version = reader.string(); @@ -6430,39 +7323,39 @@ break; } case 21: { - message.javaSettings = $root.google.api.JavaSettings.decode(reader, reader.uint32()); + message.javaSettings = $root.google.api.JavaSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } case 22: { - message.cppSettings = $root.google.api.CppSettings.decode(reader, reader.uint32()); + message.cppSettings = $root.google.api.CppSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } case 23: { - message.phpSettings = $root.google.api.PhpSettings.decode(reader, reader.uint32()); + message.phpSettings = $root.google.api.PhpSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } case 24: { - message.pythonSettings = $root.google.api.PythonSettings.decode(reader, reader.uint32()); + message.pythonSettings = $root.google.api.PythonSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } case 25: { - message.nodeSettings = $root.google.api.NodeSettings.decode(reader, reader.uint32()); + message.nodeSettings = $root.google.api.NodeSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } case 26: { - message.dotnetSettings = $root.google.api.DotnetSettings.decode(reader, reader.uint32()); + message.dotnetSettings = $root.google.api.DotnetSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } case 27: { - message.rubySettings = $root.google.api.RubySettings.decode(reader, reader.uint32()); + message.rubySettings = $root.google.api.RubySettings.decode(reader, reader.uint32(), undefined, long + 1); break; } case 28: { - message.goSettings = $root.google.api.GoSettings.decode(reader, reader.uint32()); + message.goSettings = $root.google.api.GoSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -6493,13 +7386,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ClientLibrarySettings.verify = function verify(message) { + ClientLibrarySettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.version != null && message.hasOwnProperty("version")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.version != null && Object.hasOwnProperty.call(message, "version")) if (!$util.isString(message.version)) return "version: string expected"; - if (message.launchStage != null && message.hasOwnProperty("launchStage")) + if (message.launchStage != null && Object.hasOwnProperty.call(message, "launchStage")) switch (message.launchStage) { default: return "launchStage: enum value expected"; @@ -6513,46 +7410,46 @@ case 5: break; } - if (message.restNumericEnums != null && message.hasOwnProperty("restNumericEnums")) + if (message.restNumericEnums != null && Object.hasOwnProperty.call(message, "restNumericEnums")) if (typeof message.restNumericEnums !== "boolean") return "restNumericEnums: boolean expected"; - if (message.javaSettings != null && message.hasOwnProperty("javaSettings")) { - var error = $root.google.api.JavaSettings.verify(message.javaSettings); + if (message.javaSettings != null && Object.hasOwnProperty.call(message, "javaSettings")) { + var error = $root.google.api.JavaSettings.verify(message.javaSettings, long + 1); if (error) return "javaSettings." + error; } - if (message.cppSettings != null && message.hasOwnProperty("cppSettings")) { - var error = $root.google.api.CppSettings.verify(message.cppSettings); + if (message.cppSettings != null && Object.hasOwnProperty.call(message, "cppSettings")) { + var error = $root.google.api.CppSettings.verify(message.cppSettings, long + 1); if (error) return "cppSettings." + error; } - if (message.phpSettings != null && message.hasOwnProperty("phpSettings")) { - var error = $root.google.api.PhpSettings.verify(message.phpSettings); + if (message.phpSettings != null && Object.hasOwnProperty.call(message, "phpSettings")) { + var error = $root.google.api.PhpSettings.verify(message.phpSettings, long + 1); if (error) return "phpSettings." + error; } - if (message.pythonSettings != null && message.hasOwnProperty("pythonSettings")) { - var error = $root.google.api.PythonSettings.verify(message.pythonSettings); + if (message.pythonSettings != null && Object.hasOwnProperty.call(message, "pythonSettings")) { + var error = $root.google.api.PythonSettings.verify(message.pythonSettings, long + 1); if (error) return "pythonSettings." + error; } - if (message.nodeSettings != null && message.hasOwnProperty("nodeSettings")) { - var error = $root.google.api.NodeSettings.verify(message.nodeSettings); + if (message.nodeSettings != null && Object.hasOwnProperty.call(message, "nodeSettings")) { + var error = $root.google.api.NodeSettings.verify(message.nodeSettings, long + 1); if (error) return "nodeSettings." + error; } - if (message.dotnetSettings != null && message.hasOwnProperty("dotnetSettings")) { - var error = $root.google.api.DotnetSettings.verify(message.dotnetSettings); + if (message.dotnetSettings != null && Object.hasOwnProperty.call(message, "dotnetSettings")) { + var error = $root.google.api.DotnetSettings.verify(message.dotnetSettings, long + 1); if (error) return "dotnetSettings." + error; } - if (message.rubySettings != null && message.hasOwnProperty("rubySettings")) { - var error = $root.google.api.RubySettings.verify(message.rubySettings); + if (message.rubySettings != null && Object.hasOwnProperty.call(message, "rubySettings")) { + var error = $root.google.api.RubySettings.verify(message.rubySettings, long + 1); if (error) return "rubySettings." + error; } - if (message.goSettings != null && message.hasOwnProperty("goSettings")) { - var error = $root.google.api.GoSettings.verify(message.goSettings); + if (message.goSettings != null && Object.hasOwnProperty.call(message, "goSettings")) { + var error = $root.google.api.GoSettings.verify(message.goSettings, long + 1); if (error) return "goSettings." + error; } @@ -6567,9 +7464,15 @@ * @param {Object.} object Plain object * @returns {google.api.ClientLibrarySettings} ClientLibrarySettings */ - ClientLibrarySettings.fromObject = function fromObject(object) { + ClientLibrarySettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.ClientLibrarySettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.ClientLibrarySettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.ClientLibrarySettings(); if (object.version != null) message.version = String(object.version); @@ -6616,44 +7519,44 @@ if (object.restNumericEnums != null) message.restNumericEnums = Boolean(object.restNumericEnums); if (object.javaSettings != null) { - if (typeof object.javaSettings !== "object") + if (!$util.isObject(object.javaSettings)) throw TypeError(".google.api.ClientLibrarySettings.javaSettings: object expected"); - message.javaSettings = $root.google.api.JavaSettings.fromObject(object.javaSettings); + message.javaSettings = $root.google.api.JavaSettings.fromObject(object.javaSettings, long + 1); } if (object.cppSettings != null) { - if (typeof object.cppSettings !== "object") + if (!$util.isObject(object.cppSettings)) throw TypeError(".google.api.ClientLibrarySettings.cppSettings: object expected"); - message.cppSettings = $root.google.api.CppSettings.fromObject(object.cppSettings); + message.cppSettings = $root.google.api.CppSettings.fromObject(object.cppSettings, long + 1); } if (object.phpSettings != null) { - if (typeof object.phpSettings !== "object") + if (!$util.isObject(object.phpSettings)) throw TypeError(".google.api.ClientLibrarySettings.phpSettings: object expected"); - message.phpSettings = $root.google.api.PhpSettings.fromObject(object.phpSettings); + message.phpSettings = $root.google.api.PhpSettings.fromObject(object.phpSettings, long + 1); } if (object.pythonSettings != null) { - if (typeof object.pythonSettings !== "object") + if (!$util.isObject(object.pythonSettings)) throw TypeError(".google.api.ClientLibrarySettings.pythonSettings: object expected"); - message.pythonSettings = $root.google.api.PythonSettings.fromObject(object.pythonSettings); + message.pythonSettings = $root.google.api.PythonSettings.fromObject(object.pythonSettings, long + 1); } if (object.nodeSettings != null) { - if (typeof object.nodeSettings !== "object") + if (!$util.isObject(object.nodeSettings)) throw TypeError(".google.api.ClientLibrarySettings.nodeSettings: object expected"); - message.nodeSettings = $root.google.api.NodeSettings.fromObject(object.nodeSettings); + message.nodeSettings = $root.google.api.NodeSettings.fromObject(object.nodeSettings, long + 1); } if (object.dotnetSettings != null) { - if (typeof object.dotnetSettings !== "object") + if (!$util.isObject(object.dotnetSettings)) throw TypeError(".google.api.ClientLibrarySettings.dotnetSettings: object expected"); - message.dotnetSettings = $root.google.api.DotnetSettings.fromObject(object.dotnetSettings); + message.dotnetSettings = $root.google.api.DotnetSettings.fromObject(object.dotnetSettings, long + 1); } if (object.rubySettings != null) { - if (typeof object.rubySettings !== "object") + if (!$util.isObject(object.rubySettings)) throw TypeError(".google.api.ClientLibrarySettings.rubySettings: object expected"); - message.rubySettings = $root.google.api.RubySettings.fromObject(object.rubySettings); + message.rubySettings = $root.google.api.RubySettings.fromObject(object.rubySettings, long + 1); } if (object.goSettings != null) { - if (typeof object.goSettings !== "object") + if (!$util.isObject(object.goSettings)) throw TypeError(".google.api.ClientLibrarySettings.goSettings: object expected"); - message.goSettings = $root.google.api.GoSettings.fromObject(object.goSettings); + message.goSettings = $root.google.api.GoSettings.fromObject(object.goSettings, long + 1); } return message; }; @@ -6667,9 +7570,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ClientLibrarySettings.toObject = function toObject(message, options) { + ClientLibrarySettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.version = ""; @@ -6684,28 +7591,28 @@ object.rubySettings = null; object.goSettings = null; } - if (message.version != null && message.hasOwnProperty("version")) + if (message.version != null && Object.hasOwnProperty.call(message, "version")) object.version = message.version; - if (message.launchStage != null && message.hasOwnProperty("launchStage")) + if (message.launchStage != null && Object.hasOwnProperty.call(message, "launchStage")) object.launchStage = options.enums === String ? $root.google.api.LaunchStage[message.launchStage] === undefined ? message.launchStage : $root.google.api.LaunchStage[message.launchStage] : message.launchStage; - if (message.restNumericEnums != null && message.hasOwnProperty("restNumericEnums")) + if (message.restNumericEnums != null && Object.hasOwnProperty.call(message, "restNumericEnums")) object.restNumericEnums = message.restNumericEnums; - if (message.javaSettings != null && message.hasOwnProperty("javaSettings")) - object.javaSettings = $root.google.api.JavaSettings.toObject(message.javaSettings, options); - if (message.cppSettings != null && message.hasOwnProperty("cppSettings")) - object.cppSettings = $root.google.api.CppSettings.toObject(message.cppSettings, options); - if (message.phpSettings != null && message.hasOwnProperty("phpSettings")) - object.phpSettings = $root.google.api.PhpSettings.toObject(message.phpSettings, options); - if (message.pythonSettings != null && message.hasOwnProperty("pythonSettings")) - object.pythonSettings = $root.google.api.PythonSettings.toObject(message.pythonSettings, options); - if (message.nodeSettings != null && message.hasOwnProperty("nodeSettings")) - object.nodeSettings = $root.google.api.NodeSettings.toObject(message.nodeSettings, options); - if (message.dotnetSettings != null && message.hasOwnProperty("dotnetSettings")) - object.dotnetSettings = $root.google.api.DotnetSettings.toObject(message.dotnetSettings, options); - if (message.rubySettings != null && message.hasOwnProperty("rubySettings")) - object.rubySettings = $root.google.api.RubySettings.toObject(message.rubySettings, options); - if (message.goSettings != null && message.hasOwnProperty("goSettings")) - object.goSettings = $root.google.api.GoSettings.toObject(message.goSettings, options); + if (message.javaSettings != null && Object.hasOwnProperty.call(message, "javaSettings")) + object.javaSettings = $root.google.api.JavaSettings.toObject(message.javaSettings, options, q + 1); + if (message.cppSettings != null && Object.hasOwnProperty.call(message, "cppSettings")) + object.cppSettings = $root.google.api.CppSettings.toObject(message.cppSettings, options, q + 1); + if (message.phpSettings != null && Object.hasOwnProperty.call(message, "phpSettings")) + object.phpSettings = $root.google.api.PhpSettings.toObject(message.phpSettings, options, q + 1); + if (message.pythonSettings != null && Object.hasOwnProperty.call(message, "pythonSettings")) + object.pythonSettings = $root.google.api.PythonSettings.toObject(message.pythonSettings, options, q + 1); + if (message.nodeSettings != null && Object.hasOwnProperty.call(message, "nodeSettings")) + object.nodeSettings = $root.google.api.NodeSettings.toObject(message.nodeSettings, options, q + 1); + if (message.dotnetSettings != null && Object.hasOwnProperty.call(message, "dotnetSettings")) + object.dotnetSettings = $root.google.api.DotnetSettings.toObject(message.dotnetSettings, options, q + 1); + if (message.rubySettings != null && Object.hasOwnProperty.call(message, "rubySettings")) + object.rubySettings = $root.google.api.RubySettings.toObject(message.rubySettings, options, q + 1); + if (message.goSettings != null && Object.hasOwnProperty.call(message, "goSettings")) + object.goSettings = $root.google.api.GoSettings.toObject(message.goSettings, options, q + 1); return object; }; @@ -6771,7 +7678,7 @@ this.librarySettings = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -6884,12 +7791,16 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Publishing.encode = function encode(message, writer) { + Publishing.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.methodSettings != null && message.methodSettings.length) for (var i = 0; i < message.methodSettings.length; ++i) - $root.google.api.MethodSettings.encode(message.methodSettings[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.api.MethodSettings.encode(message.methodSettings[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.newIssueUri != null && Object.hasOwnProperty.call(message, "newIssueUri")) writer.uint32(/* id 101, wireType 2 =*/810).string(message.newIssueUri); if (message.documentationUri != null && Object.hasOwnProperty.call(message, "documentationUri")) @@ -6907,7 +7818,7 @@ writer.uint32(/* id 107, wireType 0 =*/856).int32(message.organization); if (message.librarySettings != null && message.librarySettings.length) for (var i = 0; i < message.librarySettings.length; ++i) - $root.google.api.ClientLibrarySettings.encode(message.librarySettings[i], writer.uint32(/* id 109, wireType 2 =*/874).fork()).ldelim(); + $root.google.api.ClientLibrarySettings.encode(message.librarySettings[i], writer.uint32(/* id 109, wireType 2 =*/874).fork(), q + 1).ldelim(); if (message.protoReferenceDocumentationUri != null && Object.hasOwnProperty.call(message, "protoReferenceDocumentationUri")) writer.uint32(/* id 110, wireType 2 =*/882).string(message.protoReferenceDocumentationUri); if (message.restReferenceDocumentationUri != null && Object.hasOwnProperty.call(message, "restReferenceDocumentationUri")) @@ -6939,17 +7850,23 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Publishing.decode = function decode(reader, length) { + Publishing.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.Publishing(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 2: { if (!(message.methodSettings && message.methodSettings.length)) message.methodSettings = []; - message.methodSettings.push($root.google.api.MethodSettings.decode(reader, reader.uint32())); + message.methodSettings.push($root.google.api.MethodSettings.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 101: { @@ -6985,7 +7902,7 @@ case 109: { if (!(message.librarySettings && message.librarySettings.length)) message.librarySettings = []; - message.librarySettings.push($root.google.api.ClientLibrarySettings.decode(reader, reader.uint32())); + message.librarySettings.push($root.google.api.ClientLibrarySettings.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 110: { @@ -6997,7 +7914,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -7028,41 +7945,45 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Publishing.verify = function verify(message) { + Publishing.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.methodSettings != null && message.hasOwnProperty("methodSettings")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.methodSettings != null && Object.hasOwnProperty.call(message, "methodSettings")) { if (!Array.isArray(message.methodSettings)) return "methodSettings: array expected"; for (var i = 0; i < message.methodSettings.length; ++i) { - var error = $root.google.api.MethodSettings.verify(message.methodSettings[i]); + var error = $root.google.api.MethodSettings.verify(message.methodSettings[i], long + 1); if (error) return "methodSettings." + error; } } - if (message.newIssueUri != null && message.hasOwnProperty("newIssueUri")) + if (message.newIssueUri != null && Object.hasOwnProperty.call(message, "newIssueUri")) if (!$util.isString(message.newIssueUri)) return "newIssueUri: string expected"; - if (message.documentationUri != null && message.hasOwnProperty("documentationUri")) + if (message.documentationUri != null && Object.hasOwnProperty.call(message, "documentationUri")) if (!$util.isString(message.documentationUri)) return "documentationUri: string expected"; - if (message.apiShortName != null && message.hasOwnProperty("apiShortName")) + if (message.apiShortName != null && Object.hasOwnProperty.call(message, "apiShortName")) if (!$util.isString(message.apiShortName)) return "apiShortName: string expected"; - if (message.githubLabel != null && message.hasOwnProperty("githubLabel")) + if (message.githubLabel != null && Object.hasOwnProperty.call(message, "githubLabel")) if (!$util.isString(message.githubLabel)) return "githubLabel: string expected"; - if (message.codeownerGithubTeams != null && message.hasOwnProperty("codeownerGithubTeams")) { + if (message.codeownerGithubTeams != null && Object.hasOwnProperty.call(message, "codeownerGithubTeams")) { if (!Array.isArray(message.codeownerGithubTeams)) return "codeownerGithubTeams: array expected"; for (var i = 0; i < message.codeownerGithubTeams.length; ++i) if (!$util.isString(message.codeownerGithubTeams[i])) return "codeownerGithubTeams: string[] expected"; } - if (message.docTagPrefix != null && message.hasOwnProperty("docTagPrefix")) + if (message.docTagPrefix != null && Object.hasOwnProperty.call(message, "docTagPrefix")) if (!$util.isString(message.docTagPrefix)) return "docTagPrefix: string expected"; - if (message.organization != null && message.hasOwnProperty("organization")) + if (message.organization != null && Object.hasOwnProperty.call(message, "organization")) switch (message.organization) { default: return "organization: enum value expected"; @@ -7076,19 +7997,19 @@ case 7: break; } - if (message.librarySettings != null && message.hasOwnProperty("librarySettings")) { + if (message.librarySettings != null && Object.hasOwnProperty.call(message, "librarySettings")) { if (!Array.isArray(message.librarySettings)) return "librarySettings: array expected"; for (var i = 0; i < message.librarySettings.length; ++i) { - var error = $root.google.api.ClientLibrarySettings.verify(message.librarySettings[i]); + var error = $root.google.api.ClientLibrarySettings.verify(message.librarySettings[i], long + 1); if (error) return "librarySettings." + error; } } - if (message.protoReferenceDocumentationUri != null && message.hasOwnProperty("protoReferenceDocumentationUri")) + if (message.protoReferenceDocumentationUri != null && Object.hasOwnProperty.call(message, "protoReferenceDocumentationUri")) if (!$util.isString(message.protoReferenceDocumentationUri)) return "protoReferenceDocumentationUri: string expected"; - if (message.restReferenceDocumentationUri != null && message.hasOwnProperty("restReferenceDocumentationUri")) + if (message.restReferenceDocumentationUri != null && Object.hasOwnProperty.call(message, "restReferenceDocumentationUri")) if (!$util.isString(message.restReferenceDocumentationUri)) return "restReferenceDocumentationUri: string expected"; return null; @@ -7102,18 +8023,24 @@ * @param {Object.} object Plain object * @returns {google.api.Publishing} Publishing */ - Publishing.fromObject = function fromObject(object) { + Publishing.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.Publishing) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.Publishing: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.Publishing(); if (object.methodSettings) { if (!Array.isArray(object.methodSettings)) throw TypeError(".google.api.Publishing.methodSettings: array expected"); message.methodSettings = []; for (var i = 0; i < object.methodSettings.length; ++i) { - if (typeof object.methodSettings[i] !== "object") + if (!$util.isObject(object.methodSettings[i])) throw TypeError(".google.api.Publishing.methodSettings: object expected"); - message.methodSettings[i] = $root.google.api.MethodSettings.fromObject(object.methodSettings[i]); + message.methodSettings[i] = $root.google.api.MethodSettings.fromObject(object.methodSettings[i], long + 1); } } if (object.newIssueUri != null) @@ -7178,9 +8105,9 @@ throw TypeError(".google.api.Publishing.librarySettings: array expected"); message.librarySettings = []; for (var i = 0; i < object.librarySettings.length; ++i) { - if (typeof object.librarySettings[i] !== "object") + if (!$util.isObject(object.librarySettings[i])) throw TypeError(".google.api.Publishing.librarySettings: object expected"); - message.librarySettings[i] = $root.google.api.ClientLibrarySettings.fromObject(object.librarySettings[i]); + message.librarySettings[i] = $root.google.api.ClientLibrarySettings.fromObject(object.librarySettings[i], long + 1); } } if (object.protoReferenceDocumentationUri != null) @@ -7199,9 +8126,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Publishing.toObject = function toObject(message, options) { + Publishing.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.methodSettings = []; @@ -7221,33 +8152,33 @@ if (message.methodSettings && message.methodSettings.length) { object.methodSettings = []; for (var j = 0; j < message.methodSettings.length; ++j) - object.methodSettings[j] = $root.google.api.MethodSettings.toObject(message.methodSettings[j], options); + object.methodSettings[j] = $root.google.api.MethodSettings.toObject(message.methodSettings[j], options, q + 1); } - if (message.newIssueUri != null && message.hasOwnProperty("newIssueUri")) + if (message.newIssueUri != null && Object.hasOwnProperty.call(message, "newIssueUri")) object.newIssueUri = message.newIssueUri; - if (message.documentationUri != null && message.hasOwnProperty("documentationUri")) + if (message.documentationUri != null && Object.hasOwnProperty.call(message, "documentationUri")) object.documentationUri = message.documentationUri; - if (message.apiShortName != null && message.hasOwnProperty("apiShortName")) + if (message.apiShortName != null && Object.hasOwnProperty.call(message, "apiShortName")) object.apiShortName = message.apiShortName; - if (message.githubLabel != null && message.hasOwnProperty("githubLabel")) + if (message.githubLabel != null && Object.hasOwnProperty.call(message, "githubLabel")) object.githubLabel = message.githubLabel; if (message.codeownerGithubTeams && message.codeownerGithubTeams.length) { object.codeownerGithubTeams = []; for (var j = 0; j < message.codeownerGithubTeams.length; ++j) object.codeownerGithubTeams[j] = message.codeownerGithubTeams[j]; } - if (message.docTagPrefix != null && message.hasOwnProperty("docTagPrefix")) + if (message.docTagPrefix != null && Object.hasOwnProperty.call(message, "docTagPrefix")) object.docTagPrefix = message.docTagPrefix; - if (message.organization != null && message.hasOwnProperty("organization")) + if (message.organization != null && Object.hasOwnProperty.call(message, "organization")) object.organization = options.enums === String ? $root.google.api.ClientLibraryOrganization[message.organization] === undefined ? message.organization : $root.google.api.ClientLibraryOrganization[message.organization] : message.organization; if (message.librarySettings && message.librarySettings.length) { object.librarySettings = []; for (var j = 0; j < message.librarySettings.length; ++j) - object.librarySettings[j] = $root.google.api.ClientLibrarySettings.toObject(message.librarySettings[j], options); + object.librarySettings[j] = $root.google.api.ClientLibrarySettings.toObject(message.librarySettings[j], options, q + 1); } - if (message.protoReferenceDocumentationUri != null && message.hasOwnProperty("protoReferenceDocumentationUri")) + if (message.protoReferenceDocumentationUri != null && Object.hasOwnProperty.call(message, "protoReferenceDocumentationUri")) object.protoReferenceDocumentationUri = message.protoReferenceDocumentationUri; - if (message.restReferenceDocumentationUri != null && message.hasOwnProperty("restReferenceDocumentationUri")) + if (message.restReferenceDocumentationUri != null && Object.hasOwnProperty.call(message, "restReferenceDocumentationUri")) object.restReferenceDocumentationUri = message.restReferenceDocumentationUri; return object; }; @@ -7304,7 +8235,7 @@ this.serviceClassNames = {}; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -7353,16 +8284,20 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - JavaSettings.encode = function encode(message, writer) { + JavaSettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.libraryPackage != null && Object.hasOwnProperty.call(message, "libraryPackage")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.libraryPackage); if (message.serviceClassNames != null && Object.hasOwnProperty.call(message, "serviceClassNames")) for (var keys = Object.keys(message.serviceClassNames), i = 0; i < keys.length; ++i) writer.uint32(/* id 2, wireType 2 =*/18).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]).uint32(/* id 2, wireType 2 =*/18).string(message.serviceClassNames[keys[i]]).ldelim(); if (message.common != null && Object.hasOwnProperty.call(message, "common")) - $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); return writer; }; @@ -7390,12 +8325,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - JavaSettings.decode = function decode(reader, length) { + JavaSettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.JavaSettings(), key, value; while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.libraryPackage = reader.string(); @@ -7417,19 +8358,21 @@ value = reader.string(); break; default: - reader.skipType(tag2 & 7); + reader.skipType(tag2 & 7, long); break; } } + if (key === "__proto__") + $util.makeProp(message.serviceClassNames, key); message.serviceClassNames[key] = value; break; } case 3: { - message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32()); + message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -7460,13 +8403,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - JavaSettings.verify = function verify(message) { + JavaSettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.libraryPackage != null && message.hasOwnProperty("libraryPackage")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.libraryPackage != null && Object.hasOwnProperty.call(message, "libraryPackage")) if (!$util.isString(message.libraryPackage)) return "libraryPackage: string expected"; - if (message.serviceClassNames != null && message.hasOwnProperty("serviceClassNames")) { + if (message.serviceClassNames != null && Object.hasOwnProperty.call(message, "serviceClassNames")) { if (!$util.isObject(message.serviceClassNames)) return "serviceClassNames: object expected"; var key = Object.keys(message.serviceClassNames); @@ -7474,8 +8421,8 @@ if (!$util.isString(message.serviceClassNames[key[i]])) return "serviceClassNames: string{k:string} expected"; } - if (message.common != null && message.hasOwnProperty("common")) { - var error = $root.google.api.CommonLanguageSettings.verify(message.common); + if (message.common != null && Object.hasOwnProperty.call(message, "common")) { + var error = $root.google.api.CommonLanguageSettings.verify(message.common, long + 1); if (error) return "common." + error; } @@ -7490,23 +8437,32 @@ * @param {Object.} object Plain object * @returns {google.api.JavaSettings} JavaSettings */ - JavaSettings.fromObject = function fromObject(object) { + JavaSettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.JavaSettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.JavaSettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.JavaSettings(); if (object.libraryPackage != null) message.libraryPackage = String(object.libraryPackage); if (object.serviceClassNames) { - if (typeof object.serviceClassNames !== "object") + if (!$util.isObject(object.serviceClassNames)) throw TypeError(".google.api.JavaSettings.serviceClassNames: object expected"); message.serviceClassNames = {}; - for (var keys = Object.keys(object.serviceClassNames), i = 0; i < keys.length; ++i) + for (var keys = Object.keys(object.serviceClassNames), i = 0; i < keys.length; ++i) { + if (keys[i] === "__proto__") + $util.makeProp(message.serviceClassNames, keys[i]); message.serviceClassNames[keys[i]] = String(object.serviceClassNames[keys[i]]); + } } if (object.common != null) { - if (typeof object.common !== "object") + if (!$util.isObject(object.common)) throw TypeError(".google.api.JavaSettings.common: object expected"); - message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common); + message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common, long + 1); } return message; }; @@ -7520,9 +8476,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - JavaSettings.toObject = function toObject(message, options) { + JavaSettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.objects || options.defaults) object.serviceClassNames = {}; @@ -7530,16 +8490,19 @@ object.libraryPackage = ""; object.common = null; } - if (message.libraryPackage != null && message.hasOwnProperty("libraryPackage")) + if (message.libraryPackage != null && Object.hasOwnProperty.call(message, "libraryPackage")) object.libraryPackage = message.libraryPackage; var keys2; if (message.serviceClassNames && (keys2 = Object.keys(message.serviceClassNames)).length) { object.serviceClassNames = {}; - for (var j = 0; j < keys2.length; ++j) + for (var j = 0; j < keys2.length; ++j) { + if (keys2[j] === "__proto__") + $util.makeProp(object.serviceClassNames, keys2[j]); object.serviceClassNames[keys2[j]] = message.serviceClassNames[keys2[j]]; + } } - if (message.common != null && message.hasOwnProperty("common")) - object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options); + if (message.common != null && Object.hasOwnProperty.call(message, "common")) + object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options, q + 1); return object; }; @@ -7592,7 +8555,7 @@ function CppSettings(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -7625,11 +8588,15 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - CppSettings.encode = function encode(message, writer) { + CppSettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.common != null && Object.hasOwnProperty.call(message, "common")) - $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -7657,19 +8624,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - CppSettings.decode = function decode(reader, length) { + CppSettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.CppSettings(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32()); + message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -7700,11 +8673,15 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - CppSettings.verify = function verify(message) { + CppSettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.common != null && message.hasOwnProperty("common")) { - var error = $root.google.api.CommonLanguageSettings.verify(message.common); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.common != null && Object.hasOwnProperty.call(message, "common")) { + var error = $root.google.api.CommonLanguageSettings.verify(message.common, long + 1); if (error) return "common." + error; } @@ -7719,14 +8696,20 @@ * @param {Object.} object Plain object * @returns {google.api.CppSettings} CppSettings */ - CppSettings.fromObject = function fromObject(object) { + CppSettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.CppSettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.CppSettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.CppSettings(); if (object.common != null) { - if (typeof object.common !== "object") + if (!$util.isObject(object.common)) throw TypeError(".google.api.CppSettings.common: object expected"); - message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common); + message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common, long + 1); } return message; }; @@ -7740,14 +8723,18 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - CppSettings.toObject = function toObject(message, options) { + CppSettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.common = null; - if (message.common != null && message.hasOwnProperty("common")) - object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options); + if (message.common != null && Object.hasOwnProperty.call(message, "common")) + object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options, q + 1); return object; }; @@ -7800,7 +8787,7 @@ function PhpSettings(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -7833,11 +8820,15 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - PhpSettings.encode = function encode(message, writer) { + PhpSettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.common != null && Object.hasOwnProperty.call(message, "common")) - $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -7865,19 +8856,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - PhpSettings.decode = function decode(reader, length) { + PhpSettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.PhpSettings(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32()); + message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -7908,11 +8905,15 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - PhpSettings.verify = function verify(message) { + PhpSettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.common != null && message.hasOwnProperty("common")) { - var error = $root.google.api.CommonLanguageSettings.verify(message.common); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.common != null && Object.hasOwnProperty.call(message, "common")) { + var error = $root.google.api.CommonLanguageSettings.verify(message.common, long + 1); if (error) return "common." + error; } @@ -7927,14 +8928,20 @@ * @param {Object.} object Plain object * @returns {google.api.PhpSettings} PhpSettings */ - PhpSettings.fromObject = function fromObject(object) { + PhpSettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.PhpSettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.PhpSettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.PhpSettings(); if (object.common != null) { - if (typeof object.common !== "object") + if (!$util.isObject(object.common)) throw TypeError(".google.api.PhpSettings.common: object expected"); - message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common); + message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common, long + 1); } return message; }; @@ -7948,14 +8955,18 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - PhpSettings.toObject = function toObject(message, options) { + PhpSettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.common = null; - if (message.common != null && message.hasOwnProperty("common")) - object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options); + if (message.common != null && Object.hasOwnProperty.call(message, "common")) + object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options, q + 1); return object; }; @@ -8008,7 +9019,7 @@ function PythonSettings(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -8041,11 +9052,15 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - PythonSettings.encode = function encode(message, writer) { + PythonSettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.common != null && Object.hasOwnProperty.call(message, "common")) - $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -8073,19 +9088,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - PythonSettings.decode = function decode(reader, length) { + PythonSettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.PythonSettings(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32()); + message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -8116,11 +9137,15 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - PythonSettings.verify = function verify(message) { + PythonSettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.common != null && message.hasOwnProperty("common")) { - var error = $root.google.api.CommonLanguageSettings.verify(message.common); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.common != null && Object.hasOwnProperty.call(message, "common")) { + var error = $root.google.api.CommonLanguageSettings.verify(message.common, long + 1); if (error) return "common." + error; } @@ -8135,14 +9160,20 @@ * @param {Object.} object Plain object * @returns {google.api.PythonSettings} PythonSettings */ - PythonSettings.fromObject = function fromObject(object) { + PythonSettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.PythonSettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.PythonSettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.PythonSettings(); if (object.common != null) { - if (typeof object.common !== "object") + if (!$util.isObject(object.common)) throw TypeError(".google.api.PythonSettings.common: object expected"); - message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common); + message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common, long + 1); } return message; }; @@ -8156,14 +9187,18 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - PythonSettings.toObject = function toObject(message, options) { + PythonSettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.common = null; - if (message.common != null && message.hasOwnProperty("common")) - object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options); + if (message.common != null && Object.hasOwnProperty.call(message, "common")) + object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options, q + 1); return object; }; @@ -8216,7 +9251,7 @@ function NodeSettings(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -8249,11 +9284,15 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - NodeSettings.encode = function encode(message, writer) { + NodeSettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.common != null && Object.hasOwnProperty.call(message, "common")) - $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -8281,19 +9320,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - NodeSettings.decode = function decode(reader, length) { + NodeSettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.NodeSettings(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32()); + message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -8324,11 +9369,15 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - NodeSettings.verify = function verify(message) { + NodeSettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.common != null && message.hasOwnProperty("common")) { - var error = $root.google.api.CommonLanguageSettings.verify(message.common); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.common != null && Object.hasOwnProperty.call(message, "common")) { + var error = $root.google.api.CommonLanguageSettings.verify(message.common, long + 1); if (error) return "common." + error; } @@ -8343,14 +9392,20 @@ * @param {Object.} object Plain object * @returns {google.api.NodeSettings} NodeSettings */ - NodeSettings.fromObject = function fromObject(object) { + NodeSettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.NodeSettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.NodeSettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.NodeSettings(); if (object.common != null) { - if (typeof object.common !== "object") + if (!$util.isObject(object.common)) throw TypeError(".google.api.NodeSettings.common: object expected"); - message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common); + message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common, long + 1); } return message; }; @@ -8364,14 +9419,18 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - NodeSettings.toObject = function toObject(message, options) { + NodeSettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.common = null; - if (message.common != null && message.hasOwnProperty("common")) - object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options); + if (message.common != null && Object.hasOwnProperty.call(message, "common")) + object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options, q + 1); return object; }; @@ -8434,7 +9493,7 @@ this.handwrittenSignatures = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -8507,11 +9566,15 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - DotnetSettings.encode = function encode(message, writer) { + DotnetSettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.common != null && Object.hasOwnProperty.call(message, "common")) - $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); if (message.renamedServices != null && Object.hasOwnProperty.call(message, "renamedServices")) for (var keys = Object.keys(message.renamedServices), i = 0; i < keys.length; ++i) writer.uint32(/* id 2, wireType 2 =*/18).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]).uint32(/* id 2, wireType 2 =*/18).string(message.renamedServices[keys[i]]).ldelim(); @@ -8554,15 +9617,21 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - DotnetSettings.decode = function decode(reader, length) { + DotnetSettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.DotnetSettings(), key, value; while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32()); + message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } case 2: { @@ -8581,10 +9650,12 @@ value = reader.string(); break; default: - reader.skipType(tag2 & 7); + reader.skipType(tag2 & 7, long); break; } } + if (key === "__proto__") + $util.makeProp(message.renamedServices, key); message.renamedServices[key] = value; break; } @@ -8604,10 +9675,12 @@ value = reader.string(); break; default: - reader.skipType(tag2 & 7); + reader.skipType(tag2 & 7, long); break; } } + if (key === "__proto__") + $util.makeProp(message.renamedResources, key); message.renamedResources[key] = value; break; } @@ -8630,7 +9703,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -8661,15 +9734,19 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - DotnetSettings.verify = function verify(message) { + DotnetSettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.common != null && message.hasOwnProperty("common")) { - var error = $root.google.api.CommonLanguageSettings.verify(message.common); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.common != null && Object.hasOwnProperty.call(message, "common")) { + var error = $root.google.api.CommonLanguageSettings.verify(message.common, long + 1); if (error) return "common." + error; } - if (message.renamedServices != null && message.hasOwnProperty("renamedServices")) { + if (message.renamedServices != null && Object.hasOwnProperty.call(message, "renamedServices")) { if (!$util.isObject(message.renamedServices)) return "renamedServices: object expected"; var key = Object.keys(message.renamedServices); @@ -8677,7 +9754,7 @@ if (!$util.isString(message.renamedServices[key[i]])) return "renamedServices: string{k:string} expected"; } - if (message.renamedResources != null && message.hasOwnProperty("renamedResources")) { + if (message.renamedResources != null && Object.hasOwnProperty.call(message, "renamedResources")) { if (!$util.isObject(message.renamedResources)) return "renamedResources: object expected"; var key = Object.keys(message.renamedResources); @@ -8685,21 +9762,21 @@ if (!$util.isString(message.renamedResources[key[i]])) return "renamedResources: string{k:string} expected"; } - if (message.ignoredResources != null && message.hasOwnProperty("ignoredResources")) { + if (message.ignoredResources != null && Object.hasOwnProperty.call(message, "ignoredResources")) { if (!Array.isArray(message.ignoredResources)) return "ignoredResources: array expected"; for (var i = 0; i < message.ignoredResources.length; ++i) if (!$util.isString(message.ignoredResources[i])) return "ignoredResources: string[] expected"; } - if (message.forcedNamespaceAliases != null && message.hasOwnProperty("forcedNamespaceAliases")) { + if (message.forcedNamespaceAliases != null && Object.hasOwnProperty.call(message, "forcedNamespaceAliases")) { if (!Array.isArray(message.forcedNamespaceAliases)) return "forcedNamespaceAliases: array expected"; for (var i = 0; i < message.forcedNamespaceAliases.length; ++i) if (!$util.isString(message.forcedNamespaceAliases[i])) return "forcedNamespaceAliases: string[] expected"; } - if (message.handwrittenSignatures != null && message.hasOwnProperty("handwrittenSignatures")) { + if (message.handwrittenSignatures != null && Object.hasOwnProperty.call(message, "handwrittenSignatures")) { if (!Array.isArray(message.handwrittenSignatures)) return "handwrittenSignatures: array expected"; for (var i = 0; i < message.handwrittenSignatures.length; ++i) @@ -8717,28 +9794,40 @@ * @param {Object.} object Plain object * @returns {google.api.DotnetSettings} DotnetSettings */ - DotnetSettings.fromObject = function fromObject(object) { + DotnetSettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.DotnetSettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.DotnetSettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.DotnetSettings(); if (object.common != null) { - if (typeof object.common !== "object") + if (!$util.isObject(object.common)) throw TypeError(".google.api.DotnetSettings.common: object expected"); - message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common); + message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common, long + 1); } if (object.renamedServices) { - if (typeof object.renamedServices !== "object") + if (!$util.isObject(object.renamedServices)) throw TypeError(".google.api.DotnetSettings.renamedServices: object expected"); message.renamedServices = {}; - for (var keys = Object.keys(object.renamedServices), i = 0; i < keys.length; ++i) + for (var keys = Object.keys(object.renamedServices), i = 0; i < keys.length; ++i) { + if (keys[i] === "__proto__") + $util.makeProp(message.renamedServices, keys[i]); message.renamedServices[keys[i]] = String(object.renamedServices[keys[i]]); + } } if (object.renamedResources) { - if (typeof object.renamedResources !== "object") + if (!$util.isObject(object.renamedResources)) throw TypeError(".google.api.DotnetSettings.renamedResources: object expected"); message.renamedResources = {}; - for (var keys = Object.keys(object.renamedResources), i = 0; i < keys.length; ++i) + for (var keys = Object.keys(object.renamedResources), i = 0; i < keys.length; ++i) { + if (keys[i] === "__proto__") + $util.makeProp(message.renamedResources, keys[i]); message.renamedResources[keys[i]] = String(object.renamedResources[keys[i]]); + } } if (object.ignoredResources) { if (!Array.isArray(object.ignoredResources)) @@ -8773,9 +9862,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - DotnetSettings.toObject = function toObject(message, options) { + DotnetSettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.ignoredResources = []; @@ -8788,18 +9881,24 @@ } if (options.defaults) object.common = null; - if (message.common != null && message.hasOwnProperty("common")) - object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options); + if (message.common != null && Object.hasOwnProperty.call(message, "common")) + object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options, q + 1); var keys2; if (message.renamedServices && (keys2 = Object.keys(message.renamedServices)).length) { object.renamedServices = {}; - for (var j = 0; j < keys2.length; ++j) + for (var j = 0; j < keys2.length; ++j) { + if (keys2[j] === "__proto__") + $util.makeProp(object.renamedServices, keys2[j]); object.renamedServices[keys2[j]] = message.renamedServices[keys2[j]]; + } } if (message.renamedResources && (keys2 = Object.keys(message.renamedResources)).length) { object.renamedResources = {}; - for (var j = 0; j < keys2.length; ++j) + for (var j = 0; j < keys2.length; ++j) { + if (keys2[j] === "__proto__") + $util.makeProp(object.renamedResources, keys2[j]); object.renamedResources[keys2[j]] = message.renamedResources[keys2[j]]; + } } if (message.ignoredResources && message.ignoredResources.length) { object.ignoredResources = []; @@ -8868,7 +9967,7 @@ function RubySettings(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -8901,11 +10000,15 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - RubySettings.encode = function encode(message, writer) { + RubySettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.common != null && Object.hasOwnProperty.call(message, "common")) - $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -8933,19 +10036,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - RubySettings.decode = function decode(reader, length) { + RubySettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.RubySettings(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32()); + message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -8976,11 +10085,15 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - RubySettings.verify = function verify(message) { + RubySettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.common != null && message.hasOwnProperty("common")) { - var error = $root.google.api.CommonLanguageSettings.verify(message.common); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.common != null && Object.hasOwnProperty.call(message, "common")) { + var error = $root.google.api.CommonLanguageSettings.verify(message.common, long + 1); if (error) return "common." + error; } @@ -8995,14 +10108,20 @@ * @param {Object.} object Plain object * @returns {google.api.RubySettings} RubySettings */ - RubySettings.fromObject = function fromObject(object) { + RubySettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.RubySettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.RubySettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.RubySettings(); if (object.common != null) { - if (typeof object.common !== "object") + if (!$util.isObject(object.common)) throw TypeError(".google.api.RubySettings.common: object expected"); - message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common); + message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common, long + 1); } return message; }; @@ -9016,14 +10135,18 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - RubySettings.toObject = function toObject(message, options) { + RubySettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.common = null; - if (message.common != null && message.hasOwnProperty("common")) - object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options); + if (message.common != null && Object.hasOwnProperty.call(message, "common")) + object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options, q + 1); return object; }; @@ -9076,7 +10199,7 @@ function GoSettings(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -9109,11 +10232,15 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - GoSettings.encode = function encode(message, writer) { + GoSettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.common != null && Object.hasOwnProperty.call(message, "common")) - $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.api.CommonLanguageSettings.encode(message.common, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -9141,19 +10268,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - GoSettings.decode = function decode(reader, length) { + GoSettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.GoSettings(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32()); + message.common = $root.google.api.CommonLanguageSettings.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -9184,11 +10317,15 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - GoSettings.verify = function verify(message) { + GoSettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.common != null && message.hasOwnProperty("common")) { - var error = $root.google.api.CommonLanguageSettings.verify(message.common); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.common != null && Object.hasOwnProperty.call(message, "common")) { + var error = $root.google.api.CommonLanguageSettings.verify(message.common, long + 1); if (error) return "common." + error; } @@ -9203,14 +10340,20 @@ * @param {Object.} object Plain object * @returns {google.api.GoSettings} GoSettings */ - GoSettings.fromObject = function fromObject(object) { + GoSettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.GoSettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.GoSettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.GoSettings(); if (object.common != null) { - if (typeof object.common !== "object") + if (!$util.isObject(object.common)) throw TypeError(".google.api.GoSettings.common: object expected"); - message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common); + message.common = $root.google.api.CommonLanguageSettings.fromObject(object.common, long + 1); } return message; }; @@ -9224,14 +10367,18 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - GoSettings.toObject = function toObject(message, options) { + GoSettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.common = null; - if (message.common != null && message.hasOwnProperty("common")) - object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options); + if (message.common != null && Object.hasOwnProperty.call(message, "common")) + object.common = $root.google.api.CommonLanguageSettings.toObject(message.common, options, q + 1); return object; }; @@ -9287,7 +10434,7 @@ this.autoPopulatedFields = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -9336,13 +10483,17 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - MethodSettings.encode = function encode(message, writer) { + MethodSettings.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.selector != null && Object.hasOwnProperty.call(message, "selector")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.selector); if (message.longRunning != null && Object.hasOwnProperty.call(message, "longRunning")) - $root.google.api.MethodSettings.LongRunning.encode(message.longRunning, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.api.MethodSettings.LongRunning.encode(message.longRunning, writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.autoPopulatedFields != null && message.autoPopulatedFields.length) for (var i = 0; i < message.autoPopulatedFields.length; ++i) writer.uint32(/* id 3, wireType 2 =*/26).string(message.autoPopulatedFields[i]); @@ -9373,19 +10524,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - MethodSettings.decode = function decode(reader, length) { + MethodSettings.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.MethodSettings(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.selector = reader.string(); break; } case 2: { - message.longRunning = $root.google.api.MethodSettings.LongRunning.decode(reader, reader.uint32()); + message.longRunning = $root.google.api.MethodSettings.LongRunning.decode(reader, reader.uint32(), undefined, long + 1); break; } case 3: { @@ -9395,7 +10552,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -9426,18 +10583,22 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - MethodSettings.verify = function verify(message) { + MethodSettings.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.selector != null && message.hasOwnProperty("selector")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.selector != null && Object.hasOwnProperty.call(message, "selector")) if (!$util.isString(message.selector)) return "selector: string expected"; - if (message.longRunning != null && message.hasOwnProperty("longRunning")) { - var error = $root.google.api.MethodSettings.LongRunning.verify(message.longRunning); + if (message.longRunning != null && Object.hasOwnProperty.call(message, "longRunning")) { + var error = $root.google.api.MethodSettings.LongRunning.verify(message.longRunning, long + 1); if (error) return "longRunning." + error; } - if (message.autoPopulatedFields != null && message.hasOwnProperty("autoPopulatedFields")) { + if (message.autoPopulatedFields != null && Object.hasOwnProperty.call(message, "autoPopulatedFields")) { if (!Array.isArray(message.autoPopulatedFields)) return "autoPopulatedFields: array expected"; for (var i = 0; i < message.autoPopulatedFields.length; ++i) @@ -9455,16 +10616,22 @@ * @param {Object.} object Plain object * @returns {google.api.MethodSettings} MethodSettings */ - MethodSettings.fromObject = function fromObject(object) { + MethodSettings.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.MethodSettings) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.MethodSettings: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.MethodSettings(); if (object.selector != null) message.selector = String(object.selector); if (object.longRunning != null) { - if (typeof object.longRunning !== "object") + if (!$util.isObject(object.longRunning)) throw TypeError(".google.api.MethodSettings.longRunning: object expected"); - message.longRunning = $root.google.api.MethodSettings.LongRunning.fromObject(object.longRunning); + message.longRunning = $root.google.api.MethodSettings.LongRunning.fromObject(object.longRunning, long + 1); } if (object.autoPopulatedFields) { if (!Array.isArray(object.autoPopulatedFields)) @@ -9485,9 +10652,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - MethodSettings.toObject = function toObject(message, options) { + MethodSettings.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.autoPopulatedFields = []; @@ -9495,10 +10666,10 @@ object.selector = ""; object.longRunning = null; } - if (message.selector != null && message.hasOwnProperty("selector")) + if (message.selector != null && Object.hasOwnProperty.call(message, "selector")) object.selector = message.selector; - if (message.longRunning != null && message.hasOwnProperty("longRunning")) - object.longRunning = $root.google.api.MethodSettings.LongRunning.toObject(message.longRunning, options); + if (message.longRunning != null && Object.hasOwnProperty.call(message, "longRunning")) + object.longRunning = $root.google.api.MethodSettings.LongRunning.toObject(message.longRunning, options, q + 1); if (message.autoPopulatedFields && message.autoPopulatedFields.length) { object.autoPopulatedFields = []; for (var j = 0; j < message.autoPopulatedFields.length; ++j) @@ -9556,7 +10727,7 @@ function LongRunning(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -9613,17 +10784,21 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - LongRunning.encode = function encode(message, writer) { + LongRunning.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.initialPollDelay != null && Object.hasOwnProperty.call(message, "initialPollDelay")) - $root.google.protobuf.Duration.encode(message.initialPollDelay, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.protobuf.Duration.encode(message.initialPollDelay, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); if (message.pollDelayMultiplier != null && Object.hasOwnProperty.call(message, "pollDelayMultiplier")) writer.uint32(/* id 2, wireType 5 =*/21).float(message.pollDelayMultiplier); if (message.maxPollDelay != null && Object.hasOwnProperty.call(message, "maxPollDelay")) - $root.google.protobuf.Duration.encode(message.maxPollDelay, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.protobuf.Duration.encode(message.maxPollDelay, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); if (message.totalPollTimeout != null && Object.hasOwnProperty.call(message, "totalPollTimeout")) - $root.google.protobuf.Duration.encode(message.totalPollTimeout, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.google.protobuf.Duration.encode(message.totalPollTimeout, writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); return writer; }; @@ -9651,15 +10826,21 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - LongRunning.decode = function decode(reader, length) { + LongRunning.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.api.MethodSettings.LongRunning(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.initialPollDelay = $root.google.protobuf.Duration.decode(reader, reader.uint32()); + message.initialPollDelay = $root.google.protobuf.Duration.decode(reader, reader.uint32(), undefined, long + 1); break; } case 2: { @@ -9667,15 +10848,15 @@ break; } case 3: { - message.maxPollDelay = $root.google.protobuf.Duration.decode(reader, reader.uint32()); + message.maxPollDelay = $root.google.protobuf.Duration.decode(reader, reader.uint32(), undefined, long + 1); break; } case 4: { - message.totalPollTimeout = $root.google.protobuf.Duration.decode(reader, reader.uint32()); + message.totalPollTimeout = $root.google.protobuf.Duration.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -9706,24 +10887,28 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - LongRunning.verify = function verify(message) { + LongRunning.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.initialPollDelay != null && message.hasOwnProperty("initialPollDelay")) { - var error = $root.google.protobuf.Duration.verify(message.initialPollDelay); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.initialPollDelay != null && Object.hasOwnProperty.call(message, "initialPollDelay")) { + var error = $root.google.protobuf.Duration.verify(message.initialPollDelay, long + 1); if (error) return "initialPollDelay." + error; } - if (message.pollDelayMultiplier != null && message.hasOwnProperty("pollDelayMultiplier")) + if (message.pollDelayMultiplier != null && Object.hasOwnProperty.call(message, "pollDelayMultiplier")) if (typeof message.pollDelayMultiplier !== "number") return "pollDelayMultiplier: number expected"; - if (message.maxPollDelay != null && message.hasOwnProperty("maxPollDelay")) { - var error = $root.google.protobuf.Duration.verify(message.maxPollDelay); + if (message.maxPollDelay != null && Object.hasOwnProperty.call(message, "maxPollDelay")) { + var error = $root.google.protobuf.Duration.verify(message.maxPollDelay, long + 1); if (error) return "maxPollDelay." + error; } - if (message.totalPollTimeout != null && message.hasOwnProperty("totalPollTimeout")) { - var error = $root.google.protobuf.Duration.verify(message.totalPollTimeout); + if (message.totalPollTimeout != null && Object.hasOwnProperty.call(message, "totalPollTimeout")) { + var error = $root.google.protobuf.Duration.verify(message.totalPollTimeout, long + 1); if (error) return "totalPollTimeout." + error; } @@ -9738,26 +10923,32 @@ * @param {Object.} object Plain object * @returns {google.api.MethodSettings.LongRunning} LongRunning */ - LongRunning.fromObject = function fromObject(object) { + LongRunning.fromObject = function fromObject(object, long) { if (object instanceof $root.google.api.MethodSettings.LongRunning) return object; + if (!$util.isObject(object)) + throw TypeError(".google.api.MethodSettings.LongRunning: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.api.MethodSettings.LongRunning(); if (object.initialPollDelay != null) { - if (typeof object.initialPollDelay !== "object") + if (!$util.isObject(object.initialPollDelay)) throw TypeError(".google.api.MethodSettings.LongRunning.initialPollDelay: object expected"); - message.initialPollDelay = $root.google.protobuf.Duration.fromObject(object.initialPollDelay); + message.initialPollDelay = $root.google.protobuf.Duration.fromObject(object.initialPollDelay, long + 1); } if (object.pollDelayMultiplier != null) message.pollDelayMultiplier = Number(object.pollDelayMultiplier); if (object.maxPollDelay != null) { - if (typeof object.maxPollDelay !== "object") + if (!$util.isObject(object.maxPollDelay)) throw TypeError(".google.api.MethodSettings.LongRunning.maxPollDelay: object expected"); - message.maxPollDelay = $root.google.protobuf.Duration.fromObject(object.maxPollDelay); + message.maxPollDelay = $root.google.protobuf.Duration.fromObject(object.maxPollDelay, long + 1); } if (object.totalPollTimeout != null) { - if (typeof object.totalPollTimeout !== "object") + if (!$util.isObject(object.totalPollTimeout)) throw TypeError(".google.api.MethodSettings.LongRunning.totalPollTimeout: object expected"); - message.totalPollTimeout = $root.google.protobuf.Duration.fromObject(object.totalPollTimeout); + message.totalPollTimeout = $root.google.protobuf.Duration.fromObject(object.totalPollTimeout, long + 1); } return message; }; @@ -9771,9 +10962,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - LongRunning.toObject = function toObject(message, options) { + LongRunning.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.initialPollDelay = null; @@ -9781,14 +10976,14 @@ object.maxPollDelay = null; object.totalPollTimeout = null; } - if (message.initialPollDelay != null && message.hasOwnProperty("initialPollDelay")) - object.initialPollDelay = $root.google.protobuf.Duration.toObject(message.initialPollDelay, options); - if (message.pollDelayMultiplier != null && message.hasOwnProperty("pollDelayMultiplier")) + if (message.initialPollDelay != null && Object.hasOwnProperty.call(message, "initialPollDelay")) + object.initialPollDelay = $root.google.protobuf.Duration.toObject(message.initialPollDelay, options, q + 1); + if (message.pollDelayMultiplier != null && Object.hasOwnProperty.call(message, "pollDelayMultiplier")) object.pollDelayMultiplier = options.json && !isFinite(message.pollDelayMultiplier) ? String(message.pollDelayMultiplier) : message.pollDelayMultiplier; - if (message.maxPollDelay != null && message.hasOwnProperty("maxPollDelay")) - object.maxPollDelay = $root.google.protobuf.Duration.toObject(message.maxPollDelay, options); - if (message.totalPollTimeout != null && message.hasOwnProperty("totalPollTimeout")) - object.totalPollTimeout = $root.google.protobuf.Duration.toObject(message.totalPollTimeout, options); + if (message.maxPollDelay != null && Object.hasOwnProperty.call(message, "maxPollDelay")) + object.maxPollDelay = $root.google.protobuf.Duration.toObject(message.maxPollDelay, options, q + 1); + if (message.totalPollTimeout != null && Object.hasOwnProperty.call(message, "totalPollTimeout")) + object.totalPollTimeout = $root.google.protobuf.Duration.toObject(message.totalPollTimeout, options, q + 1); return object; }; @@ -9925,7 +11120,7 @@ this.file = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -9958,12 +11153,16 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - FileDescriptorSet.encode = function encode(message, writer) { + FileDescriptorSet.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.file != null && message.file.length) for (var i = 0; i < message.file.length; ++i) - $root.google.protobuf.FileDescriptorProto.encode(message.file[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.protobuf.FileDescriptorProto.encode(message.file[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -9991,21 +11190,27 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - FileDescriptorSet.decode = function decode(reader, length) { + FileDescriptorSet.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FileDescriptorSet(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.file && message.file.length)) message.file = []; - message.file.push($root.google.protobuf.FileDescriptorProto.decode(reader, reader.uint32())); + message.file.push($root.google.protobuf.FileDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -10036,14 +11241,18 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - FileDescriptorSet.verify = function verify(message) { + FileDescriptorSet.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.file != null && message.hasOwnProperty("file")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.file != null && Object.hasOwnProperty.call(message, "file")) { if (!Array.isArray(message.file)) return "file: array expected"; for (var i = 0; i < message.file.length; ++i) { - var error = $root.google.protobuf.FileDescriptorProto.verify(message.file[i]); + var error = $root.google.protobuf.FileDescriptorProto.verify(message.file[i], long + 1); if (error) return "file." + error; } @@ -10059,18 +11268,24 @@ * @param {Object.} object Plain object * @returns {google.protobuf.FileDescriptorSet} FileDescriptorSet */ - FileDescriptorSet.fromObject = function fromObject(object) { + FileDescriptorSet.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.FileDescriptorSet) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.FileDescriptorSet: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.FileDescriptorSet(); if (object.file) { if (!Array.isArray(object.file)) throw TypeError(".google.protobuf.FileDescriptorSet.file: array expected"); message.file = []; for (var i = 0; i < object.file.length; ++i) { - if (typeof object.file[i] !== "object") + if (!$util.isObject(object.file[i])) throw TypeError(".google.protobuf.FileDescriptorSet.file: object expected"); - message.file[i] = $root.google.protobuf.FileDescriptorProto.fromObject(object.file[i]); + message.file[i] = $root.google.protobuf.FileDescriptorProto.fromObject(object.file[i], long + 1); } } return message; @@ -10085,16 +11300,20 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - FileDescriptorSet.toObject = function toObject(message, options) { + FileDescriptorSet.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.file = []; if (message.file && message.file.length) { object.file = []; for (var j = 0; j < message.file.length; ++j) - object.file[j] = $root.google.protobuf.FileDescriptorProto.toObject(message.file[j], options); + object.file[j] = $root.google.protobuf.FileDescriptorProto.toObject(message.file[j], options, q + 1); } return object; }; @@ -10199,7 +11418,7 @@ this.extension = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -10328,9 +11547,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - FileDescriptorProto.encode = function encode(message, writer) { + FileDescriptorProto.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message["package"] != null && Object.hasOwnProperty.call(message, "package")) @@ -10340,20 +11563,20 @@ writer.uint32(/* id 3, wireType 2 =*/26).string(message.dependency[i]); if (message.messageType != null && message.messageType.length) for (var i = 0; i < message.messageType.length; ++i) - $root.google.protobuf.DescriptorProto.encode(message.messageType[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.google.protobuf.DescriptorProto.encode(message.messageType[i], writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); if (message.enumType != null && message.enumType.length) for (var i = 0; i < message.enumType.length; ++i) - $root.google.protobuf.EnumDescriptorProto.encode(message.enumType[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); + $root.google.protobuf.EnumDescriptorProto.encode(message.enumType[i], writer.uint32(/* id 5, wireType 2 =*/42).fork(), q + 1).ldelim(); if (message.service != null && message.service.length) for (var i = 0; i < message.service.length; ++i) - $root.google.protobuf.ServiceDescriptorProto.encode(message.service[i], writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim(); + $root.google.protobuf.ServiceDescriptorProto.encode(message.service[i], writer.uint32(/* id 6, wireType 2 =*/50).fork(), q + 1).ldelim(); if (message.extension != null && message.extension.length) for (var i = 0; i < message.extension.length; ++i) - $root.google.protobuf.FieldDescriptorProto.encode(message.extension[i], writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim(); + $root.google.protobuf.FieldDescriptorProto.encode(message.extension[i], writer.uint32(/* id 7, wireType 2 =*/58).fork(), q + 1).ldelim(); if (message.options != null && Object.hasOwnProperty.call(message, "options")) - $root.google.protobuf.FileOptions.encode(message.options, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim(); + $root.google.protobuf.FileOptions.encode(message.options, writer.uint32(/* id 8, wireType 2 =*/66).fork(), q + 1).ldelim(); if (message.sourceCodeInfo != null && Object.hasOwnProperty.call(message, "sourceCodeInfo")) - $root.google.protobuf.SourceCodeInfo.encode(message.sourceCodeInfo, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim(); + $root.google.protobuf.SourceCodeInfo.encode(message.sourceCodeInfo, writer.uint32(/* id 9, wireType 2 =*/74).fork(), q + 1).ldelim(); if (message.publicDependency != null && message.publicDependency.length) for (var i = 0; i < message.publicDependency.length; ++i) writer.uint32(/* id 10, wireType 0 =*/80).int32(message.publicDependency[i]); @@ -10391,12 +11614,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - FileDescriptorProto.decode = function decode(reader, length) { + FileDescriptorProto.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FileDescriptorProto(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); @@ -10437,33 +11666,33 @@ case 4: { if (!(message.messageType && message.messageType.length)) message.messageType = []; - message.messageType.push($root.google.protobuf.DescriptorProto.decode(reader, reader.uint32())); + message.messageType.push($root.google.protobuf.DescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 5: { if (!(message.enumType && message.enumType.length)) message.enumType = []; - message.enumType.push($root.google.protobuf.EnumDescriptorProto.decode(reader, reader.uint32())); + message.enumType.push($root.google.protobuf.EnumDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 6: { if (!(message.service && message.service.length)) message.service = []; - message.service.push($root.google.protobuf.ServiceDescriptorProto.decode(reader, reader.uint32())); + message.service.push($root.google.protobuf.ServiceDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 7: { if (!(message.extension && message.extension.length)) message.extension = []; - message.extension.push($root.google.protobuf.FieldDescriptorProto.decode(reader, reader.uint32())); + message.extension.push($root.google.protobuf.FieldDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 8: { - message.options = $root.google.protobuf.FileOptions.decode(reader, reader.uint32()); + message.options = $root.google.protobuf.FileOptions.decode(reader, reader.uint32(), undefined, long + 1); break; } case 9: { - message.sourceCodeInfo = $root.google.protobuf.SourceCodeInfo.decode(reader, reader.uint32()); + message.sourceCodeInfo = $root.google.protobuf.SourceCodeInfo.decode(reader, reader.uint32(), undefined, long + 1); break; } case 12: { @@ -10475,7 +11704,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -10506,86 +11735,90 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - FileDescriptorProto.verify = function verify(message) { + FileDescriptorProto.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message["package"] != null && message.hasOwnProperty("package")) + if (message["package"] != null && Object.hasOwnProperty.call(message, "package")) if (!$util.isString(message["package"])) return "package: string expected"; - if (message.dependency != null && message.hasOwnProperty("dependency")) { + if (message.dependency != null && Object.hasOwnProperty.call(message, "dependency")) { if (!Array.isArray(message.dependency)) return "dependency: array expected"; for (var i = 0; i < message.dependency.length; ++i) if (!$util.isString(message.dependency[i])) return "dependency: string[] expected"; } - if (message.publicDependency != null && message.hasOwnProperty("publicDependency")) { + if (message.publicDependency != null && Object.hasOwnProperty.call(message, "publicDependency")) { if (!Array.isArray(message.publicDependency)) return "publicDependency: array expected"; for (var i = 0; i < message.publicDependency.length; ++i) if (!$util.isInteger(message.publicDependency[i])) return "publicDependency: integer[] expected"; } - if (message.weakDependency != null && message.hasOwnProperty("weakDependency")) { + if (message.weakDependency != null && Object.hasOwnProperty.call(message, "weakDependency")) { if (!Array.isArray(message.weakDependency)) return "weakDependency: array expected"; for (var i = 0; i < message.weakDependency.length; ++i) if (!$util.isInteger(message.weakDependency[i])) return "weakDependency: integer[] expected"; } - if (message.messageType != null && message.hasOwnProperty("messageType")) { + if (message.messageType != null && Object.hasOwnProperty.call(message, "messageType")) { if (!Array.isArray(message.messageType)) return "messageType: array expected"; for (var i = 0; i < message.messageType.length; ++i) { - var error = $root.google.protobuf.DescriptorProto.verify(message.messageType[i]); + var error = $root.google.protobuf.DescriptorProto.verify(message.messageType[i], long + 1); if (error) return "messageType." + error; } } - if (message.enumType != null && message.hasOwnProperty("enumType")) { + if (message.enumType != null && Object.hasOwnProperty.call(message, "enumType")) { if (!Array.isArray(message.enumType)) return "enumType: array expected"; for (var i = 0; i < message.enumType.length; ++i) { - var error = $root.google.protobuf.EnumDescriptorProto.verify(message.enumType[i]); + var error = $root.google.protobuf.EnumDescriptorProto.verify(message.enumType[i], long + 1); if (error) return "enumType." + error; } } - if (message.service != null && message.hasOwnProperty("service")) { + if (message.service != null && Object.hasOwnProperty.call(message, "service")) { if (!Array.isArray(message.service)) return "service: array expected"; for (var i = 0; i < message.service.length; ++i) { - var error = $root.google.protobuf.ServiceDescriptorProto.verify(message.service[i]); + var error = $root.google.protobuf.ServiceDescriptorProto.verify(message.service[i], long + 1); if (error) return "service." + error; } } - if (message.extension != null && message.hasOwnProperty("extension")) { + if (message.extension != null && Object.hasOwnProperty.call(message, "extension")) { if (!Array.isArray(message.extension)) return "extension: array expected"; for (var i = 0; i < message.extension.length; ++i) { - var error = $root.google.protobuf.FieldDescriptorProto.verify(message.extension[i]); + var error = $root.google.protobuf.FieldDescriptorProto.verify(message.extension[i], long + 1); if (error) return "extension." + error; } } - if (message.options != null && message.hasOwnProperty("options")) { - var error = $root.google.protobuf.FileOptions.verify(message.options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) { + var error = $root.google.protobuf.FileOptions.verify(message.options, long + 1); if (error) return "options." + error; } - if (message.sourceCodeInfo != null && message.hasOwnProperty("sourceCodeInfo")) { - var error = $root.google.protobuf.SourceCodeInfo.verify(message.sourceCodeInfo); + if (message.sourceCodeInfo != null && Object.hasOwnProperty.call(message, "sourceCodeInfo")) { + var error = $root.google.protobuf.SourceCodeInfo.verify(message.sourceCodeInfo, long + 1); if (error) return "sourceCodeInfo." + error; } - if (message.syntax != null && message.hasOwnProperty("syntax")) + if (message.syntax != null && Object.hasOwnProperty.call(message, "syntax")) if (!$util.isString(message.syntax)) return "syntax: string expected"; - if (message.edition != null && message.hasOwnProperty("edition")) + if (message.edition != null && Object.hasOwnProperty.call(message, "edition")) switch (message.edition) { default: return "edition: enum value expected"; @@ -10613,9 +11846,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.FileDescriptorProto} FileDescriptorProto */ - FileDescriptorProto.fromObject = function fromObject(object) { + FileDescriptorProto.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.FileDescriptorProto) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.FileDescriptorProto: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.FileDescriptorProto(); if (object.name != null) message.name = String(object.name); @@ -10647,9 +11886,9 @@ throw TypeError(".google.protobuf.FileDescriptorProto.messageType: array expected"); message.messageType = []; for (var i = 0; i < object.messageType.length; ++i) { - if (typeof object.messageType[i] !== "object") + if (!$util.isObject(object.messageType[i])) throw TypeError(".google.protobuf.FileDescriptorProto.messageType: object expected"); - message.messageType[i] = $root.google.protobuf.DescriptorProto.fromObject(object.messageType[i]); + message.messageType[i] = $root.google.protobuf.DescriptorProto.fromObject(object.messageType[i], long + 1); } } if (object.enumType) { @@ -10657,9 +11896,9 @@ throw TypeError(".google.protobuf.FileDescriptorProto.enumType: array expected"); message.enumType = []; for (var i = 0; i < object.enumType.length; ++i) { - if (typeof object.enumType[i] !== "object") + if (!$util.isObject(object.enumType[i])) throw TypeError(".google.protobuf.FileDescriptorProto.enumType: object expected"); - message.enumType[i] = $root.google.protobuf.EnumDescriptorProto.fromObject(object.enumType[i]); + message.enumType[i] = $root.google.protobuf.EnumDescriptorProto.fromObject(object.enumType[i], long + 1); } } if (object.service) { @@ -10667,9 +11906,9 @@ throw TypeError(".google.protobuf.FileDescriptorProto.service: array expected"); message.service = []; for (var i = 0; i < object.service.length; ++i) { - if (typeof object.service[i] !== "object") + if (!$util.isObject(object.service[i])) throw TypeError(".google.protobuf.FileDescriptorProto.service: object expected"); - message.service[i] = $root.google.protobuf.ServiceDescriptorProto.fromObject(object.service[i]); + message.service[i] = $root.google.protobuf.ServiceDescriptorProto.fromObject(object.service[i], long + 1); } } if (object.extension) { @@ -10677,20 +11916,20 @@ throw TypeError(".google.protobuf.FileDescriptorProto.extension: array expected"); message.extension = []; for (var i = 0; i < object.extension.length; ++i) { - if (typeof object.extension[i] !== "object") + if (!$util.isObject(object.extension[i])) throw TypeError(".google.protobuf.FileDescriptorProto.extension: object expected"); - message.extension[i] = $root.google.protobuf.FieldDescriptorProto.fromObject(object.extension[i]); + message.extension[i] = $root.google.protobuf.FieldDescriptorProto.fromObject(object.extension[i], long + 1); } } if (object.options != null) { - if (typeof object.options !== "object") + if (!$util.isObject(object.options)) throw TypeError(".google.protobuf.FileDescriptorProto.options: object expected"); - message.options = $root.google.protobuf.FileOptions.fromObject(object.options); + message.options = $root.google.protobuf.FileOptions.fromObject(object.options, long + 1); } if (object.sourceCodeInfo != null) { - if (typeof object.sourceCodeInfo !== "object") + if (!$util.isObject(object.sourceCodeInfo)) throw TypeError(".google.protobuf.FileDescriptorProto.sourceCodeInfo: object expected"); - message.sourceCodeInfo = $root.google.protobuf.SourceCodeInfo.fromObject(object.sourceCodeInfo); + message.sourceCodeInfo = $root.google.protobuf.SourceCodeInfo.fromObject(object.sourceCodeInfo, long + 1); } if (object.syntax != null) message.syntax = String(object.syntax); @@ -10758,9 +11997,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - FileDescriptorProto.toObject = function toObject(message, options) { + FileDescriptorProto.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.dependency = []; @@ -10779,9 +12022,9 @@ object.syntax = ""; object.edition = options.enums === String ? "EDITION_UNKNOWN" : 0; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; - if (message["package"] != null && message.hasOwnProperty("package")) + if (message["package"] != null && Object.hasOwnProperty.call(message, "package")) object["package"] = message["package"]; if (message.dependency && message.dependency.length) { object.dependency = []; @@ -10791,27 +12034,27 @@ if (message.messageType && message.messageType.length) { object.messageType = []; for (var j = 0; j < message.messageType.length; ++j) - object.messageType[j] = $root.google.protobuf.DescriptorProto.toObject(message.messageType[j], options); + object.messageType[j] = $root.google.protobuf.DescriptorProto.toObject(message.messageType[j], options, q + 1); } if (message.enumType && message.enumType.length) { object.enumType = []; for (var j = 0; j < message.enumType.length; ++j) - object.enumType[j] = $root.google.protobuf.EnumDescriptorProto.toObject(message.enumType[j], options); + object.enumType[j] = $root.google.protobuf.EnumDescriptorProto.toObject(message.enumType[j], options, q + 1); } if (message.service && message.service.length) { object.service = []; for (var j = 0; j < message.service.length; ++j) - object.service[j] = $root.google.protobuf.ServiceDescriptorProto.toObject(message.service[j], options); + object.service[j] = $root.google.protobuf.ServiceDescriptorProto.toObject(message.service[j], options, q + 1); } if (message.extension && message.extension.length) { object.extension = []; for (var j = 0; j < message.extension.length; ++j) - object.extension[j] = $root.google.protobuf.FieldDescriptorProto.toObject(message.extension[j], options); + object.extension[j] = $root.google.protobuf.FieldDescriptorProto.toObject(message.extension[j], options, q + 1); } - if (message.options != null && message.hasOwnProperty("options")) - object.options = $root.google.protobuf.FileOptions.toObject(message.options, options); - if (message.sourceCodeInfo != null && message.hasOwnProperty("sourceCodeInfo")) - object.sourceCodeInfo = $root.google.protobuf.SourceCodeInfo.toObject(message.sourceCodeInfo, options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) + object.options = $root.google.protobuf.FileOptions.toObject(message.options, options, q + 1); + if (message.sourceCodeInfo != null && Object.hasOwnProperty.call(message, "sourceCodeInfo")) + object.sourceCodeInfo = $root.google.protobuf.SourceCodeInfo.toObject(message.sourceCodeInfo, options, q + 1); if (message.publicDependency && message.publicDependency.length) { object.publicDependency = []; for (var j = 0; j < message.publicDependency.length; ++j) @@ -10822,9 +12065,9 @@ for (var j = 0; j < message.weakDependency.length; ++j) object.weakDependency[j] = message.weakDependency[j]; } - if (message.syntax != null && message.hasOwnProperty("syntax")) + if (message.syntax != null && Object.hasOwnProperty.call(message, "syntax")) object.syntax = message.syntax; - if (message.edition != null && message.hasOwnProperty("edition")) + if (message.edition != null && Object.hasOwnProperty.call(message, "edition")) object.edition = options.enums === String ? $root.google.protobuf.Edition[message.edition] === undefined ? message.edition : $root.google.protobuf.Edition[message.edition] : message.edition; return object; }; @@ -10895,7 +12138,7 @@ this.reservedName = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -11000,34 +12243,38 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - DescriptorProto.encode = function encode(message, writer) { + DescriptorProto.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.field != null && message.field.length) for (var i = 0; i < message.field.length; ++i) - $root.google.protobuf.FieldDescriptorProto.encode(message.field[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.FieldDescriptorProto.encode(message.field[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.nestedType != null && message.nestedType.length) for (var i = 0; i < message.nestedType.length; ++i) - $root.google.protobuf.DescriptorProto.encode(message.nestedType[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.protobuf.DescriptorProto.encode(message.nestedType[i], writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); if (message.enumType != null && message.enumType.length) for (var i = 0; i < message.enumType.length; ++i) - $root.google.protobuf.EnumDescriptorProto.encode(message.enumType[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.google.protobuf.EnumDescriptorProto.encode(message.enumType[i], writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); if (message.extensionRange != null && message.extensionRange.length) for (var i = 0; i < message.extensionRange.length; ++i) - $root.google.protobuf.DescriptorProto.ExtensionRange.encode(message.extensionRange[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); + $root.google.protobuf.DescriptorProto.ExtensionRange.encode(message.extensionRange[i], writer.uint32(/* id 5, wireType 2 =*/42).fork(), q + 1).ldelim(); if (message.extension != null && message.extension.length) for (var i = 0; i < message.extension.length; ++i) - $root.google.protobuf.FieldDescriptorProto.encode(message.extension[i], writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim(); + $root.google.protobuf.FieldDescriptorProto.encode(message.extension[i], writer.uint32(/* id 6, wireType 2 =*/50).fork(), q + 1).ldelim(); if (message.options != null && Object.hasOwnProperty.call(message, "options")) - $root.google.protobuf.MessageOptions.encode(message.options, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim(); + $root.google.protobuf.MessageOptions.encode(message.options, writer.uint32(/* id 7, wireType 2 =*/58).fork(), q + 1).ldelim(); if (message.oneofDecl != null && message.oneofDecl.length) for (var i = 0; i < message.oneofDecl.length; ++i) - $root.google.protobuf.OneofDescriptorProto.encode(message.oneofDecl[i], writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim(); + $root.google.protobuf.OneofDescriptorProto.encode(message.oneofDecl[i], writer.uint32(/* id 8, wireType 2 =*/66).fork(), q + 1).ldelim(); if (message.reservedRange != null && message.reservedRange.length) for (var i = 0; i < message.reservedRange.length; ++i) - $root.google.protobuf.DescriptorProto.ReservedRange.encode(message.reservedRange[i], writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim(); + $root.google.protobuf.DescriptorProto.ReservedRange.encode(message.reservedRange[i], writer.uint32(/* id 9, wireType 2 =*/74).fork(), q + 1).ldelim(); if (message.reservedName != null && message.reservedName.length) for (var i = 0; i < message.reservedName.length; ++i) writer.uint32(/* id 10, wireType 2 =*/82).string(message.reservedName[i]); @@ -11058,12 +12305,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - DescriptorProto.decode = function decode(reader, length) { + DescriptorProto.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.DescriptorProto(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); @@ -11072,47 +12325,47 @@ case 2: { if (!(message.field && message.field.length)) message.field = []; - message.field.push($root.google.protobuf.FieldDescriptorProto.decode(reader, reader.uint32())); + message.field.push($root.google.protobuf.FieldDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 6: { if (!(message.extension && message.extension.length)) message.extension = []; - message.extension.push($root.google.protobuf.FieldDescriptorProto.decode(reader, reader.uint32())); + message.extension.push($root.google.protobuf.FieldDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 3: { if (!(message.nestedType && message.nestedType.length)) message.nestedType = []; - message.nestedType.push($root.google.protobuf.DescriptorProto.decode(reader, reader.uint32())); + message.nestedType.push($root.google.protobuf.DescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 4: { if (!(message.enumType && message.enumType.length)) message.enumType = []; - message.enumType.push($root.google.protobuf.EnumDescriptorProto.decode(reader, reader.uint32())); + message.enumType.push($root.google.protobuf.EnumDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 5: { if (!(message.extensionRange && message.extensionRange.length)) message.extensionRange = []; - message.extensionRange.push($root.google.protobuf.DescriptorProto.ExtensionRange.decode(reader, reader.uint32())); + message.extensionRange.push($root.google.protobuf.DescriptorProto.ExtensionRange.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 8: { if (!(message.oneofDecl && message.oneofDecl.length)) message.oneofDecl = []; - message.oneofDecl.push($root.google.protobuf.OneofDescriptorProto.decode(reader, reader.uint32())); + message.oneofDecl.push($root.google.protobuf.OneofDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 7: { - message.options = $root.google.protobuf.MessageOptions.decode(reader, reader.uint32()); + message.options = $root.google.protobuf.MessageOptions.decode(reader, reader.uint32(), undefined, long + 1); break; } case 9: { if (!(message.reservedRange && message.reservedRange.length)) message.reservedRange = []; - message.reservedRange.push($root.google.protobuf.DescriptorProto.ReservedRange.decode(reader, reader.uint32())); + message.reservedRange.push($root.google.protobuf.DescriptorProto.ReservedRange.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 10: { @@ -11122,7 +12375,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -11153,81 +12406,85 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - DescriptorProto.verify = function verify(message) { + DescriptorProto.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.field != null && message.hasOwnProperty("field")) { + if (message.field != null && Object.hasOwnProperty.call(message, "field")) { if (!Array.isArray(message.field)) return "field: array expected"; for (var i = 0; i < message.field.length; ++i) { - var error = $root.google.protobuf.FieldDescriptorProto.verify(message.field[i]); + var error = $root.google.protobuf.FieldDescriptorProto.verify(message.field[i], long + 1); if (error) return "field." + error; } } - if (message.extension != null && message.hasOwnProperty("extension")) { + if (message.extension != null && Object.hasOwnProperty.call(message, "extension")) { if (!Array.isArray(message.extension)) return "extension: array expected"; for (var i = 0; i < message.extension.length; ++i) { - var error = $root.google.protobuf.FieldDescriptorProto.verify(message.extension[i]); + var error = $root.google.protobuf.FieldDescriptorProto.verify(message.extension[i], long + 1); if (error) return "extension." + error; } } - if (message.nestedType != null && message.hasOwnProperty("nestedType")) { + if (message.nestedType != null && Object.hasOwnProperty.call(message, "nestedType")) { if (!Array.isArray(message.nestedType)) return "nestedType: array expected"; for (var i = 0; i < message.nestedType.length; ++i) { - var error = $root.google.protobuf.DescriptorProto.verify(message.nestedType[i]); + var error = $root.google.protobuf.DescriptorProto.verify(message.nestedType[i], long + 1); if (error) return "nestedType." + error; } } - if (message.enumType != null && message.hasOwnProperty("enumType")) { + if (message.enumType != null && Object.hasOwnProperty.call(message, "enumType")) { if (!Array.isArray(message.enumType)) return "enumType: array expected"; for (var i = 0; i < message.enumType.length; ++i) { - var error = $root.google.protobuf.EnumDescriptorProto.verify(message.enumType[i]); + var error = $root.google.protobuf.EnumDescriptorProto.verify(message.enumType[i], long + 1); if (error) return "enumType." + error; } } - if (message.extensionRange != null && message.hasOwnProperty("extensionRange")) { + if (message.extensionRange != null && Object.hasOwnProperty.call(message, "extensionRange")) { if (!Array.isArray(message.extensionRange)) return "extensionRange: array expected"; for (var i = 0; i < message.extensionRange.length; ++i) { - var error = $root.google.protobuf.DescriptorProto.ExtensionRange.verify(message.extensionRange[i]); + var error = $root.google.protobuf.DescriptorProto.ExtensionRange.verify(message.extensionRange[i], long + 1); if (error) return "extensionRange." + error; } } - if (message.oneofDecl != null && message.hasOwnProperty("oneofDecl")) { + if (message.oneofDecl != null && Object.hasOwnProperty.call(message, "oneofDecl")) { if (!Array.isArray(message.oneofDecl)) return "oneofDecl: array expected"; for (var i = 0; i < message.oneofDecl.length; ++i) { - var error = $root.google.protobuf.OneofDescriptorProto.verify(message.oneofDecl[i]); + var error = $root.google.protobuf.OneofDescriptorProto.verify(message.oneofDecl[i], long + 1); if (error) return "oneofDecl." + error; } } - if (message.options != null && message.hasOwnProperty("options")) { - var error = $root.google.protobuf.MessageOptions.verify(message.options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) { + var error = $root.google.protobuf.MessageOptions.verify(message.options, long + 1); if (error) return "options." + error; } - if (message.reservedRange != null && message.hasOwnProperty("reservedRange")) { + if (message.reservedRange != null && Object.hasOwnProperty.call(message, "reservedRange")) { if (!Array.isArray(message.reservedRange)) return "reservedRange: array expected"; for (var i = 0; i < message.reservedRange.length; ++i) { - var error = $root.google.protobuf.DescriptorProto.ReservedRange.verify(message.reservedRange[i]); + var error = $root.google.protobuf.DescriptorProto.ReservedRange.verify(message.reservedRange[i], long + 1); if (error) return "reservedRange." + error; } } - if (message.reservedName != null && message.hasOwnProperty("reservedName")) { + if (message.reservedName != null && Object.hasOwnProperty.call(message, "reservedName")) { if (!Array.isArray(message.reservedName)) return "reservedName: array expected"; for (var i = 0; i < message.reservedName.length; ++i) @@ -11245,9 +12502,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.DescriptorProto} DescriptorProto */ - DescriptorProto.fromObject = function fromObject(object) { + DescriptorProto.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.DescriptorProto) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.DescriptorProto: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.DescriptorProto(); if (object.name != null) message.name = String(object.name); @@ -11256,9 +12519,9 @@ throw TypeError(".google.protobuf.DescriptorProto.field: array expected"); message.field = []; for (var i = 0; i < object.field.length; ++i) { - if (typeof object.field[i] !== "object") + if (!$util.isObject(object.field[i])) throw TypeError(".google.protobuf.DescriptorProto.field: object expected"); - message.field[i] = $root.google.protobuf.FieldDescriptorProto.fromObject(object.field[i]); + message.field[i] = $root.google.protobuf.FieldDescriptorProto.fromObject(object.field[i], long + 1); } } if (object.extension) { @@ -11266,9 +12529,9 @@ throw TypeError(".google.protobuf.DescriptorProto.extension: array expected"); message.extension = []; for (var i = 0; i < object.extension.length; ++i) { - if (typeof object.extension[i] !== "object") + if (!$util.isObject(object.extension[i])) throw TypeError(".google.protobuf.DescriptorProto.extension: object expected"); - message.extension[i] = $root.google.protobuf.FieldDescriptorProto.fromObject(object.extension[i]); + message.extension[i] = $root.google.protobuf.FieldDescriptorProto.fromObject(object.extension[i], long + 1); } } if (object.nestedType) { @@ -11276,9 +12539,9 @@ throw TypeError(".google.protobuf.DescriptorProto.nestedType: array expected"); message.nestedType = []; for (var i = 0; i < object.nestedType.length; ++i) { - if (typeof object.nestedType[i] !== "object") + if (!$util.isObject(object.nestedType[i])) throw TypeError(".google.protobuf.DescriptorProto.nestedType: object expected"); - message.nestedType[i] = $root.google.protobuf.DescriptorProto.fromObject(object.nestedType[i]); + message.nestedType[i] = $root.google.protobuf.DescriptorProto.fromObject(object.nestedType[i], long + 1); } } if (object.enumType) { @@ -11286,9 +12549,9 @@ throw TypeError(".google.protobuf.DescriptorProto.enumType: array expected"); message.enumType = []; for (var i = 0; i < object.enumType.length; ++i) { - if (typeof object.enumType[i] !== "object") + if (!$util.isObject(object.enumType[i])) throw TypeError(".google.protobuf.DescriptorProto.enumType: object expected"); - message.enumType[i] = $root.google.protobuf.EnumDescriptorProto.fromObject(object.enumType[i]); + message.enumType[i] = $root.google.protobuf.EnumDescriptorProto.fromObject(object.enumType[i], long + 1); } } if (object.extensionRange) { @@ -11296,9 +12559,9 @@ throw TypeError(".google.protobuf.DescriptorProto.extensionRange: array expected"); message.extensionRange = []; for (var i = 0; i < object.extensionRange.length; ++i) { - if (typeof object.extensionRange[i] !== "object") + if (!$util.isObject(object.extensionRange[i])) throw TypeError(".google.protobuf.DescriptorProto.extensionRange: object expected"); - message.extensionRange[i] = $root.google.protobuf.DescriptorProto.ExtensionRange.fromObject(object.extensionRange[i]); + message.extensionRange[i] = $root.google.protobuf.DescriptorProto.ExtensionRange.fromObject(object.extensionRange[i], long + 1); } } if (object.oneofDecl) { @@ -11306,24 +12569,24 @@ throw TypeError(".google.protobuf.DescriptorProto.oneofDecl: array expected"); message.oneofDecl = []; for (var i = 0; i < object.oneofDecl.length; ++i) { - if (typeof object.oneofDecl[i] !== "object") + if (!$util.isObject(object.oneofDecl[i])) throw TypeError(".google.protobuf.DescriptorProto.oneofDecl: object expected"); - message.oneofDecl[i] = $root.google.protobuf.OneofDescriptorProto.fromObject(object.oneofDecl[i]); + message.oneofDecl[i] = $root.google.protobuf.OneofDescriptorProto.fromObject(object.oneofDecl[i], long + 1); } } if (object.options != null) { - if (typeof object.options !== "object") + if (!$util.isObject(object.options)) throw TypeError(".google.protobuf.DescriptorProto.options: object expected"); - message.options = $root.google.protobuf.MessageOptions.fromObject(object.options); + message.options = $root.google.protobuf.MessageOptions.fromObject(object.options, long + 1); } if (object.reservedRange) { if (!Array.isArray(object.reservedRange)) throw TypeError(".google.protobuf.DescriptorProto.reservedRange: array expected"); message.reservedRange = []; for (var i = 0; i < object.reservedRange.length; ++i) { - if (typeof object.reservedRange[i] !== "object") + if (!$util.isObject(object.reservedRange[i])) throw TypeError(".google.protobuf.DescriptorProto.reservedRange: object expected"); - message.reservedRange[i] = $root.google.protobuf.DescriptorProto.ReservedRange.fromObject(object.reservedRange[i]); + message.reservedRange[i] = $root.google.protobuf.DescriptorProto.ReservedRange.fromObject(object.reservedRange[i], long + 1); } } if (object.reservedName) { @@ -11345,9 +12608,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - DescriptorProto.toObject = function toObject(message, options) { + DescriptorProto.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.field = []; @@ -11363,44 +12630,44 @@ object.name = ""; object.options = null; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; if (message.field && message.field.length) { object.field = []; for (var j = 0; j < message.field.length; ++j) - object.field[j] = $root.google.protobuf.FieldDescriptorProto.toObject(message.field[j], options); + object.field[j] = $root.google.protobuf.FieldDescriptorProto.toObject(message.field[j], options, q + 1); } if (message.nestedType && message.nestedType.length) { object.nestedType = []; for (var j = 0; j < message.nestedType.length; ++j) - object.nestedType[j] = $root.google.protobuf.DescriptorProto.toObject(message.nestedType[j], options); + object.nestedType[j] = $root.google.protobuf.DescriptorProto.toObject(message.nestedType[j], options, q + 1); } if (message.enumType && message.enumType.length) { object.enumType = []; for (var j = 0; j < message.enumType.length; ++j) - object.enumType[j] = $root.google.protobuf.EnumDescriptorProto.toObject(message.enumType[j], options); + object.enumType[j] = $root.google.protobuf.EnumDescriptorProto.toObject(message.enumType[j], options, q + 1); } if (message.extensionRange && message.extensionRange.length) { object.extensionRange = []; for (var j = 0; j < message.extensionRange.length; ++j) - object.extensionRange[j] = $root.google.protobuf.DescriptorProto.ExtensionRange.toObject(message.extensionRange[j], options); + object.extensionRange[j] = $root.google.protobuf.DescriptorProto.ExtensionRange.toObject(message.extensionRange[j], options, q + 1); } if (message.extension && message.extension.length) { object.extension = []; for (var j = 0; j < message.extension.length; ++j) - object.extension[j] = $root.google.protobuf.FieldDescriptorProto.toObject(message.extension[j], options); + object.extension[j] = $root.google.protobuf.FieldDescriptorProto.toObject(message.extension[j], options, q + 1); } - if (message.options != null && message.hasOwnProperty("options")) - object.options = $root.google.protobuf.MessageOptions.toObject(message.options, options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) + object.options = $root.google.protobuf.MessageOptions.toObject(message.options, options, q + 1); if (message.oneofDecl && message.oneofDecl.length) { object.oneofDecl = []; for (var j = 0; j < message.oneofDecl.length; ++j) - object.oneofDecl[j] = $root.google.protobuf.OneofDescriptorProto.toObject(message.oneofDecl[j], options); + object.oneofDecl[j] = $root.google.protobuf.OneofDescriptorProto.toObject(message.oneofDecl[j], options, q + 1); } if (message.reservedRange && message.reservedRange.length) { object.reservedRange = []; for (var j = 0; j < message.reservedRange.length; ++j) - object.reservedRange[j] = $root.google.protobuf.DescriptorProto.ReservedRange.toObject(message.reservedRange[j], options); + object.reservedRange[j] = $root.google.protobuf.DescriptorProto.ReservedRange.toObject(message.reservedRange[j], options, q + 1); } if (message.reservedName && message.reservedName.length) { object.reservedName = []; @@ -11458,7 +12725,7 @@ function ExtensionRange(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -11507,15 +12774,19 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ExtensionRange.encode = function encode(message, writer) { + ExtensionRange.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.start != null && Object.hasOwnProperty.call(message, "start")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.start); if (message.end != null && Object.hasOwnProperty.call(message, "end")) writer.uint32(/* id 2, wireType 0 =*/16).int32(message.end); if (message.options != null && Object.hasOwnProperty.call(message, "options")) - $root.google.protobuf.ExtensionRangeOptions.encode(message.options, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.protobuf.ExtensionRangeOptions.encode(message.options, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); return writer; }; @@ -11543,12 +12814,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ExtensionRange.decode = function decode(reader, length) { + ExtensionRange.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.DescriptorProto.ExtensionRange(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.start = reader.int32(); @@ -11559,11 +12836,11 @@ break; } case 3: { - message.options = $root.google.protobuf.ExtensionRangeOptions.decode(reader, reader.uint32()); + message.options = $root.google.protobuf.ExtensionRangeOptions.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -11594,17 +12871,21 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ExtensionRange.verify = function verify(message) { + ExtensionRange.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.start != null && message.hasOwnProperty("start")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.start != null && Object.hasOwnProperty.call(message, "start")) if (!$util.isInteger(message.start)) return "start: integer expected"; - if (message.end != null && message.hasOwnProperty("end")) + if (message.end != null && Object.hasOwnProperty.call(message, "end")) if (!$util.isInteger(message.end)) return "end: integer expected"; - if (message.options != null && message.hasOwnProperty("options")) { - var error = $root.google.protobuf.ExtensionRangeOptions.verify(message.options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) { + var error = $root.google.protobuf.ExtensionRangeOptions.verify(message.options, long + 1); if (error) return "options." + error; } @@ -11619,18 +12900,24 @@ * @param {Object.} object Plain object * @returns {google.protobuf.DescriptorProto.ExtensionRange} ExtensionRange */ - ExtensionRange.fromObject = function fromObject(object) { + ExtensionRange.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.DescriptorProto.ExtensionRange) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.DescriptorProto.ExtensionRange: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.DescriptorProto.ExtensionRange(); if (object.start != null) message.start = object.start | 0; if (object.end != null) message.end = object.end | 0; if (object.options != null) { - if (typeof object.options !== "object") + if (!$util.isObject(object.options)) throw TypeError(".google.protobuf.DescriptorProto.ExtensionRange.options: object expected"); - message.options = $root.google.protobuf.ExtensionRangeOptions.fromObject(object.options); + message.options = $root.google.protobuf.ExtensionRangeOptions.fromObject(object.options, long + 1); } return message; }; @@ -11644,21 +12931,25 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ExtensionRange.toObject = function toObject(message, options) { + ExtensionRange.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.start = 0; object.end = 0; object.options = null; } - if (message.start != null && message.hasOwnProperty("start")) + if (message.start != null && Object.hasOwnProperty.call(message, "start")) object.start = message.start; - if (message.end != null && message.hasOwnProperty("end")) + if (message.end != null && Object.hasOwnProperty.call(message, "end")) object.end = message.end; - if (message.options != null && message.hasOwnProperty("options")) - object.options = $root.google.protobuf.ExtensionRangeOptions.toObject(message.options, options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) + object.options = $root.google.protobuf.ExtensionRangeOptions.toObject(message.options, options, q + 1); return object; }; @@ -11712,7 +13003,7 @@ function ReservedRange(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -11753,9 +13044,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ReservedRange.encode = function encode(message, writer) { + ReservedRange.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.start != null && Object.hasOwnProperty.call(message, "start")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.start); if (message.end != null && Object.hasOwnProperty.call(message, "end")) @@ -11787,12 +13082,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ReservedRange.decode = function decode(reader, length) { + ReservedRange.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.DescriptorProto.ReservedRange(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.start = reader.int32(); @@ -11803,7 +13104,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -11834,13 +13135,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ReservedRange.verify = function verify(message) { + ReservedRange.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.start != null && message.hasOwnProperty("start")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.start != null && Object.hasOwnProperty.call(message, "start")) if (!$util.isInteger(message.start)) return "start: integer expected"; - if (message.end != null && message.hasOwnProperty("end")) + if (message.end != null && Object.hasOwnProperty.call(message, "end")) if (!$util.isInteger(message.end)) return "end: integer expected"; return null; @@ -11854,9 +13159,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.DescriptorProto.ReservedRange} ReservedRange */ - ReservedRange.fromObject = function fromObject(object) { + ReservedRange.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.DescriptorProto.ReservedRange) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.DescriptorProto.ReservedRange: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.DescriptorProto.ReservedRange(); if (object.start != null) message.start = object.start | 0; @@ -11874,17 +13185,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ReservedRange.toObject = function toObject(message, options) { + ReservedRange.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.start = 0; object.end = 0; } - if (message.start != null && message.hasOwnProperty("start")) + if (message.start != null && Object.hasOwnProperty.call(message, "start")) object.start = message.start; - if (message.end != null && message.hasOwnProperty("end")) + if (message.end != null && Object.hasOwnProperty.call(message, "end")) object.end = message.end; return object; }; @@ -11946,7 +13261,7 @@ this.declaration = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -12003,19 +13318,23 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ExtensionRangeOptions.encode = function encode(message, writer) { + ExtensionRangeOptions.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.declaration != null && message.declaration.length) for (var i = 0; i < message.declaration.length; ++i) - $root.google.protobuf.ExtensionRangeOptions.Declaration.encode(message.declaration[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.ExtensionRangeOptions.Declaration.encode(message.declaration[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.verification != null && Object.hasOwnProperty.call(message, "verification")) writer.uint32(/* id 3, wireType 0 =*/24).int32(message.verification); if (message.features != null && Object.hasOwnProperty.call(message, "features")) - $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 50, wireType 2 =*/402).fork()).ldelim(); + $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 50, wireType 2 =*/402).fork(), q + 1).ldelim(); if (message.uninterpretedOption != null && message.uninterpretedOption.length) for (var i = 0; i < message.uninterpretedOption.length; ++i) - $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork()).ldelim(); + $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork(), q + 1).ldelim(); return writer; }; @@ -12043,27 +13362,33 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ExtensionRangeOptions.decode = function decode(reader, length) { + ExtensionRangeOptions.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.ExtensionRangeOptions(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 999: { if (!(message.uninterpretedOption && message.uninterpretedOption.length)) message.uninterpretedOption = []; - message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32())); + message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 2: { if (!(message.declaration && message.declaration.length)) message.declaration = []; - message.declaration.push($root.google.protobuf.ExtensionRangeOptions.Declaration.decode(reader, reader.uint32())); + message.declaration.push($root.google.protobuf.ExtensionRangeOptions.Declaration.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 50: { - message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32()); + message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32(), undefined, long + 1); break; } case 3: { @@ -12071,7 +13396,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -12102,33 +13427,37 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ExtensionRangeOptions.verify = function verify(message) { + ExtensionRangeOptions.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.uninterpretedOption != null && message.hasOwnProperty("uninterpretedOption")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.uninterpretedOption != null && Object.hasOwnProperty.call(message, "uninterpretedOption")) { if (!Array.isArray(message.uninterpretedOption)) return "uninterpretedOption: array expected"; for (var i = 0; i < message.uninterpretedOption.length; ++i) { - var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i]); + var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i], long + 1); if (error) return "uninterpretedOption." + error; } } - if (message.declaration != null && message.hasOwnProperty("declaration")) { + if (message.declaration != null && Object.hasOwnProperty.call(message, "declaration")) { if (!Array.isArray(message.declaration)) return "declaration: array expected"; for (var i = 0; i < message.declaration.length; ++i) { - var error = $root.google.protobuf.ExtensionRangeOptions.Declaration.verify(message.declaration[i]); + var error = $root.google.protobuf.ExtensionRangeOptions.Declaration.verify(message.declaration[i], long + 1); if (error) return "declaration." + error; } } - if (message.features != null && message.hasOwnProperty("features")) { - var error = $root.google.protobuf.FeatureSet.verify(message.features); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) { + var error = $root.google.protobuf.FeatureSet.verify(message.features, long + 1); if (error) return "features." + error; } - if (message.verification != null && message.hasOwnProperty("verification")) + if (message.verification != null && Object.hasOwnProperty.call(message, "verification")) switch (message.verification) { default: return "verification: enum value expected"; @@ -12147,18 +13476,24 @@ * @param {Object.} object Plain object * @returns {google.protobuf.ExtensionRangeOptions} ExtensionRangeOptions */ - ExtensionRangeOptions.fromObject = function fromObject(object) { + ExtensionRangeOptions.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.ExtensionRangeOptions) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.ExtensionRangeOptions: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.ExtensionRangeOptions(); if (object.uninterpretedOption) { if (!Array.isArray(object.uninterpretedOption)) throw TypeError(".google.protobuf.ExtensionRangeOptions.uninterpretedOption: array expected"); message.uninterpretedOption = []; for (var i = 0; i < object.uninterpretedOption.length; ++i) { - if (typeof object.uninterpretedOption[i] !== "object") + if (!$util.isObject(object.uninterpretedOption[i])) throw TypeError(".google.protobuf.ExtensionRangeOptions.uninterpretedOption: object expected"); - message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i]); + message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i], long + 1); } } if (object.declaration) { @@ -12166,15 +13501,15 @@ throw TypeError(".google.protobuf.ExtensionRangeOptions.declaration: array expected"); message.declaration = []; for (var i = 0; i < object.declaration.length; ++i) { - if (typeof object.declaration[i] !== "object") + if (!$util.isObject(object.declaration[i])) throw TypeError(".google.protobuf.ExtensionRangeOptions.declaration: object expected"); - message.declaration[i] = $root.google.protobuf.ExtensionRangeOptions.Declaration.fromObject(object.declaration[i]); + message.declaration[i] = $root.google.protobuf.ExtensionRangeOptions.Declaration.fromObject(object.declaration[i], long + 1); } } if (object.features != null) { - if (typeof object.features !== "object") + if (!$util.isObject(object.features)) throw TypeError(".google.protobuf.ExtensionRangeOptions.features: object expected"); - message.features = $root.google.protobuf.FeatureSet.fromObject(object.features); + message.features = $root.google.protobuf.FeatureSet.fromObject(object.features, long + 1); } switch (object.verification) { case "DECLARATION": @@ -12204,9 +13539,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ExtensionRangeOptions.toObject = function toObject(message, options) { + ExtensionRangeOptions.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.declaration = []; @@ -12219,16 +13558,16 @@ if (message.declaration && message.declaration.length) { object.declaration = []; for (var j = 0; j < message.declaration.length; ++j) - object.declaration[j] = $root.google.protobuf.ExtensionRangeOptions.Declaration.toObject(message.declaration[j], options); + object.declaration[j] = $root.google.protobuf.ExtensionRangeOptions.Declaration.toObject(message.declaration[j], options, q + 1); } - if (message.verification != null && message.hasOwnProperty("verification")) + if (message.verification != null && Object.hasOwnProperty.call(message, "verification")) object.verification = options.enums === String ? $root.google.protobuf.ExtensionRangeOptions.VerificationState[message.verification] === undefined ? message.verification : $root.google.protobuf.ExtensionRangeOptions.VerificationState[message.verification] : message.verification; - if (message.features != null && message.hasOwnProperty("features")) - object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) + object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options, q + 1); if (message.uninterpretedOption && message.uninterpretedOption.length) { object.uninterpretedOption = []; for (var j = 0; j < message.uninterpretedOption.length; ++j) - object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options); + object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options, q + 1); } return object; }; @@ -12283,7 +13622,7 @@ function Declaration(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -12348,9 +13687,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Declaration.encode = function encode(message, writer) { + Declaration.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.number != null && Object.hasOwnProperty.call(message, "number")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.number); if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) @@ -12388,12 +13731,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Declaration.decode = function decode(reader, length) { + Declaration.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.ExtensionRangeOptions.Declaration(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.number = reader.int32(); @@ -12416,7 +13765,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -12447,22 +13796,26 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Declaration.verify = function verify(message) { + Declaration.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.number != null && message.hasOwnProperty("number")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.number != null && Object.hasOwnProperty.call(message, "number")) if (!$util.isInteger(message.number)) return "number: integer expected"; - if (message.fullName != null && message.hasOwnProperty("fullName")) + if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) if (!$util.isString(message.fullName)) return "fullName: string expected"; - if (message.type != null && message.hasOwnProperty("type")) + if (message.type != null && Object.hasOwnProperty.call(message, "type")) if (!$util.isString(message.type)) return "type: string expected"; - if (message.reserved != null && message.hasOwnProperty("reserved")) + if (message.reserved != null && Object.hasOwnProperty.call(message, "reserved")) if (typeof message.reserved !== "boolean") return "reserved: boolean expected"; - if (message.repeated != null && message.hasOwnProperty("repeated")) + if (message.repeated != null && Object.hasOwnProperty.call(message, "repeated")) if (typeof message.repeated !== "boolean") return "repeated: boolean expected"; return null; @@ -12476,9 +13829,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.ExtensionRangeOptions.Declaration} Declaration */ - Declaration.fromObject = function fromObject(object) { + Declaration.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.ExtensionRangeOptions.Declaration) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.ExtensionRangeOptions.Declaration: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.ExtensionRangeOptions.Declaration(); if (object.number != null) message.number = object.number | 0; @@ -12502,9 +13861,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Declaration.toObject = function toObject(message, options) { + Declaration.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.number = 0; @@ -12513,15 +13876,15 @@ object.reserved = false; object.repeated = false; } - if (message.number != null && message.hasOwnProperty("number")) + if (message.number != null && Object.hasOwnProperty.call(message, "number")) object.number = message.number; - if (message.fullName != null && message.hasOwnProperty("fullName")) + if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) object.fullName = message.fullName; - if (message.type != null && message.hasOwnProperty("type")) + if (message.type != null && Object.hasOwnProperty.call(message, "type")) object.type = message.type; - if (message.reserved != null && message.hasOwnProperty("reserved")) + if (message.reserved != null && Object.hasOwnProperty.call(message, "reserved")) object.reserved = message.reserved; - if (message.repeated != null && message.hasOwnProperty("repeated")) + if (message.repeated != null && Object.hasOwnProperty.call(message, "repeated")) object.repeated = message.repeated; return object; }; @@ -12602,7 +13965,7 @@ function FieldDescriptorProto(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -12715,9 +14078,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - FieldDescriptorProto.encode = function encode(message, writer) { + FieldDescriptorProto.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.extendee != null && Object.hasOwnProperty.call(message, "extendee")) @@ -12733,7 +14100,7 @@ if (message.defaultValue != null && Object.hasOwnProperty.call(message, "defaultValue")) writer.uint32(/* id 7, wireType 2 =*/58).string(message.defaultValue); if (message.options != null && Object.hasOwnProperty.call(message, "options")) - $root.google.protobuf.FieldOptions.encode(message.options, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim(); + $root.google.protobuf.FieldOptions.encode(message.options, writer.uint32(/* id 8, wireType 2 =*/66).fork(), q + 1).ldelim(); if (message.oneofIndex != null && Object.hasOwnProperty.call(message, "oneofIndex")) writer.uint32(/* id 9, wireType 0 =*/72).int32(message.oneofIndex); if (message.jsonName != null && Object.hasOwnProperty.call(message, "jsonName")) @@ -12767,12 +14134,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - FieldDescriptorProto.decode = function decode(reader, length) { + FieldDescriptorProto.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FieldDescriptorProto(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); @@ -12811,7 +14184,7 @@ break; } case 8: { - message.options = $root.google.protobuf.FieldOptions.decode(reader, reader.uint32()); + message.options = $root.google.protobuf.FieldOptions.decode(reader, reader.uint32(), undefined, long + 1); break; } case 17: { @@ -12819,7 +14192,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -12850,16 +14223,20 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - FieldDescriptorProto.verify = function verify(message) { + FieldDescriptorProto.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.number != null && message.hasOwnProperty("number")) + if (message.number != null && Object.hasOwnProperty.call(message, "number")) if (!$util.isInteger(message.number)) return "number: integer expected"; - if (message.label != null && message.hasOwnProperty("label")) + if (message.label != null && Object.hasOwnProperty.call(message, "label")) switch (message.label) { default: return "label: enum value expected"; @@ -12868,7 +14245,7 @@ case 2: break; } - if (message.type != null && message.hasOwnProperty("type")) + if (message.type != null && Object.hasOwnProperty.call(message, "type")) switch (message.type) { default: return "type: enum value expected"; @@ -12892,27 +14269,27 @@ case 18: break; } - if (message.typeName != null && message.hasOwnProperty("typeName")) + if (message.typeName != null && Object.hasOwnProperty.call(message, "typeName")) if (!$util.isString(message.typeName)) return "typeName: string expected"; - if (message.extendee != null && message.hasOwnProperty("extendee")) + if (message.extendee != null && Object.hasOwnProperty.call(message, "extendee")) if (!$util.isString(message.extendee)) return "extendee: string expected"; - if (message.defaultValue != null && message.hasOwnProperty("defaultValue")) + if (message.defaultValue != null && Object.hasOwnProperty.call(message, "defaultValue")) if (!$util.isString(message.defaultValue)) return "defaultValue: string expected"; - if (message.oneofIndex != null && message.hasOwnProperty("oneofIndex")) + if (message.oneofIndex != null && Object.hasOwnProperty.call(message, "oneofIndex")) if (!$util.isInteger(message.oneofIndex)) return "oneofIndex: integer expected"; - if (message.jsonName != null && message.hasOwnProperty("jsonName")) + if (message.jsonName != null && Object.hasOwnProperty.call(message, "jsonName")) if (!$util.isString(message.jsonName)) return "jsonName: string expected"; - if (message.options != null && message.hasOwnProperty("options")) { - var error = $root.google.protobuf.FieldOptions.verify(message.options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) { + var error = $root.google.protobuf.FieldOptions.verify(message.options, long + 1); if (error) return "options." + error; } - if (message.proto3Optional != null && message.hasOwnProperty("proto3Optional")) + if (message.proto3Optional != null && Object.hasOwnProperty.call(message, "proto3Optional")) if (typeof message.proto3Optional !== "boolean") return "proto3Optional: boolean expected"; return null; @@ -12926,9 +14303,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.FieldDescriptorProto} FieldDescriptorProto */ - FieldDescriptorProto.fromObject = function fromObject(object) { + FieldDescriptorProto.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.FieldDescriptorProto) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.FieldDescriptorProto: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.FieldDescriptorProto(); if (object.name != null) message.name = String(object.name); @@ -13045,9 +14428,9 @@ if (object.jsonName != null) message.jsonName = String(object.jsonName); if (object.options != null) { - if (typeof object.options !== "object") + if (!$util.isObject(object.options)) throw TypeError(".google.protobuf.FieldDescriptorProto.options: object expected"); - message.options = $root.google.protobuf.FieldOptions.fromObject(object.options); + message.options = $root.google.protobuf.FieldOptions.fromObject(object.options, long + 1); } if (object.proto3Optional != null) message.proto3Optional = Boolean(object.proto3Optional); @@ -13063,9 +14446,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - FieldDescriptorProto.toObject = function toObject(message, options) { + FieldDescriptorProto.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.name = ""; @@ -13080,27 +14467,27 @@ object.jsonName = ""; object.proto3Optional = false; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; - if (message.extendee != null && message.hasOwnProperty("extendee")) + if (message.extendee != null && Object.hasOwnProperty.call(message, "extendee")) object.extendee = message.extendee; - if (message.number != null && message.hasOwnProperty("number")) + if (message.number != null && Object.hasOwnProperty.call(message, "number")) object.number = message.number; - if (message.label != null && message.hasOwnProperty("label")) + if (message.label != null && Object.hasOwnProperty.call(message, "label")) object.label = options.enums === String ? $root.google.protobuf.FieldDescriptorProto.Label[message.label] === undefined ? message.label : $root.google.protobuf.FieldDescriptorProto.Label[message.label] : message.label; - if (message.type != null && message.hasOwnProperty("type")) + if (message.type != null && Object.hasOwnProperty.call(message, "type")) object.type = options.enums === String ? $root.google.protobuf.FieldDescriptorProto.Type[message.type] === undefined ? message.type : $root.google.protobuf.FieldDescriptorProto.Type[message.type] : message.type; - if (message.typeName != null && message.hasOwnProperty("typeName")) + if (message.typeName != null && Object.hasOwnProperty.call(message, "typeName")) object.typeName = message.typeName; - if (message.defaultValue != null && message.hasOwnProperty("defaultValue")) + if (message.defaultValue != null && Object.hasOwnProperty.call(message, "defaultValue")) object.defaultValue = message.defaultValue; - if (message.options != null && message.hasOwnProperty("options")) - object.options = $root.google.protobuf.FieldOptions.toObject(message.options, options); - if (message.oneofIndex != null && message.hasOwnProperty("oneofIndex")) + if (message.options != null && Object.hasOwnProperty.call(message, "options")) + object.options = $root.google.protobuf.FieldOptions.toObject(message.options, options, q + 1); + if (message.oneofIndex != null && Object.hasOwnProperty.call(message, "oneofIndex")) object.oneofIndex = message.oneofIndex; - if (message.jsonName != null && message.hasOwnProperty("jsonName")) + if (message.jsonName != null && Object.hasOwnProperty.call(message, "jsonName")) object.jsonName = message.jsonName; - if (message.proto3Optional != null && message.hasOwnProperty("proto3Optional")) + if (message.proto3Optional != null && Object.hasOwnProperty.call(message, "proto3Optional")) object.proto3Optional = message.proto3Optional; return object; }; @@ -13217,7 +14604,7 @@ function OneofDescriptorProto(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -13258,13 +14645,17 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - OneofDescriptorProto.encode = function encode(message, writer) { + OneofDescriptorProto.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.options != null && Object.hasOwnProperty.call(message, "options")) - $root.google.protobuf.OneofOptions.encode(message.options, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.OneofOptions.encode(message.options, writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); return writer; }; @@ -13292,23 +14683,29 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - OneofDescriptorProto.decode = function decode(reader, length) { + OneofDescriptorProto.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.OneofDescriptorProto(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); break; } case 2: { - message.options = $root.google.protobuf.OneofOptions.decode(reader, reader.uint32()); + message.options = $root.google.protobuf.OneofOptions.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -13339,14 +14736,18 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - OneofDescriptorProto.verify = function verify(message) { + OneofDescriptorProto.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.options != null && message.hasOwnProperty("options")) { - var error = $root.google.protobuf.OneofOptions.verify(message.options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) { + var error = $root.google.protobuf.OneofOptions.verify(message.options, long + 1); if (error) return "options." + error; } @@ -13361,16 +14762,22 @@ * @param {Object.} object Plain object * @returns {google.protobuf.OneofDescriptorProto} OneofDescriptorProto */ - OneofDescriptorProto.fromObject = function fromObject(object) { + OneofDescriptorProto.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.OneofDescriptorProto) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.OneofDescriptorProto: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.OneofDescriptorProto(); if (object.name != null) message.name = String(object.name); if (object.options != null) { - if (typeof object.options !== "object") + if (!$util.isObject(object.options)) throw TypeError(".google.protobuf.OneofDescriptorProto.options: object expected"); - message.options = $root.google.protobuf.OneofOptions.fromObject(object.options); + message.options = $root.google.protobuf.OneofOptions.fromObject(object.options, long + 1); } return message; }; @@ -13384,18 +14791,22 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - OneofDescriptorProto.toObject = function toObject(message, options) { + OneofDescriptorProto.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.name = ""; object.options = null; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; - if (message.options != null && message.hasOwnProperty("options")) - object.options = $root.google.protobuf.OneofOptions.toObject(message.options, options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) + object.options = $root.google.protobuf.OneofOptions.toObject(message.options, options, q + 1); return object; }; @@ -13455,7 +14866,7 @@ this.reservedName = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -13520,19 +14931,23 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - EnumDescriptorProto.encode = function encode(message, writer) { + EnumDescriptorProto.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.value != null && message.value.length) for (var i = 0; i < message.value.length; ++i) - $root.google.protobuf.EnumValueDescriptorProto.encode(message.value[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.EnumValueDescriptorProto.encode(message.value[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.options != null && Object.hasOwnProperty.call(message, "options")) - $root.google.protobuf.EnumOptions.encode(message.options, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.protobuf.EnumOptions.encode(message.options, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); if (message.reservedRange != null && message.reservedRange.length) for (var i = 0; i < message.reservedRange.length; ++i) - $root.google.protobuf.EnumDescriptorProto.EnumReservedRange.encode(message.reservedRange[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.google.protobuf.EnumDescriptorProto.EnumReservedRange.encode(message.reservedRange[i], writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); if (message.reservedName != null && message.reservedName.length) for (var i = 0; i < message.reservedName.length; ++i) writer.uint32(/* id 5, wireType 2 =*/42).string(message.reservedName[i]); @@ -13563,12 +14978,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - EnumDescriptorProto.decode = function decode(reader, length) { + EnumDescriptorProto.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.EnumDescriptorProto(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); @@ -13577,17 +14998,17 @@ case 2: { if (!(message.value && message.value.length)) message.value = []; - message.value.push($root.google.protobuf.EnumValueDescriptorProto.decode(reader, reader.uint32())); + message.value.push($root.google.protobuf.EnumValueDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 3: { - message.options = $root.google.protobuf.EnumOptions.decode(reader, reader.uint32()); + message.options = $root.google.protobuf.EnumOptions.decode(reader, reader.uint32(), undefined, long + 1); break; } case 4: { if (!(message.reservedRange && message.reservedRange.length)) message.reservedRange = []; - message.reservedRange.push($root.google.protobuf.EnumDescriptorProto.EnumReservedRange.decode(reader, reader.uint32())); + message.reservedRange.push($root.google.protobuf.EnumDescriptorProto.EnumReservedRange.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 5: { @@ -13597,7 +15018,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -13628,36 +15049,40 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - EnumDescriptorProto.verify = function verify(message) { + EnumDescriptorProto.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.value != null && message.hasOwnProperty("value")) { + if (message.value != null && Object.hasOwnProperty.call(message, "value")) { if (!Array.isArray(message.value)) return "value: array expected"; for (var i = 0; i < message.value.length; ++i) { - var error = $root.google.protobuf.EnumValueDescriptorProto.verify(message.value[i]); + var error = $root.google.protobuf.EnumValueDescriptorProto.verify(message.value[i], long + 1); if (error) return "value." + error; } } - if (message.options != null && message.hasOwnProperty("options")) { - var error = $root.google.protobuf.EnumOptions.verify(message.options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) { + var error = $root.google.protobuf.EnumOptions.verify(message.options, long + 1); if (error) return "options." + error; } - if (message.reservedRange != null && message.hasOwnProperty("reservedRange")) { + if (message.reservedRange != null && Object.hasOwnProperty.call(message, "reservedRange")) { if (!Array.isArray(message.reservedRange)) return "reservedRange: array expected"; for (var i = 0; i < message.reservedRange.length; ++i) { - var error = $root.google.protobuf.EnumDescriptorProto.EnumReservedRange.verify(message.reservedRange[i]); + var error = $root.google.protobuf.EnumDescriptorProto.EnumReservedRange.verify(message.reservedRange[i], long + 1); if (error) return "reservedRange." + error; } } - if (message.reservedName != null && message.hasOwnProperty("reservedName")) { + if (message.reservedName != null && Object.hasOwnProperty.call(message, "reservedName")) { if (!Array.isArray(message.reservedName)) return "reservedName: array expected"; for (var i = 0; i < message.reservedName.length; ++i) @@ -13675,9 +15100,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.EnumDescriptorProto} EnumDescriptorProto */ - EnumDescriptorProto.fromObject = function fromObject(object) { + EnumDescriptorProto.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.EnumDescriptorProto) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.EnumDescriptorProto: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.EnumDescriptorProto(); if (object.name != null) message.name = String(object.name); @@ -13686,24 +15117,24 @@ throw TypeError(".google.protobuf.EnumDescriptorProto.value: array expected"); message.value = []; for (var i = 0; i < object.value.length; ++i) { - if (typeof object.value[i] !== "object") + if (!$util.isObject(object.value[i])) throw TypeError(".google.protobuf.EnumDescriptorProto.value: object expected"); - message.value[i] = $root.google.protobuf.EnumValueDescriptorProto.fromObject(object.value[i]); + message.value[i] = $root.google.protobuf.EnumValueDescriptorProto.fromObject(object.value[i], long + 1); } } if (object.options != null) { - if (typeof object.options !== "object") + if (!$util.isObject(object.options)) throw TypeError(".google.protobuf.EnumDescriptorProto.options: object expected"); - message.options = $root.google.protobuf.EnumOptions.fromObject(object.options); + message.options = $root.google.protobuf.EnumOptions.fromObject(object.options, long + 1); } if (object.reservedRange) { if (!Array.isArray(object.reservedRange)) throw TypeError(".google.protobuf.EnumDescriptorProto.reservedRange: array expected"); message.reservedRange = []; for (var i = 0; i < object.reservedRange.length; ++i) { - if (typeof object.reservedRange[i] !== "object") + if (!$util.isObject(object.reservedRange[i])) throw TypeError(".google.protobuf.EnumDescriptorProto.reservedRange: object expected"); - message.reservedRange[i] = $root.google.protobuf.EnumDescriptorProto.EnumReservedRange.fromObject(object.reservedRange[i]); + message.reservedRange[i] = $root.google.protobuf.EnumDescriptorProto.EnumReservedRange.fromObject(object.reservedRange[i], long + 1); } } if (object.reservedName) { @@ -13725,9 +15156,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - EnumDescriptorProto.toObject = function toObject(message, options) { + EnumDescriptorProto.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.value = []; @@ -13738,19 +15173,19 @@ object.name = ""; object.options = null; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; if (message.value && message.value.length) { object.value = []; for (var j = 0; j < message.value.length; ++j) - object.value[j] = $root.google.protobuf.EnumValueDescriptorProto.toObject(message.value[j], options); + object.value[j] = $root.google.protobuf.EnumValueDescriptorProto.toObject(message.value[j], options, q + 1); } - if (message.options != null && message.hasOwnProperty("options")) - object.options = $root.google.protobuf.EnumOptions.toObject(message.options, options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) + object.options = $root.google.protobuf.EnumOptions.toObject(message.options, options, q + 1); if (message.reservedRange && message.reservedRange.length) { object.reservedRange = []; for (var j = 0; j < message.reservedRange.length; ++j) - object.reservedRange[j] = $root.google.protobuf.EnumDescriptorProto.EnumReservedRange.toObject(message.reservedRange[j], options); + object.reservedRange[j] = $root.google.protobuf.EnumDescriptorProto.EnumReservedRange.toObject(message.reservedRange[j], options, q + 1); } if (message.reservedName && message.reservedName.length) { object.reservedName = []; @@ -13807,7 +15242,7 @@ function EnumReservedRange(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -13848,9 +15283,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - EnumReservedRange.encode = function encode(message, writer) { + EnumReservedRange.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.start != null && Object.hasOwnProperty.call(message, "start")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.start); if (message.end != null && Object.hasOwnProperty.call(message, "end")) @@ -13882,12 +15321,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - EnumReservedRange.decode = function decode(reader, length) { + EnumReservedRange.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.EnumDescriptorProto.EnumReservedRange(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.start = reader.int32(); @@ -13898,7 +15343,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -13929,13 +15374,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - EnumReservedRange.verify = function verify(message) { + EnumReservedRange.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.start != null && message.hasOwnProperty("start")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.start != null && Object.hasOwnProperty.call(message, "start")) if (!$util.isInteger(message.start)) return "start: integer expected"; - if (message.end != null && message.hasOwnProperty("end")) + if (message.end != null && Object.hasOwnProperty.call(message, "end")) if (!$util.isInteger(message.end)) return "end: integer expected"; return null; @@ -13949,9 +15398,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.EnumDescriptorProto.EnumReservedRange} EnumReservedRange */ - EnumReservedRange.fromObject = function fromObject(object) { + EnumReservedRange.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.EnumDescriptorProto.EnumReservedRange) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.EnumDescriptorProto.EnumReservedRange: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.EnumDescriptorProto.EnumReservedRange(); if (object.start != null) message.start = object.start | 0; @@ -13969,17 +15424,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - EnumReservedRange.toObject = function toObject(message, options) { + EnumReservedRange.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.start = 0; object.end = 0; } - if (message.start != null && message.hasOwnProperty("start")) + if (message.start != null && Object.hasOwnProperty.call(message, "start")) object.start = message.start; - if (message.end != null && message.hasOwnProperty("end")) + if (message.end != null && Object.hasOwnProperty.call(message, "end")) object.end = message.end; return object; }; @@ -14038,7 +15497,7 @@ function EnumValueDescriptorProto(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -14087,15 +15546,19 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - EnumValueDescriptorProto.encode = function encode(message, writer) { + EnumValueDescriptorProto.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.number != null && Object.hasOwnProperty.call(message, "number")) writer.uint32(/* id 2, wireType 0 =*/16).int32(message.number); if (message.options != null && Object.hasOwnProperty.call(message, "options")) - $root.google.protobuf.EnumValueOptions.encode(message.options, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.protobuf.EnumValueOptions.encode(message.options, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); return writer; }; @@ -14123,12 +15586,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - EnumValueDescriptorProto.decode = function decode(reader, length) { + EnumValueDescriptorProto.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.EnumValueDescriptorProto(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); @@ -14139,11 +15608,11 @@ break; } case 3: { - message.options = $root.google.protobuf.EnumValueOptions.decode(reader, reader.uint32()); + message.options = $root.google.protobuf.EnumValueOptions.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -14174,17 +15643,21 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - EnumValueDescriptorProto.verify = function verify(message) { + EnumValueDescriptorProto.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.number != null && message.hasOwnProperty("number")) + if (message.number != null && Object.hasOwnProperty.call(message, "number")) if (!$util.isInteger(message.number)) return "number: integer expected"; - if (message.options != null && message.hasOwnProperty("options")) { - var error = $root.google.protobuf.EnumValueOptions.verify(message.options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) { + var error = $root.google.protobuf.EnumValueOptions.verify(message.options, long + 1); if (error) return "options." + error; } @@ -14199,18 +15672,24 @@ * @param {Object.} object Plain object * @returns {google.protobuf.EnumValueDescriptorProto} EnumValueDescriptorProto */ - EnumValueDescriptorProto.fromObject = function fromObject(object) { + EnumValueDescriptorProto.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.EnumValueDescriptorProto) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.EnumValueDescriptorProto: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.EnumValueDescriptorProto(); if (object.name != null) message.name = String(object.name); if (object.number != null) message.number = object.number | 0; if (object.options != null) { - if (typeof object.options !== "object") + if (!$util.isObject(object.options)) throw TypeError(".google.protobuf.EnumValueDescriptorProto.options: object expected"); - message.options = $root.google.protobuf.EnumValueOptions.fromObject(object.options); + message.options = $root.google.protobuf.EnumValueOptions.fromObject(object.options, long + 1); } return message; }; @@ -14224,21 +15703,25 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - EnumValueDescriptorProto.toObject = function toObject(message, options) { + EnumValueDescriptorProto.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.name = ""; object.number = 0; object.options = null; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; - if (message.number != null && message.hasOwnProperty("number")) + if (message.number != null && Object.hasOwnProperty.call(message, "number")) object.number = message.number; - if (message.options != null && message.hasOwnProperty("options")) - object.options = $root.google.protobuf.EnumValueOptions.toObject(message.options, options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) + object.options = $root.google.protobuf.EnumValueOptions.toObject(message.options, options, q + 1); return object; }; @@ -14294,7 +15777,7 @@ this.method = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -14343,16 +15826,20 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ServiceDescriptorProto.encode = function encode(message, writer) { + ServiceDescriptorProto.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.method != null && message.method.length) for (var i = 0; i < message.method.length; ++i) - $root.google.protobuf.MethodDescriptorProto.encode(message.method[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.MethodDescriptorProto.encode(message.method[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.options != null && Object.hasOwnProperty.call(message, "options")) - $root.google.protobuf.ServiceOptions.encode(message.options, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.protobuf.ServiceOptions.encode(message.options, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); return writer; }; @@ -14380,12 +15867,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ServiceDescriptorProto.decode = function decode(reader, length) { + ServiceDescriptorProto.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.ServiceDescriptorProto(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); @@ -14394,15 +15887,15 @@ case 2: { if (!(message.method && message.method.length)) message.method = []; - message.method.push($root.google.protobuf.MethodDescriptorProto.decode(reader, reader.uint32())); + message.method.push($root.google.protobuf.MethodDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 3: { - message.options = $root.google.protobuf.ServiceOptions.decode(reader, reader.uint32()); + message.options = $root.google.protobuf.ServiceOptions.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -14433,23 +15926,27 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ServiceDescriptorProto.verify = function verify(message) { + ServiceDescriptorProto.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.method != null && message.hasOwnProperty("method")) { + if (message.method != null && Object.hasOwnProperty.call(message, "method")) { if (!Array.isArray(message.method)) return "method: array expected"; for (var i = 0; i < message.method.length; ++i) { - var error = $root.google.protobuf.MethodDescriptorProto.verify(message.method[i]); + var error = $root.google.protobuf.MethodDescriptorProto.verify(message.method[i], long + 1); if (error) return "method." + error; } } - if (message.options != null && message.hasOwnProperty("options")) { - var error = $root.google.protobuf.ServiceOptions.verify(message.options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) { + var error = $root.google.protobuf.ServiceOptions.verify(message.options, long + 1); if (error) return "options." + error; } @@ -14464,9 +15961,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.ServiceDescriptorProto} ServiceDescriptorProto */ - ServiceDescriptorProto.fromObject = function fromObject(object) { + ServiceDescriptorProto.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.ServiceDescriptorProto) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.ServiceDescriptorProto: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.ServiceDescriptorProto(); if (object.name != null) message.name = String(object.name); @@ -14475,15 +15978,15 @@ throw TypeError(".google.protobuf.ServiceDescriptorProto.method: array expected"); message.method = []; for (var i = 0; i < object.method.length; ++i) { - if (typeof object.method[i] !== "object") + if (!$util.isObject(object.method[i])) throw TypeError(".google.protobuf.ServiceDescriptorProto.method: object expected"); - message.method[i] = $root.google.protobuf.MethodDescriptorProto.fromObject(object.method[i]); + message.method[i] = $root.google.protobuf.MethodDescriptorProto.fromObject(object.method[i], long + 1); } } if (object.options != null) { - if (typeof object.options !== "object") + if (!$util.isObject(object.options)) throw TypeError(".google.protobuf.ServiceDescriptorProto.options: object expected"); - message.options = $root.google.protobuf.ServiceOptions.fromObject(object.options); + message.options = $root.google.protobuf.ServiceOptions.fromObject(object.options, long + 1); } return message; }; @@ -14497,9 +16000,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ServiceDescriptorProto.toObject = function toObject(message, options) { + ServiceDescriptorProto.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.method = []; @@ -14507,15 +16014,15 @@ object.name = ""; object.options = null; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; if (message.method && message.method.length) { object.method = []; for (var j = 0; j < message.method.length; ++j) - object.method[j] = $root.google.protobuf.MethodDescriptorProto.toObject(message.method[j], options); + object.method[j] = $root.google.protobuf.MethodDescriptorProto.toObject(message.method[j], options, q + 1); } - if (message.options != null && message.hasOwnProperty("options")) - object.options = $root.google.protobuf.ServiceOptions.toObject(message.options, options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) + object.options = $root.google.protobuf.ServiceOptions.toObject(message.options, options, q + 1); return object; }; @@ -14573,7 +16080,7 @@ function MethodDescriptorProto(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -14646,9 +16153,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - MethodDescriptorProto.encode = function encode(message, writer) { + MethodDescriptorProto.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.inputType != null && Object.hasOwnProperty.call(message, "inputType")) @@ -14656,7 +16167,7 @@ if (message.outputType != null && Object.hasOwnProperty.call(message, "outputType")) writer.uint32(/* id 3, wireType 2 =*/26).string(message.outputType); if (message.options != null && Object.hasOwnProperty.call(message, "options")) - $root.google.protobuf.MethodOptions.encode(message.options, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.google.protobuf.MethodOptions.encode(message.options, writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); if (message.clientStreaming != null && Object.hasOwnProperty.call(message, "clientStreaming")) writer.uint32(/* id 5, wireType 0 =*/40).bool(message.clientStreaming); if (message.serverStreaming != null && Object.hasOwnProperty.call(message, "serverStreaming")) @@ -14688,12 +16199,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - MethodDescriptorProto.decode = function decode(reader, length) { + MethodDescriptorProto.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.MethodDescriptorProto(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); @@ -14708,7 +16225,7 @@ break; } case 4: { - message.options = $root.google.protobuf.MethodOptions.decode(reader, reader.uint32()); + message.options = $root.google.protobuf.MethodOptions.decode(reader, reader.uint32(), undefined, long + 1); break; } case 5: { @@ -14720,7 +16237,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -14751,27 +16268,31 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - MethodDescriptorProto.verify = function verify(message) { + MethodDescriptorProto.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.inputType != null && message.hasOwnProperty("inputType")) + if (message.inputType != null && Object.hasOwnProperty.call(message, "inputType")) if (!$util.isString(message.inputType)) return "inputType: string expected"; - if (message.outputType != null && message.hasOwnProperty("outputType")) + if (message.outputType != null && Object.hasOwnProperty.call(message, "outputType")) if (!$util.isString(message.outputType)) return "outputType: string expected"; - if (message.options != null && message.hasOwnProperty("options")) { - var error = $root.google.protobuf.MethodOptions.verify(message.options); + if (message.options != null && Object.hasOwnProperty.call(message, "options")) { + var error = $root.google.protobuf.MethodOptions.verify(message.options, long + 1); if (error) return "options." + error; } - if (message.clientStreaming != null && message.hasOwnProperty("clientStreaming")) + if (message.clientStreaming != null && Object.hasOwnProperty.call(message, "clientStreaming")) if (typeof message.clientStreaming !== "boolean") return "clientStreaming: boolean expected"; - if (message.serverStreaming != null && message.hasOwnProperty("serverStreaming")) + if (message.serverStreaming != null && Object.hasOwnProperty.call(message, "serverStreaming")) if (typeof message.serverStreaming !== "boolean") return "serverStreaming: boolean expected"; return null; @@ -14785,9 +16306,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.MethodDescriptorProto} MethodDescriptorProto */ - MethodDescriptorProto.fromObject = function fromObject(object) { + MethodDescriptorProto.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.MethodDescriptorProto) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.MethodDescriptorProto: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.MethodDescriptorProto(); if (object.name != null) message.name = String(object.name); @@ -14796,9 +16323,9 @@ if (object.outputType != null) message.outputType = String(object.outputType); if (object.options != null) { - if (typeof object.options !== "object") + if (!$util.isObject(object.options)) throw TypeError(".google.protobuf.MethodDescriptorProto.options: object expected"); - message.options = $root.google.protobuf.MethodOptions.fromObject(object.options); + message.options = $root.google.protobuf.MethodOptions.fromObject(object.options, long + 1); } if (object.clientStreaming != null) message.clientStreaming = Boolean(object.clientStreaming); @@ -14816,9 +16343,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - MethodDescriptorProto.toObject = function toObject(message, options) { + MethodDescriptorProto.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.name = ""; @@ -14828,17 +16359,17 @@ object.clientStreaming = false; object.serverStreaming = false; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; - if (message.inputType != null && message.hasOwnProperty("inputType")) + if (message.inputType != null && Object.hasOwnProperty.call(message, "inputType")) object.inputType = message.inputType; - if (message.outputType != null && message.hasOwnProperty("outputType")) + if (message.outputType != null && Object.hasOwnProperty.call(message, "outputType")) object.outputType = message.outputType; - if (message.options != null && message.hasOwnProperty("options")) - object.options = $root.google.protobuf.MethodOptions.toObject(message.options, options); - if (message.clientStreaming != null && message.hasOwnProperty("clientStreaming")) + if (message.options != null && Object.hasOwnProperty.call(message, "options")) + object.options = $root.google.protobuf.MethodOptions.toObject(message.options, options, q + 1); + if (message.clientStreaming != null && Object.hasOwnProperty.call(message, "clientStreaming")) object.clientStreaming = message.clientStreaming; - if (message.serverStreaming != null && message.hasOwnProperty("serverStreaming")) + if (message.serverStreaming != null && Object.hasOwnProperty.call(message, "serverStreaming")) object.serverStreaming = message.serverStreaming; return object; }; @@ -14915,7 +16446,7 @@ this[".google.api.resourceDefinition"] = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -15116,9 +16647,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - FileOptions.encode = function encode(message, writer) { + FileOptions.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.javaPackage != null && Object.hasOwnProperty.call(message, "javaPackage")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.javaPackage); if (message.javaOuterClassname != null && Object.hasOwnProperty.call(message, "javaOuterClassname")) @@ -15158,13 +16693,13 @@ if (message.rubyPackage != null && Object.hasOwnProperty.call(message, "rubyPackage")) writer.uint32(/* id 45, wireType 2 =*/362).string(message.rubyPackage); if (message.features != null && Object.hasOwnProperty.call(message, "features")) - $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 50, wireType 2 =*/402).fork()).ldelim(); + $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 50, wireType 2 =*/402).fork(), q + 1).ldelim(); if (message.uninterpretedOption != null && message.uninterpretedOption.length) for (var i = 0; i < message.uninterpretedOption.length; ++i) - $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork()).ldelim(); + $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork(), q + 1).ldelim(); if (message[".google.api.resourceDefinition"] != null && message[".google.api.resourceDefinition"].length) for (var i = 0; i < message[".google.api.resourceDefinition"].length; ++i) - $root.google.api.ResourceDescriptor.encode(message[".google.api.resourceDefinition"][i], writer.uint32(/* id 1053, wireType 2 =*/8426).fork()).ldelim(); + $root.google.api.ResourceDescriptor.encode(message[".google.api.resourceDefinition"][i], writer.uint32(/* id 1053, wireType 2 =*/8426).fork(), q + 1).ldelim(); return writer; }; @@ -15192,12 +16727,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - FileOptions.decode = function decode(reader, length) { + FileOptions.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FileOptions(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.javaPackage = reader.string(); @@ -15276,23 +16817,23 @@ break; } case 50: { - message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32()); + message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32(), undefined, long + 1); break; } case 999: { if (!(message.uninterpretedOption && message.uninterpretedOption.length)) message.uninterpretedOption = []; - message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32())); + message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 1053: { if (!(message[".google.api.resourceDefinition"] && message[".google.api.resourceDefinition"].length)) message[".google.api.resourceDefinition"] = []; - message[".google.api.resourceDefinition"].push($root.google.api.ResourceDescriptor.decode(reader, reader.uint32())); + message[".google.api.resourceDefinition"].push($root.google.api.ResourceDescriptor.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -15323,25 +16864,29 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - FileOptions.verify = function verify(message) { + FileOptions.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.javaPackage != null && message.hasOwnProperty("javaPackage")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.javaPackage != null && Object.hasOwnProperty.call(message, "javaPackage")) if (!$util.isString(message.javaPackage)) return "javaPackage: string expected"; - if (message.javaOuterClassname != null && message.hasOwnProperty("javaOuterClassname")) + if (message.javaOuterClassname != null && Object.hasOwnProperty.call(message, "javaOuterClassname")) if (!$util.isString(message.javaOuterClassname)) return "javaOuterClassname: string expected"; - if (message.javaMultipleFiles != null && message.hasOwnProperty("javaMultipleFiles")) + if (message.javaMultipleFiles != null && Object.hasOwnProperty.call(message, "javaMultipleFiles")) if (typeof message.javaMultipleFiles !== "boolean") return "javaMultipleFiles: boolean expected"; - if (message.javaGenerateEqualsAndHash != null && message.hasOwnProperty("javaGenerateEqualsAndHash")) + if (message.javaGenerateEqualsAndHash != null && Object.hasOwnProperty.call(message, "javaGenerateEqualsAndHash")) if (typeof message.javaGenerateEqualsAndHash !== "boolean") return "javaGenerateEqualsAndHash: boolean expected"; - if (message.javaStringCheckUtf8 != null && message.hasOwnProperty("javaStringCheckUtf8")) + if (message.javaStringCheckUtf8 != null && Object.hasOwnProperty.call(message, "javaStringCheckUtf8")) if (typeof message.javaStringCheckUtf8 !== "boolean") return "javaStringCheckUtf8: boolean expected"; - if (message.optimizeFor != null && message.hasOwnProperty("optimizeFor")) + if (message.optimizeFor != null && Object.hasOwnProperty.call(message, "optimizeFor")) switch (message.optimizeFor) { default: return "optimizeFor: enum value expected"; @@ -15350,64 +16895,64 @@ case 3: break; } - if (message.goPackage != null && message.hasOwnProperty("goPackage")) + if (message.goPackage != null && Object.hasOwnProperty.call(message, "goPackage")) if (!$util.isString(message.goPackage)) return "goPackage: string expected"; - if (message.ccGenericServices != null && message.hasOwnProperty("ccGenericServices")) + if (message.ccGenericServices != null && Object.hasOwnProperty.call(message, "ccGenericServices")) if (typeof message.ccGenericServices !== "boolean") return "ccGenericServices: boolean expected"; - if (message.javaGenericServices != null && message.hasOwnProperty("javaGenericServices")) + if (message.javaGenericServices != null && Object.hasOwnProperty.call(message, "javaGenericServices")) if (typeof message.javaGenericServices !== "boolean") return "javaGenericServices: boolean expected"; - if (message.pyGenericServices != null && message.hasOwnProperty("pyGenericServices")) + if (message.pyGenericServices != null && Object.hasOwnProperty.call(message, "pyGenericServices")) if (typeof message.pyGenericServices !== "boolean") return "pyGenericServices: boolean expected"; - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) if (typeof message.deprecated !== "boolean") return "deprecated: boolean expected"; - if (message.ccEnableArenas != null && message.hasOwnProperty("ccEnableArenas")) + if (message.ccEnableArenas != null && Object.hasOwnProperty.call(message, "ccEnableArenas")) if (typeof message.ccEnableArenas !== "boolean") return "ccEnableArenas: boolean expected"; - if (message.objcClassPrefix != null && message.hasOwnProperty("objcClassPrefix")) + if (message.objcClassPrefix != null && Object.hasOwnProperty.call(message, "objcClassPrefix")) if (!$util.isString(message.objcClassPrefix)) return "objcClassPrefix: string expected"; - if (message.csharpNamespace != null && message.hasOwnProperty("csharpNamespace")) + if (message.csharpNamespace != null && Object.hasOwnProperty.call(message, "csharpNamespace")) if (!$util.isString(message.csharpNamespace)) return "csharpNamespace: string expected"; - if (message.swiftPrefix != null && message.hasOwnProperty("swiftPrefix")) + if (message.swiftPrefix != null && Object.hasOwnProperty.call(message, "swiftPrefix")) if (!$util.isString(message.swiftPrefix)) return "swiftPrefix: string expected"; - if (message.phpClassPrefix != null && message.hasOwnProperty("phpClassPrefix")) + if (message.phpClassPrefix != null && Object.hasOwnProperty.call(message, "phpClassPrefix")) if (!$util.isString(message.phpClassPrefix)) return "phpClassPrefix: string expected"; - if (message.phpNamespace != null && message.hasOwnProperty("phpNamespace")) + if (message.phpNamespace != null && Object.hasOwnProperty.call(message, "phpNamespace")) if (!$util.isString(message.phpNamespace)) return "phpNamespace: string expected"; - if (message.phpMetadataNamespace != null && message.hasOwnProperty("phpMetadataNamespace")) + if (message.phpMetadataNamespace != null && Object.hasOwnProperty.call(message, "phpMetadataNamespace")) if (!$util.isString(message.phpMetadataNamespace)) return "phpMetadataNamespace: string expected"; - if (message.rubyPackage != null && message.hasOwnProperty("rubyPackage")) + if (message.rubyPackage != null && Object.hasOwnProperty.call(message, "rubyPackage")) if (!$util.isString(message.rubyPackage)) return "rubyPackage: string expected"; - if (message.features != null && message.hasOwnProperty("features")) { - var error = $root.google.protobuf.FeatureSet.verify(message.features); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) { + var error = $root.google.protobuf.FeatureSet.verify(message.features, long + 1); if (error) return "features." + error; } - if (message.uninterpretedOption != null && message.hasOwnProperty("uninterpretedOption")) { + if (message.uninterpretedOption != null && Object.hasOwnProperty.call(message, "uninterpretedOption")) { if (!Array.isArray(message.uninterpretedOption)) return "uninterpretedOption: array expected"; for (var i = 0; i < message.uninterpretedOption.length; ++i) { - var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i]); + var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i], long + 1); if (error) return "uninterpretedOption." + error; } } - if (message[".google.api.resourceDefinition"] != null && message.hasOwnProperty(".google.api.resourceDefinition")) { + if (message[".google.api.resourceDefinition"] != null && Object.hasOwnProperty.call(message, ".google.api.resourceDefinition")) { if (!Array.isArray(message[".google.api.resourceDefinition"])) return ".google.api.resourceDefinition: array expected"; for (var i = 0; i < message[".google.api.resourceDefinition"].length; ++i) { - var error = $root.google.api.ResourceDescriptor.verify(message[".google.api.resourceDefinition"][i]); + var error = $root.google.api.ResourceDescriptor.verify(message[".google.api.resourceDefinition"][i], long + 1); if (error) return ".google.api.resourceDefinition." + error; } @@ -15423,9 +16968,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.FileOptions} FileOptions */ - FileOptions.fromObject = function fromObject(object) { + FileOptions.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.FileOptions) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.FileOptions: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.FileOptions(); if (object.javaPackage != null) message.javaPackage = String(object.javaPackage); @@ -15484,18 +17035,18 @@ if (object.rubyPackage != null) message.rubyPackage = String(object.rubyPackage); if (object.features != null) { - if (typeof object.features !== "object") + if (!$util.isObject(object.features)) throw TypeError(".google.protobuf.FileOptions.features: object expected"); - message.features = $root.google.protobuf.FeatureSet.fromObject(object.features); + message.features = $root.google.protobuf.FeatureSet.fromObject(object.features, long + 1); } if (object.uninterpretedOption) { if (!Array.isArray(object.uninterpretedOption)) throw TypeError(".google.protobuf.FileOptions.uninterpretedOption: array expected"); message.uninterpretedOption = []; for (var i = 0; i < object.uninterpretedOption.length; ++i) { - if (typeof object.uninterpretedOption[i] !== "object") + if (!$util.isObject(object.uninterpretedOption[i])) throw TypeError(".google.protobuf.FileOptions.uninterpretedOption: object expected"); - message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i]); + message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i], long + 1); } } if (object[".google.api.resourceDefinition"]) { @@ -15503,9 +17054,9 @@ throw TypeError(".google.protobuf.FileOptions..google.api.resourceDefinition: array expected"); message[".google.api.resourceDefinition"] = []; for (var i = 0; i < object[".google.api.resourceDefinition"].length; ++i) { - if (typeof object[".google.api.resourceDefinition"][i] !== "object") + if (!$util.isObject(object[".google.api.resourceDefinition"][i])) throw TypeError(".google.protobuf.FileOptions..google.api.resourceDefinition: object expected"); - message[".google.api.resourceDefinition"][i] = $root.google.api.ResourceDescriptor.fromObject(object[".google.api.resourceDefinition"][i]); + message[".google.api.resourceDefinition"][i] = $root.google.api.ResourceDescriptor.fromObject(object[".google.api.resourceDefinition"][i], long + 1); } } return message; @@ -15520,9 +17071,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - FileOptions.toObject = function toObject(message, options) { + FileOptions.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.uninterpretedOption = []; @@ -15550,55 +17105,55 @@ object.rubyPackage = ""; object.features = null; } - if (message.javaPackage != null && message.hasOwnProperty("javaPackage")) + if (message.javaPackage != null && Object.hasOwnProperty.call(message, "javaPackage")) object.javaPackage = message.javaPackage; - if (message.javaOuterClassname != null && message.hasOwnProperty("javaOuterClassname")) + if (message.javaOuterClassname != null && Object.hasOwnProperty.call(message, "javaOuterClassname")) object.javaOuterClassname = message.javaOuterClassname; - if (message.optimizeFor != null && message.hasOwnProperty("optimizeFor")) + if (message.optimizeFor != null && Object.hasOwnProperty.call(message, "optimizeFor")) object.optimizeFor = options.enums === String ? $root.google.protobuf.FileOptions.OptimizeMode[message.optimizeFor] === undefined ? message.optimizeFor : $root.google.protobuf.FileOptions.OptimizeMode[message.optimizeFor] : message.optimizeFor; - if (message.javaMultipleFiles != null && message.hasOwnProperty("javaMultipleFiles")) + if (message.javaMultipleFiles != null && Object.hasOwnProperty.call(message, "javaMultipleFiles")) object.javaMultipleFiles = message.javaMultipleFiles; - if (message.goPackage != null && message.hasOwnProperty("goPackage")) + if (message.goPackage != null && Object.hasOwnProperty.call(message, "goPackage")) object.goPackage = message.goPackage; - if (message.ccGenericServices != null && message.hasOwnProperty("ccGenericServices")) + if (message.ccGenericServices != null && Object.hasOwnProperty.call(message, "ccGenericServices")) object.ccGenericServices = message.ccGenericServices; - if (message.javaGenericServices != null && message.hasOwnProperty("javaGenericServices")) + if (message.javaGenericServices != null && Object.hasOwnProperty.call(message, "javaGenericServices")) object.javaGenericServices = message.javaGenericServices; - if (message.pyGenericServices != null && message.hasOwnProperty("pyGenericServices")) + if (message.pyGenericServices != null && Object.hasOwnProperty.call(message, "pyGenericServices")) object.pyGenericServices = message.pyGenericServices; - if (message.javaGenerateEqualsAndHash != null && message.hasOwnProperty("javaGenerateEqualsAndHash")) + if (message.javaGenerateEqualsAndHash != null && Object.hasOwnProperty.call(message, "javaGenerateEqualsAndHash")) object.javaGenerateEqualsAndHash = message.javaGenerateEqualsAndHash; - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) object.deprecated = message.deprecated; - if (message.javaStringCheckUtf8 != null && message.hasOwnProperty("javaStringCheckUtf8")) + if (message.javaStringCheckUtf8 != null && Object.hasOwnProperty.call(message, "javaStringCheckUtf8")) object.javaStringCheckUtf8 = message.javaStringCheckUtf8; - if (message.ccEnableArenas != null && message.hasOwnProperty("ccEnableArenas")) + if (message.ccEnableArenas != null && Object.hasOwnProperty.call(message, "ccEnableArenas")) object.ccEnableArenas = message.ccEnableArenas; - if (message.objcClassPrefix != null && message.hasOwnProperty("objcClassPrefix")) + if (message.objcClassPrefix != null && Object.hasOwnProperty.call(message, "objcClassPrefix")) object.objcClassPrefix = message.objcClassPrefix; - if (message.csharpNamespace != null && message.hasOwnProperty("csharpNamespace")) + if (message.csharpNamespace != null && Object.hasOwnProperty.call(message, "csharpNamespace")) object.csharpNamespace = message.csharpNamespace; - if (message.swiftPrefix != null && message.hasOwnProperty("swiftPrefix")) + if (message.swiftPrefix != null && Object.hasOwnProperty.call(message, "swiftPrefix")) object.swiftPrefix = message.swiftPrefix; - if (message.phpClassPrefix != null && message.hasOwnProperty("phpClassPrefix")) + if (message.phpClassPrefix != null && Object.hasOwnProperty.call(message, "phpClassPrefix")) object.phpClassPrefix = message.phpClassPrefix; - if (message.phpNamespace != null && message.hasOwnProperty("phpNamespace")) + if (message.phpNamespace != null && Object.hasOwnProperty.call(message, "phpNamespace")) object.phpNamespace = message.phpNamespace; - if (message.phpMetadataNamespace != null && message.hasOwnProperty("phpMetadataNamespace")) + if (message.phpMetadataNamespace != null && Object.hasOwnProperty.call(message, "phpMetadataNamespace")) object.phpMetadataNamespace = message.phpMetadataNamespace; - if (message.rubyPackage != null && message.hasOwnProperty("rubyPackage")) + if (message.rubyPackage != null && Object.hasOwnProperty.call(message, "rubyPackage")) object.rubyPackage = message.rubyPackage; - if (message.features != null && message.hasOwnProperty("features")) - object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) + object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options, q + 1); if (message.uninterpretedOption && message.uninterpretedOption.length) { object.uninterpretedOption = []; for (var j = 0; j < message.uninterpretedOption.length; ++j) - object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options); + object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options, q + 1); } if (message[".google.api.resourceDefinition"] && message[".google.api.resourceDefinition"].length) { object[".google.api.resourceDefinition"] = []; for (var j = 0; j < message[".google.api.resourceDefinition"].length; ++j) - object[".google.api.resourceDefinition"][j] = $root.google.api.ResourceDescriptor.toObject(message[".google.api.resourceDefinition"][j], options); + object[".google.api.resourceDefinition"][j] = $root.google.api.ResourceDescriptor.toObject(message[".google.api.resourceDefinition"][j], options, q + 1); } return object; }; @@ -15676,7 +17231,7 @@ this.uninterpretedOption = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -15765,9 +17320,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - MessageOptions.encode = function encode(message, writer) { + MessageOptions.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.messageSetWireFormat != null && Object.hasOwnProperty.call(message, "messageSetWireFormat")) writer.uint32(/* id 1, wireType 0 =*/8).bool(message.messageSetWireFormat); if (message.noStandardDescriptorAccessor != null && Object.hasOwnProperty.call(message, "noStandardDescriptorAccessor")) @@ -15779,12 +17338,12 @@ if (message.deprecatedLegacyJsonFieldConflicts != null && Object.hasOwnProperty.call(message, "deprecatedLegacyJsonFieldConflicts")) writer.uint32(/* id 11, wireType 0 =*/88).bool(message.deprecatedLegacyJsonFieldConflicts); if (message.features != null && Object.hasOwnProperty.call(message, "features")) - $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim(); + $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 12, wireType 2 =*/98).fork(), q + 1).ldelim(); if (message.uninterpretedOption != null && message.uninterpretedOption.length) for (var i = 0; i < message.uninterpretedOption.length; ++i) - $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork()).ldelim(); + $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork(), q + 1).ldelim(); if (message[".google.api.resource"] != null && Object.hasOwnProperty.call(message, ".google.api.resource")) - $root.google.api.ResourceDescriptor.encode(message[".google.api.resource"], writer.uint32(/* id 1053, wireType 2 =*/8426).fork()).ldelim(); + $root.google.api.ResourceDescriptor.encode(message[".google.api.resource"], writer.uint32(/* id 1053, wireType 2 =*/8426).fork(), q + 1).ldelim(); return writer; }; @@ -15812,12 +17371,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - MessageOptions.decode = function decode(reader, length) { + MessageOptions.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.MessageOptions(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.messageSetWireFormat = reader.bool(); @@ -15840,21 +17405,21 @@ break; } case 12: { - message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32()); + message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32(), undefined, long + 1); break; } case 999: { if (!(message.uninterpretedOption && message.uninterpretedOption.length)) message.uninterpretedOption = []; - message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32())); + message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 1053: { - message[".google.api.resource"] = $root.google.api.ResourceDescriptor.decode(reader, reader.uint32()); + message[".google.api.resource"] = $root.google.api.ResourceDescriptor.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -15885,40 +17450,44 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - MessageOptions.verify = function verify(message) { + MessageOptions.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.messageSetWireFormat != null && message.hasOwnProperty("messageSetWireFormat")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.messageSetWireFormat != null && Object.hasOwnProperty.call(message, "messageSetWireFormat")) if (typeof message.messageSetWireFormat !== "boolean") return "messageSetWireFormat: boolean expected"; - if (message.noStandardDescriptorAccessor != null && message.hasOwnProperty("noStandardDescriptorAccessor")) + if (message.noStandardDescriptorAccessor != null && Object.hasOwnProperty.call(message, "noStandardDescriptorAccessor")) if (typeof message.noStandardDescriptorAccessor !== "boolean") return "noStandardDescriptorAccessor: boolean expected"; - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) if (typeof message.deprecated !== "boolean") return "deprecated: boolean expected"; - if (message.mapEntry != null && message.hasOwnProperty("mapEntry")) + if (message.mapEntry != null && Object.hasOwnProperty.call(message, "mapEntry")) if (typeof message.mapEntry !== "boolean") return "mapEntry: boolean expected"; - if (message.deprecatedLegacyJsonFieldConflicts != null && message.hasOwnProperty("deprecatedLegacyJsonFieldConflicts")) + if (message.deprecatedLegacyJsonFieldConflicts != null && Object.hasOwnProperty.call(message, "deprecatedLegacyJsonFieldConflicts")) if (typeof message.deprecatedLegacyJsonFieldConflicts !== "boolean") return "deprecatedLegacyJsonFieldConflicts: boolean expected"; - if (message.features != null && message.hasOwnProperty("features")) { - var error = $root.google.protobuf.FeatureSet.verify(message.features); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) { + var error = $root.google.protobuf.FeatureSet.verify(message.features, long + 1); if (error) return "features." + error; } - if (message.uninterpretedOption != null && message.hasOwnProperty("uninterpretedOption")) { + if (message.uninterpretedOption != null && Object.hasOwnProperty.call(message, "uninterpretedOption")) { if (!Array.isArray(message.uninterpretedOption)) return "uninterpretedOption: array expected"; for (var i = 0; i < message.uninterpretedOption.length; ++i) { - var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i]); + var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i], long + 1); if (error) return "uninterpretedOption." + error; } } - if (message[".google.api.resource"] != null && message.hasOwnProperty(".google.api.resource")) { - var error = $root.google.api.ResourceDescriptor.verify(message[".google.api.resource"]); + if (message[".google.api.resource"] != null && Object.hasOwnProperty.call(message, ".google.api.resource")) { + var error = $root.google.api.ResourceDescriptor.verify(message[".google.api.resource"], long + 1); if (error) return ".google.api.resource." + error; } @@ -15933,9 +17502,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.MessageOptions} MessageOptions */ - MessageOptions.fromObject = function fromObject(object) { + MessageOptions.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.MessageOptions) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.MessageOptions: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.MessageOptions(); if (object.messageSetWireFormat != null) message.messageSetWireFormat = Boolean(object.messageSetWireFormat); @@ -15948,24 +17523,24 @@ if (object.deprecatedLegacyJsonFieldConflicts != null) message.deprecatedLegacyJsonFieldConflicts = Boolean(object.deprecatedLegacyJsonFieldConflicts); if (object.features != null) { - if (typeof object.features !== "object") + if (!$util.isObject(object.features)) throw TypeError(".google.protobuf.MessageOptions.features: object expected"); - message.features = $root.google.protobuf.FeatureSet.fromObject(object.features); + message.features = $root.google.protobuf.FeatureSet.fromObject(object.features, long + 1); } if (object.uninterpretedOption) { if (!Array.isArray(object.uninterpretedOption)) throw TypeError(".google.protobuf.MessageOptions.uninterpretedOption: array expected"); message.uninterpretedOption = []; for (var i = 0; i < object.uninterpretedOption.length; ++i) { - if (typeof object.uninterpretedOption[i] !== "object") + if (!$util.isObject(object.uninterpretedOption[i])) throw TypeError(".google.protobuf.MessageOptions.uninterpretedOption: object expected"); - message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i]); + message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i], long + 1); } } if (object[".google.api.resource"] != null) { - if (typeof object[".google.api.resource"] !== "object") + if (!$util.isObject(object[".google.api.resource"])) throw TypeError(".google.protobuf.MessageOptions..google.api.resource: object expected"); - message[".google.api.resource"] = $root.google.api.ResourceDescriptor.fromObject(object[".google.api.resource"]); + message[".google.api.resource"] = $root.google.api.ResourceDescriptor.fromObject(object[".google.api.resource"], long + 1); } return message; }; @@ -15979,9 +17554,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - MessageOptions.toObject = function toObject(message, options) { + MessageOptions.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.uninterpretedOption = []; @@ -15994,25 +17573,25 @@ object.features = null; object[".google.api.resource"] = null; } - if (message.messageSetWireFormat != null && message.hasOwnProperty("messageSetWireFormat")) + if (message.messageSetWireFormat != null && Object.hasOwnProperty.call(message, "messageSetWireFormat")) object.messageSetWireFormat = message.messageSetWireFormat; - if (message.noStandardDescriptorAccessor != null && message.hasOwnProperty("noStandardDescriptorAccessor")) + if (message.noStandardDescriptorAccessor != null && Object.hasOwnProperty.call(message, "noStandardDescriptorAccessor")) object.noStandardDescriptorAccessor = message.noStandardDescriptorAccessor; - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) object.deprecated = message.deprecated; - if (message.mapEntry != null && message.hasOwnProperty("mapEntry")) + if (message.mapEntry != null && Object.hasOwnProperty.call(message, "mapEntry")) object.mapEntry = message.mapEntry; - if (message.deprecatedLegacyJsonFieldConflicts != null && message.hasOwnProperty("deprecatedLegacyJsonFieldConflicts")) + if (message.deprecatedLegacyJsonFieldConflicts != null && Object.hasOwnProperty.call(message, "deprecatedLegacyJsonFieldConflicts")) object.deprecatedLegacyJsonFieldConflicts = message.deprecatedLegacyJsonFieldConflicts; - if (message.features != null && message.hasOwnProperty("features")) - object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) + object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options, q + 1); if (message.uninterpretedOption && message.uninterpretedOption.length) { object.uninterpretedOption = []; for (var j = 0; j < message.uninterpretedOption.length; ++j) - object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options); + object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options, q + 1); } - if (message[".google.api.resource"] != null && message.hasOwnProperty(".google.api.resource")) - object[".google.api.resource"] = $root.google.api.ResourceDescriptor.toObject(message[".google.api.resource"], options); + if (message[".google.api.resource"] != null && Object.hasOwnProperty.call(message, ".google.api.resource")) + object[".google.api.resource"] = $root.google.api.ResourceDescriptor.toObject(message[".google.api.resource"], options, q + 1); return object; }; @@ -16084,7 +17663,7 @@ this[".google.api.fieldBehavior"] = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -16237,9 +17816,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - FieldOptions.encode = function encode(message, writer) { + FieldOptions.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.ctype != null && Object.hasOwnProperty.call(message, "ctype")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.ctype); if (message.packed != null && Object.hasOwnProperty.call(message, "packed")) @@ -16263,19 +17846,19 @@ writer.uint32(/* id 19, wireType 0 =*/152).int32(message.targets[i]); if (message.editionDefaults != null && message.editionDefaults.length) for (var i = 0; i < message.editionDefaults.length; ++i) - $root.google.protobuf.FieldOptions.EditionDefault.encode(message.editionDefaults[i], writer.uint32(/* id 20, wireType 2 =*/162).fork()).ldelim(); + $root.google.protobuf.FieldOptions.EditionDefault.encode(message.editionDefaults[i], writer.uint32(/* id 20, wireType 2 =*/162).fork(), q + 1).ldelim(); if (message.features != null && Object.hasOwnProperty.call(message, "features")) - $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 21, wireType 2 =*/170).fork()).ldelim(); + $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 21, wireType 2 =*/170).fork(), q + 1).ldelim(); if (message.uninterpretedOption != null && message.uninterpretedOption.length) for (var i = 0; i < message.uninterpretedOption.length; ++i) - $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork()).ldelim(); + $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork(), q + 1).ldelim(); if (message[".google.api.fieldBehavior"] != null && message[".google.api.fieldBehavior"].length) for (var i = 0; i < message[".google.api.fieldBehavior"].length; ++i) writer.uint32(/* id 1052, wireType 0 =*/8416).int32(message[".google.api.fieldBehavior"][i]); if (message[".google.api.resourceReference"] != null && Object.hasOwnProperty.call(message, ".google.api.resourceReference")) - $root.google.api.ResourceReference.encode(message[".google.api.resourceReference"], writer.uint32(/* id 1055, wireType 2 =*/8442).fork()).ldelim(); + $root.google.api.ResourceReference.encode(message[".google.api.resourceReference"], writer.uint32(/* id 1055, wireType 2 =*/8442).fork(), q + 1).ldelim(); if (message[".google.api.fieldInfo"] != null && Object.hasOwnProperty.call(message, ".google.api.fieldInfo")) - $root.google.api.FieldInfo.encode(message[".google.api.fieldInfo"], writer.uint32(/* id 291403980, wireType 2 =*/2331231842).fork()).ldelim(); + $root.google.api.FieldInfo.encode(message[".google.api.fieldInfo"], writer.uint32(/* id 291403980, wireType 2 =*/2331231842).fork(), q + 1).ldelim(); return writer; }; @@ -16303,12 +17886,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - FieldOptions.decode = function decode(reader, length) { + FieldOptions.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FieldOptions(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.ctype = reader.int32(); @@ -16360,17 +17949,17 @@ case 20: { if (!(message.editionDefaults && message.editionDefaults.length)) message.editionDefaults = []; - message.editionDefaults.push($root.google.protobuf.FieldOptions.EditionDefault.decode(reader, reader.uint32())); + message.editionDefaults.push($root.google.protobuf.FieldOptions.EditionDefault.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 21: { - message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32()); + message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32(), undefined, long + 1); break; } case 999: { if (!(message.uninterpretedOption && message.uninterpretedOption.length)) message.uninterpretedOption = []; - message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32())); + message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 1052: { @@ -16385,15 +17974,15 @@ break; } case 291403980: { - message[".google.api.fieldInfo"] = $root.google.api.FieldInfo.decode(reader, reader.uint32()); + message[".google.api.fieldInfo"] = $root.google.api.FieldInfo.decode(reader, reader.uint32(), undefined, long + 1); break; } case 1055: { - message[".google.api.resourceReference"] = $root.google.api.ResourceReference.decode(reader, reader.uint32()); + message[".google.api.resourceReference"] = $root.google.api.ResourceReference.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -16424,10 +18013,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - FieldOptions.verify = function verify(message) { + FieldOptions.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.ctype != null && message.hasOwnProperty("ctype")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.ctype != null && Object.hasOwnProperty.call(message, "ctype")) switch (message.ctype) { default: return "ctype: enum value expected"; @@ -16436,10 +18029,10 @@ case 2: break; } - if (message.packed != null && message.hasOwnProperty("packed")) + if (message.packed != null && Object.hasOwnProperty.call(message, "packed")) if (typeof message.packed !== "boolean") return "packed: boolean expected"; - if (message.jstype != null && message.hasOwnProperty("jstype")) + if (message.jstype != null && Object.hasOwnProperty.call(message, "jstype")) switch (message.jstype) { default: return "jstype: enum value expected"; @@ -16448,22 +18041,22 @@ case 2: break; } - if (message.lazy != null && message.hasOwnProperty("lazy")) + if (message.lazy != null && Object.hasOwnProperty.call(message, "lazy")) if (typeof message.lazy !== "boolean") return "lazy: boolean expected"; - if (message.unverifiedLazy != null && message.hasOwnProperty("unverifiedLazy")) + if (message.unverifiedLazy != null && Object.hasOwnProperty.call(message, "unverifiedLazy")) if (typeof message.unverifiedLazy !== "boolean") return "unverifiedLazy: boolean expected"; - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) if (typeof message.deprecated !== "boolean") return "deprecated: boolean expected"; - if (message.weak != null && message.hasOwnProperty("weak")) + if (message.weak != null && Object.hasOwnProperty.call(message, "weak")) if (typeof message.weak !== "boolean") return "weak: boolean expected"; - if (message.debugRedact != null && message.hasOwnProperty("debugRedact")) + if (message.debugRedact != null && Object.hasOwnProperty.call(message, "debugRedact")) if (typeof message.debugRedact !== "boolean") return "debugRedact: boolean expected"; - if (message.retention != null && message.hasOwnProperty("retention")) + if (message.retention != null && Object.hasOwnProperty.call(message, "retention")) switch (message.retention) { default: return "retention: enum value expected"; @@ -16472,7 +18065,7 @@ case 2: break; } - if (message.targets != null && message.hasOwnProperty("targets")) { + if (message.targets != null && Object.hasOwnProperty.call(message, "targets")) { if (!Array.isArray(message.targets)) return "targets: array expected"; for (var i = 0; i < message.targets.length; ++i) @@ -16492,30 +18085,30 @@ break; } } - if (message.editionDefaults != null && message.hasOwnProperty("editionDefaults")) { + if (message.editionDefaults != null && Object.hasOwnProperty.call(message, "editionDefaults")) { if (!Array.isArray(message.editionDefaults)) return "editionDefaults: array expected"; for (var i = 0; i < message.editionDefaults.length; ++i) { - var error = $root.google.protobuf.FieldOptions.EditionDefault.verify(message.editionDefaults[i]); + var error = $root.google.protobuf.FieldOptions.EditionDefault.verify(message.editionDefaults[i], long + 1); if (error) return "editionDefaults." + error; } } - if (message.features != null && message.hasOwnProperty("features")) { - var error = $root.google.protobuf.FeatureSet.verify(message.features); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) { + var error = $root.google.protobuf.FeatureSet.verify(message.features, long + 1); if (error) return "features." + error; } - if (message.uninterpretedOption != null && message.hasOwnProperty("uninterpretedOption")) { + if (message.uninterpretedOption != null && Object.hasOwnProperty.call(message, "uninterpretedOption")) { if (!Array.isArray(message.uninterpretedOption)) return "uninterpretedOption: array expected"; for (var i = 0; i < message.uninterpretedOption.length; ++i) { - var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i]); + var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i], long + 1); if (error) return "uninterpretedOption." + error; } } - if (message[".google.api.fieldBehavior"] != null && message.hasOwnProperty(".google.api.fieldBehavior")) { + if (message[".google.api.fieldBehavior"] != null && Object.hasOwnProperty.call(message, ".google.api.fieldBehavior")) { if (!Array.isArray(message[".google.api.fieldBehavior"])) return ".google.api.fieldBehavior: array expected"; for (var i = 0; i < message[".google.api.fieldBehavior"].length; ++i) @@ -16534,13 +18127,13 @@ break; } } - if (message[".google.api.fieldInfo"] != null && message.hasOwnProperty(".google.api.fieldInfo")) { - var error = $root.google.api.FieldInfo.verify(message[".google.api.fieldInfo"]); + if (message[".google.api.fieldInfo"] != null && Object.hasOwnProperty.call(message, ".google.api.fieldInfo")) { + var error = $root.google.api.FieldInfo.verify(message[".google.api.fieldInfo"], long + 1); if (error) return ".google.api.fieldInfo." + error; } - if (message[".google.api.resourceReference"] != null && message.hasOwnProperty(".google.api.resourceReference")) { - var error = $root.google.api.ResourceReference.verify(message[".google.api.resourceReference"]); + if (message[".google.api.resourceReference"] != null && Object.hasOwnProperty.call(message, ".google.api.resourceReference")) { + var error = $root.google.api.ResourceReference.verify(message[".google.api.resourceReference"], long + 1); if (error) return ".google.api.resourceReference." + error; } @@ -16555,9 +18148,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.FieldOptions} FieldOptions */ - FieldOptions.fromObject = function fromObject(object) { + FieldOptions.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.FieldOptions) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.FieldOptions: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.FieldOptions(); switch (object.ctype) { default: @@ -16689,24 +18288,24 @@ throw TypeError(".google.protobuf.FieldOptions.editionDefaults: array expected"); message.editionDefaults = []; for (var i = 0; i < object.editionDefaults.length; ++i) { - if (typeof object.editionDefaults[i] !== "object") + if (!$util.isObject(object.editionDefaults[i])) throw TypeError(".google.protobuf.FieldOptions.editionDefaults: object expected"); - message.editionDefaults[i] = $root.google.protobuf.FieldOptions.EditionDefault.fromObject(object.editionDefaults[i]); + message.editionDefaults[i] = $root.google.protobuf.FieldOptions.EditionDefault.fromObject(object.editionDefaults[i], long + 1); } } if (object.features != null) { - if (typeof object.features !== "object") + if (!$util.isObject(object.features)) throw TypeError(".google.protobuf.FieldOptions.features: object expected"); - message.features = $root.google.protobuf.FeatureSet.fromObject(object.features); + message.features = $root.google.protobuf.FeatureSet.fromObject(object.features, long + 1); } if (object.uninterpretedOption) { if (!Array.isArray(object.uninterpretedOption)) throw TypeError(".google.protobuf.FieldOptions.uninterpretedOption: array expected"); message.uninterpretedOption = []; for (var i = 0; i < object.uninterpretedOption.length; ++i) { - if (typeof object.uninterpretedOption[i] !== "object") + if (!$util.isObject(object.uninterpretedOption[i])) throw TypeError(".google.protobuf.FieldOptions.uninterpretedOption: object expected"); - message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i]); + message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i], long + 1); } } if (object[".google.api.fieldBehavior"]) { @@ -16759,14 +18358,14 @@ } } if (object[".google.api.fieldInfo"] != null) { - if (typeof object[".google.api.fieldInfo"] !== "object") + if (!$util.isObject(object[".google.api.fieldInfo"])) throw TypeError(".google.protobuf.FieldOptions..google.api.fieldInfo: object expected"); - message[".google.api.fieldInfo"] = $root.google.api.FieldInfo.fromObject(object[".google.api.fieldInfo"]); + message[".google.api.fieldInfo"] = $root.google.api.FieldInfo.fromObject(object[".google.api.fieldInfo"], long + 1); } if (object[".google.api.resourceReference"] != null) { - if (typeof object[".google.api.resourceReference"] !== "object") + if (!$util.isObject(object[".google.api.resourceReference"])) throw TypeError(".google.protobuf.FieldOptions..google.api.resourceReference: object expected"); - message[".google.api.resourceReference"] = $root.google.api.ResourceReference.fromObject(object[".google.api.resourceReference"]); + message[".google.api.resourceReference"] = $root.google.api.ResourceReference.fromObject(object[".google.api.resourceReference"], long + 1); } return message; }; @@ -16780,9 +18379,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - FieldOptions.toObject = function toObject(message, options) { + FieldOptions.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.targets = []; @@ -16804,23 +18407,23 @@ object[".google.api.resourceReference"] = null; object[".google.api.fieldInfo"] = null; } - if (message.ctype != null && message.hasOwnProperty("ctype")) + if (message.ctype != null && Object.hasOwnProperty.call(message, "ctype")) object.ctype = options.enums === String ? $root.google.protobuf.FieldOptions.CType[message.ctype] === undefined ? message.ctype : $root.google.protobuf.FieldOptions.CType[message.ctype] : message.ctype; - if (message.packed != null && message.hasOwnProperty("packed")) + if (message.packed != null && Object.hasOwnProperty.call(message, "packed")) object.packed = message.packed; - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) object.deprecated = message.deprecated; - if (message.lazy != null && message.hasOwnProperty("lazy")) + if (message.lazy != null && Object.hasOwnProperty.call(message, "lazy")) object.lazy = message.lazy; - if (message.jstype != null && message.hasOwnProperty("jstype")) + if (message.jstype != null && Object.hasOwnProperty.call(message, "jstype")) object.jstype = options.enums === String ? $root.google.protobuf.FieldOptions.JSType[message.jstype] === undefined ? message.jstype : $root.google.protobuf.FieldOptions.JSType[message.jstype] : message.jstype; - if (message.weak != null && message.hasOwnProperty("weak")) + if (message.weak != null && Object.hasOwnProperty.call(message, "weak")) object.weak = message.weak; - if (message.unverifiedLazy != null && message.hasOwnProperty("unverifiedLazy")) + if (message.unverifiedLazy != null && Object.hasOwnProperty.call(message, "unverifiedLazy")) object.unverifiedLazy = message.unverifiedLazy; - if (message.debugRedact != null && message.hasOwnProperty("debugRedact")) + if (message.debugRedact != null && Object.hasOwnProperty.call(message, "debugRedact")) object.debugRedact = message.debugRedact; - if (message.retention != null && message.hasOwnProperty("retention")) + if (message.retention != null && Object.hasOwnProperty.call(message, "retention")) object.retention = options.enums === String ? $root.google.protobuf.FieldOptions.OptionRetention[message.retention] === undefined ? message.retention : $root.google.protobuf.FieldOptions.OptionRetention[message.retention] : message.retention; if (message.targets && message.targets.length) { object.targets = []; @@ -16830,24 +18433,24 @@ if (message.editionDefaults && message.editionDefaults.length) { object.editionDefaults = []; for (var j = 0; j < message.editionDefaults.length; ++j) - object.editionDefaults[j] = $root.google.protobuf.FieldOptions.EditionDefault.toObject(message.editionDefaults[j], options); + object.editionDefaults[j] = $root.google.protobuf.FieldOptions.EditionDefault.toObject(message.editionDefaults[j], options, q + 1); } - if (message.features != null && message.hasOwnProperty("features")) - object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) + object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options, q + 1); if (message.uninterpretedOption && message.uninterpretedOption.length) { object.uninterpretedOption = []; for (var j = 0; j < message.uninterpretedOption.length; ++j) - object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options); + object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options, q + 1); } if (message[".google.api.fieldBehavior"] && message[".google.api.fieldBehavior"].length) { object[".google.api.fieldBehavior"] = []; for (var j = 0; j < message[".google.api.fieldBehavior"].length; ++j) object[".google.api.fieldBehavior"][j] = options.enums === String ? $root.google.api.FieldBehavior[message[".google.api.fieldBehavior"][j]] === undefined ? message[".google.api.fieldBehavior"][j] : $root.google.api.FieldBehavior[message[".google.api.fieldBehavior"][j]] : message[".google.api.fieldBehavior"][j]; } - if (message[".google.api.resourceReference"] != null && message.hasOwnProperty(".google.api.resourceReference")) - object[".google.api.resourceReference"] = $root.google.api.ResourceReference.toObject(message[".google.api.resourceReference"], options); - if (message[".google.api.fieldInfo"] != null && message.hasOwnProperty(".google.api.fieldInfo")) - object[".google.api.fieldInfo"] = $root.google.api.FieldInfo.toObject(message[".google.api.fieldInfo"], options); + if (message[".google.api.resourceReference"] != null && Object.hasOwnProperty.call(message, ".google.api.resourceReference")) + object[".google.api.resourceReference"] = $root.google.api.ResourceReference.toObject(message[".google.api.resourceReference"], options, q + 1); + if (message[".google.api.fieldInfo"] != null && Object.hasOwnProperty.call(message, ".google.api.fieldInfo")) + object[".google.api.fieldInfo"] = $root.google.api.FieldInfo.toObject(message[".google.api.fieldInfo"], options, q + 1); return object; }; @@ -16976,7 +18579,7 @@ function EditionDefault(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -17017,9 +18620,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - EditionDefault.encode = function encode(message, writer) { + EditionDefault.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.value != null && Object.hasOwnProperty.call(message, "value")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.value); if (message.edition != null && Object.hasOwnProperty.call(message, "edition")) @@ -17051,12 +18658,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - EditionDefault.decode = function decode(reader, length) { + EditionDefault.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FieldOptions.EditionDefault(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 3: { message.edition = reader.int32(); @@ -17067,7 +18680,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -17098,10 +18711,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - EditionDefault.verify = function verify(message) { + EditionDefault.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.edition != null && message.hasOwnProperty("edition")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.edition != null && Object.hasOwnProperty.call(message, "edition")) switch (message.edition) { default: return "edition: enum value expected"; @@ -17118,7 +18735,7 @@ case 2147483647: break; } - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (!$util.isString(message.value)) return "value: string expected"; return null; @@ -17132,9 +18749,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.FieldOptions.EditionDefault} EditionDefault */ - EditionDefault.fromObject = function fromObject(object) { + EditionDefault.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.FieldOptions.EditionDefault) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.FieldOptions.EditionDefault: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.FieldOptions.EditionDefault(); switch (object.edition) { default: @@ -17202,17 +18825,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - EditionDefault.toObject = function toObject(message, options) { + EditionDefault.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.value = ""; object.edition = options.enums === String ? "EDITION_UNKNOWN" : 0; } - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) object.value = message.value; - if (message.edition != null && message.hasOwnProperty("edition")) + if (message.edition != null && Object.hasOwnProperty.call(message, "edition")) object.edition = options.enums === String ? $root.google.protobuf.Edition[message.edition] === undefined ? message.edition : $root.google.protobuf.Edition[message.edition] : message.edition; return object; }; @@ -17271,7 +18898,7 @@ this.uninterpretedOption = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -17312,14 +18939,18 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - OneofOptions.encode = function encode(message, writer) { + OneofOptions.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.features != null && Object.hasOwnProperty.call(message, "features")) - $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); if (message.uninterpretedOption != null && message.uninterpretedOption.length) for (var i = 0; i < message.uninterpretedOption.length; ++i) - $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork()).ldelim(); + $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork(), q + 1).ldelim(); return writer; }; @@ -17347,25 +18978,31 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - OneofOptions.decode = function decode(reader, length) { + OneofOptions.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.OneofOptions(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32()); + message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32(), undefined, long + 1); break; } case 999: { if (!(message.uninterpretedOption && message.uninterpretedOption.length)) message.uninterpretedOption = []; - message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32())); + message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -17396,19 +19033,23 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - OneofOptions.verify = function verify(message) { + OneofOptions.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.features != null && message.hasOwnProperty("features")) { - var error = $root.google.protobuf.FeatureSet.verify(message.features); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.features != null && Object.hasOwnProperty.call(message, "features")) { + var error = $root.google.protobuf.FeatureSet.verify(message.features, long + 1); if (error) return "features." + error; } - if (message.uninterpretedOption != null && message.hasOwnProperty("uninterpretedOption")) { + if (message.uninterpretedOption != null && Object.hasOwnProperty.call(message, "uninterpretedOption")) { if (!Array.isArray(message.uninterpretedOption)) return "uninterpretedOption: array expected"; for (var i = 0; i < message.uninterpretedOption.length; ++i) { - var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i]); + var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i], long + 1); if (error) return "uninterpretedOption." + error; } @@ -17424,23 +19065,29 @@ * @param {Object.} object Plain object * @returns {google.protobuf.OneofOptions} OneofOptions */ - OneofOptions.fromObject = function fromObject(object) { + OneofOptions.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.OneofOptions) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.OneofOptions: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.OneofOptions(); if (object.features != null) { - if (typeof object.features !== "object") + if (!$util.isObject(object.features)) throw TypeError(".google.protobuf.OneofOptions.features: object expected"); - message.features = $root.google.protobuf.FeatureSet.fromObject(object.features); + message.features = $root.google.protobuf.FeatureSet.fromObject(object.features, long + 1); } if (object.uninterpretedOption) { if (!Array.isArray(object.uninterpretedOption)) throw TypeError(".google.protobuf.OneofOptions.uninterpretedOption: array expected"); message.uninterpretedOption = []; for (var i = 0; i < object.uninterpretedOption.length; ++i) { - if (typeof object.uninterpretedOption[i] !== "object") + if (!$util.isObject(object.uninterpretedOption[i])) throw TypeError(".google.protobuf.OneofOptions.uninterpretedOption: object expected"); - message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i]); + message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i], long + 1); } } return message; @@ -17455,20 +19102,24 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - OneofOptions.toObject = function toObject(message, options) { + OneofOptions.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.uninterpretedOption = []; if (options.defaults) object.features = null; - if (message.features != null && message.hasOwnProperty("features")) - object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) + object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options, q + 1); if (message.uninterpretedOption && message.uninterpretedOption.length) { object.uninterpretedOption = []; for (var j = 0; j < message.uninterpretedOption.length; ++j) - object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options); + object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options, q + 1); } return object; }; @@ -17527,7 +19178,7 @@ this.uninterpretedOption = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -17592,9 +19243,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - EnumOptions.encode = function encode(message, writer) { + EnumOptions.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.allowAlias != null && Object.hasOwnProperty.call(message, "allowAlias")) writer.uint32(/* id 2, wireType 0 =*/16).bool(message.allowAlias); if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) @@ -17602,10 +19257,10 @@ if (message.deprecatedLegacyJsonFieldConflicts != null && Object.hasOwnProperty.call(message, "deprecatedLegacyJsonFieldConflicts")) writer.uint32(/* id 6, wireType 0 =*/48).bool(message.deprecatedLegacyJsonFieldConflicts); if (message.features != null && Object.hasOwnProperty.call(message, "features")) - $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim(); + $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 7, wireType 2 =*/58).fork(), q + 1).ldelim(); if (message.uninterpretedOption != null && message.uninterpretedOption.length) for (var i = 0; i < message.uninterpretedOption.length; ++i) - $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork()).ldelim(); + $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork(), q + 1).ldelim(); return writer; }; @@ -17633,12 +19288,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - EnumOptions.decode = function decode(reader, length) { + EnumOptions.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.EnumOptions(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 2: { message.allowAlias = reader.bool(); @@ -17653,17 +19314,17 @@ break; } case 7: { - message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32()); + message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32(), undefined, long + 1); break; } case 999: { if (!(message.uninterpretedOption && message.uninterpretedOption.length)) message.uninterpretedOption = []; - message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32())); + message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -17694,28 +19355,32 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - EnumOptions.verify = function verify(message) { + EnumOptions.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.allowAlias != null && message.hasOwnProperty("allowAlias")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.allowAlias != null && Object.hasOwnProperty.call(message, "allowAlias")) if (typeof message.allowAlias !== "boolean") return "allowAlias: boolean expected"; - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) if (typeof message.deprecated !== "boolean") return "deprecated: boolean expected"; - if (message.deprecatedLegacyJsonFieldConflicts != null && message.hasOwnProperty("deprecatedLegacyJsonFieldConflicts")) + if (message.deprecatedLegacyJsonFieldConflicts != null && Object.hasOwnProperty.call(message, "deprecatedLegacyJsonFieldConflicts")) if (typeof message.deprecatedLegacyJsonFieldConflicts !== "boolean") return "deprecatedLegacyJsonFieldConflicts: boolean expected"; - if (message.features != null && message.hasOwnProperty("features")) { - var error = $root.google.protobuf.FeatureSet.verify(message.features); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) { + var error = $root.google.protobuf.FeatureSet.verify(message.features, long + 1); if (error) return "features." + error; } - if (message.uninterpretedOption != null && message.hasOwnProperty("uninterpretedOption")) { + if (message.uninterpretedOption != null && Object.hasOwnProperty.call(message, "uninterpretedOption")) { if (!Array.isArray(message.uninterpretedOption)) return "uninterpretedOption: array expected"; for (var i = 0; i < message.uninterpretedOption.length; ++i) { - var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i]); + var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i], long + 1); if (error) return "uninterpretedOption." + error; } @@ -17731,9 +19396,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.EnumOptions} EnumOptions */ - EnumOptions.fromObject = function fromObject(object) { + EnumOptions.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.EnumOptions) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.EnumOptions: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.EnumOptions(); if (object.allowAlias != null) message.allowAlias = Boolean(object.allowAlias); @@ -17742,18 +19413,18 @@ if (object.deprecatedLegacyJsonFieldConflicts != null) message.deprecatedLegacyJsonFieldConflicts = Boolean(object.deprecatedLegacyJsonFieldConflicts); if (object.features != null) { - if (typeof object.features !== "object") + if (!$util.isObject(object.features)) throw TypeError(".google.protobuf.EnumOptions.features: object expected"); - message.features = $root.google.protobuf.FeatureSet.fromObject(object.features); + message.features = $root.google.protobuf.FeatureSet.fromObject(object.features, long + 1); } if (object.uninterpretedOption) { if (!Array.isArray(object.uninterpretedOption)) throw TypeError(".google.protobuf.EnumOptions.uninterpretedOption: array expected"); message.uninterpretedOption = []; for (var i = 0; i < object.uninterpretedOption.length; ++i) { - if (typeof object.uninterpretedOption[i] !== "object") + if (!$util.isObject(object.uninterpretedOption[i])) throw TypeError(".google.protobuf.EnumOptions.uninterpretedOption: object expected"); - message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i]); + message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i], long + 1); } } return message; @@ -17768,9 +19439,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - EnumOptions.toObject = function toObject(message, options) { + EnumOptions.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.uninterpretedOption = []; @@ -17780,18 +19455,18 @@ object.deprecatedLegacyJsonFieldConflicts = false; object.features = null; } - if (message.allowAlias != null && message.hasOwnProperty("allowAlias")) + if (message.allowAlias != null && Object.hasOwnProperty.call(message, "allowAlias")) object.allowAlias = message.allowAlias; - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) object.deprecated = message.deprecated; - if (message.deprecatedLegacyJsonFieldConflicts != null && message.hasOwnProperty("deprecatedLegacyJsonFieldConflicts")) + if (message.deprecatedLegacyJsonFieldConflicts != null && Object.hasOwnProperty.call(message, "deprecatedLegacyJsonFieldConflicts")) object.deprecatedLegacyJsonFieldConflicts = message.deprecatedLegacyJsonFieldConflicts; - if (message.features != null && message.hasOwnProperty("features")) - object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) + object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options, q + 1); if (message.uninterpretedOption && message.uninterpretedOption.length) { object.uninterpretedOption = []; for (var j = 0; j < message.uninterpretedOption.length; ++j) - object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options); + object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options, q + 1); } return object; }; @@ -17849,7 +19524,7 @@ this.uninterpretedOption = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -17906,18 +19581,22 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - EnumValueOptions.encode = function encode(message, writer) { + EnumValueOptions.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) writer.uint32(/* id 1, wireType 0 =*/8).bool(message.deprecated); if (message.features != null && Object.hasOwnProperty.call(message, "features")) - $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.debugRedact != null && Object.hasOwnProperty.call(message, "debugRedact")) writer.uint32(/* id 3, wireType 0 =*/24).bool(message.debugRedact); if (message.uninterpretedOption != null && message.uninterpretedOption.length) for (var i = 0; i < message.uninterpretedOption.length; ++i) - $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork()).ldelim(); + $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork(), q + 1).ldelim(); return writer; }; @@ -17945,19 +19624,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - EnumValueOptions.decode = function decode(reader, length) { + EnumValueOptions.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.EnumValueOptions(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.deprecated = reader.bool(); break; } case 2: { - message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32()); + message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32(), undefined, long + 1); break; } case 3: { @@ -17967,11 +19652,11 @@ case 999: { if (!(message.uninterpretedOption && message.uninterpretedOption.length)) message.uninterpretedOption = []; - message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32())); + message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -18002,25 +19687,29 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - EnumValueOptions.verify = function verify(message) { + EnumValueOptions.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) if (typeof message.deprecated !== "boolean") return "deprecated: boolean expected"; - if (message.features != null && message.hasOwnProperty("features")) { - var error = $root.google.protobuf.FeatureSet.verify(message.features); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) { + var error = $root.google.protobuf.FeatureSet.verify(message.features, long + 1); if (error) return "features." + error; } - if (message.debugRedact != null && message.hasOwnProperty("debugRedact")) + if (message.debugRedact != null && Object.hasOwnProperty.call(message, "debugRedact")) if (typeof message.debugRedact !== "boolean") return "debugRedact: boolean expected"; - if (message.uninterpretedOption != null && message.hasOwnProperty("uninterpretedOption")) { + if (message.uninterpretedOption != null && Object.hasOwnProperty.call(message, "uninterpretedOption")) { if (!Array.isArray(message.uninterpretedOption)) return "uninterpretedOption: array expected"; for (var i = 0; i < message.uninterpretedOption.length; ++i) { - var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i]); + var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i], long + 1); if (error) return "uninterpretedOption." + error; } @@ -18036,16 +19725,22 @@ * @param {Object.} object Plain object * @returns {google.protobuf.EnumValueOptions} EnumValueOptions */ - EnumValueOptions.fromObject = function fromObject(object) { + EnumValueOptions.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.EnumValueOptions) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.EnumValueOptions: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.EnumValueOptions(); if (object.deprecated != null) message.deprecated = Boolean(object.deprecated); if (object.features != null) { - if (typeof object.features !== "object") + if (!$util.isObject(object.features)) throw TypeError(".google.protobuf.EnumValueOptions.features: object expected"); - message.features = $root.google.protobuf.FeatureSet.fromObject(object.features); + message.features = $root.google.protobuf.FeatureSet.fromObject(object.features, long + 1); } if (object.debugRedact != null) message.debugRedact = Boolean(object.debugRedact); @@ -18054,9 +19749,9 @@ throw TypeError(".google.protobuf.EnumValueOptions.uninterpretedOption: array expected"); message.uninterpretedOption = []; for (var i = 0; i < object.uninterpretedOption.length; ++i) { - if (typeof object.uninterpretedOption[i] !== "object") + if (!$util.isObject(object.uninterpretedOption[i])) throw TypeError(".google.protobuf.EnumValueOptions.uninterpretedOption: object expected"); - message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i]); + message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i], long + 1); } } return message; @@ -18071,9 +19766,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - EnumValueOptions.toObject = function toObject(message, options) { + EnumValueOptions.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.uninterpretedOption = []; @@ -18082,16 +19781,16 @@ object.features = null; object.debugRedact = false; } - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) object.deprecated = message.deprecated; - if (message.features != null && message.hasOwnProperty("features")) - object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options); - if (message.debugRedact != null && message.hasOwnProperty("debugRedact")) + if (message.features != null && Object.hasOwnProperty.call(message, "features")) + object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options, q + 1); + if (message.debugRedact != null && Object.hasOwnProperty.call(message, "debugRedact")) object.debugRedact = message.debugRedact; if (message.uninterpretedOption && message.uninterpretedOption.length) { object.uninterpretedOption = []; for (var j = 0; j < message.uninterpretedOption.length; ++j) - object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options); + object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options, q + 1); } return object; }; @@ -18151,7 +19850,7 @@ this.uninterpretedOption = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -18224,16 +19923,20 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ServiceOptions.encode = function encode(message, writer) { + ServiceOptions.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) writer.uint32(/* id 33, wireType 0 =*/264).bool(message.deprecated); if (message.features != null && Object.hasOwnProperty.call(message, "features")) - $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 34, wireType 2 =*/274).fork()).ldelim(); + $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 34, wireType 2 =*/274).fork(), q + 1).ldelim(); if (message.uninterpretedOption != null && message.uninterpretedOption.length) for (var i = 0; i < message.uninterpretedOption.length; ++i) - $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork()).ldelim(); + $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork(), q + 1).ldelim(); if (message[".google.api.defaultHost"] != null && Object.hasOwnProperty.call(message, ".google.api.defaultHost")) writer.uint32(/* id 1049, wireType 2 =*/8394).string(message[".google.api.defaultHost"]); if (message[".google.api.oauthScopes"] != null && Object.hasOwnProperty.call(message, ".google.api.oauthScopes")) @@ -18267,15 +19970,21 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ServiceOptions.decode = function decode(reader, length) { + ServiceOptions.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.ServiceOptions(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 34: { - message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32()); + message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32(), undefined, long + 1); break; } case 33: { @@ -18285,7 +19994,7 @@ case 999: { if (!(message.uninterpretedOption && message.uninterpretedOption.length)) message.uninterpretedOption = []; - message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32())); + message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 1049: { @@ -18301,7 +20010,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -18332,33 +20041,37 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ServiceOptions.verify = function verify(message) { + ServiceOptions.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.features != null && message.hasOwnProperty("features")) { - var error = $root.google.protobuf.FeatureSet.verify(message.features); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.features != null && Object.hasOwnProperty.call(message, "features")) { + var error = $root.google.protobuf.FeatureSet.verify(message.features, long + 1); if (error) return "features." + error; } - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) if (typeof message.deprecated !== "boolean") return "deprecated: boolean expected"; - if (message.uninterpretedOption != null && message.hasOwnProperty("uninterpretedOption")) { + if (message.uninterpretedOption != null && Object.hasOwnProperty.call(message, "uninterpretedOption")) { if (!Array.isArray(message.uninterpretedOption)) return "uninterpretedOption: array expected"; for (var i = 0; i < message.uninterpretedOption.length; ++i) { - var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i]); + var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i], long + 1); if (error) return "uninterpretedOption." + error; } } - if (message[".google.api.defaultHost"] != null && message.hasOwnProperty(".google.api.defaultHost")) + if (message[".google.api.defaultHost"] != null && Object.hasOwnProperty.call(message, ".google.api.defaultHost")) if (!$util.isString(message[".google.api.defaultHost"])) return ".google.api.defaultHost: string expected"; - if (message[".google.api.oauthScopes"] != null && message.hasOwnProperty(".google.api.oauthScopes")) + if (message[".google.api.oauthScopes"] != null && Object.hasOwnProperty.call(message, ".google.api.oauthScopes")) if (!$util.isString(message[".google.api.oauthScopes"])) return ".google.api.oauthScopes: string expected"; - if (message[".google.api.apiVersion"] != null && message.hasOwnProperty(".google.api.apiVersion")) + if (message[".google.api.apiVersion"] != null && Object.hasOwnProperty.call(message, ".google.api.apiVersion")) if (!$util.isString(message[".google.api.apiVersion"])) return ".google.api.apiVersion: string expected"; return null; @@ -18372,14 +20085,20 @@ * @param {Object.} object Plain object * @returns {google.protobuf.ServiceOptions} ServiceOptions */ - ServiceOptions.fromObject = function fromObject(object) { + ServiceOptions.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.ServiceOptions) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.ServiceOptions: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.ServiceOptions(); if (object.features != null) { - if (typeof object.features !== "object") + if (!$util.isObject(object.features)) throw TypeError(".google.protobuf.ServiceOptions.features: object expected"); - message.features = $root.google.protobuf.FeatureSet.fromObject(object.features); + message.features = $root.google.protobuf.FeatureSet.fromObject(object.features, long + 1); } if (object.deprecated != null) message.deprecated = Boolean(object.deprecated); @@ -18388,9 +20107,9 @@ throw TypeError(".google.protobuf.ServiceOptions.uninterpretedOption: array expected"); message.uninterpretedOption = []; for (var i = 0; i < object.uninterpretedOption.length; ++i) { - if (typeof object.uninterpretedOption[i] !== "object") + if (!$util.isObject(object.uninterpretedOption[i])) throw TypeError(".google.protobuf.ServiceOptions.uninterpretedOption: object expected"); - message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i]); + message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i], long + 1); } } if (object[".google.api.defaultHost"] != null) @@ -18411,9 +20130,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ServiceOptions.toObject = function toObject(message, options) { + ServiceOptions.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.uninterpretedOption = []; @@ -18424,20 +20147,20 @@ object[".google.api.oauthScopes"] = ""; object[".google.api.apiVersion"] = ""; } - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) object.deprecated = message.deprecated; - if (message.features != null && message.hasOwnProperty("features")) - object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) + object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options, q + 1); if (message.uninterpretedOption && message.uninterpretedOption.length) { object.uninterpretedOption = []; for (var j = 0; j < message.uninterpretedOption.length; ++j) - object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options); + object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options, q + 1); } - if (message[".google.api.defaultHost"] != null && message.hasOwnProperty(".google.api.defaultHost")) + if (message[".google.api.defaultHost"] != null && Object.hasOwnProperty.call(message, ".google.api.defaultHost")) object[".google.api.defaultHost"] = message[".google.api.defaultHost"]; - if (message[".google.api.oauthScopes"] != null && message.hasOwnProperty(".google.api.oauthScopes")) + if (message[".google.api.oauthScopes"] != null && Object.hasOwnProperty.call(message, ".google.api.oauthScopes")) object[".google.api.oauthScopes"] = message[".google.api.oauthScopes"]; - if (message[".google.api.apiVersion"] != null && message.hasOwnProperty(".google.api.apiVersion")) + if (message[".google.api.apiVersion"] != null && Object.hasOwnProperty.call(message, ".google.api.apiVersion")) object[".google.api.apiVersion"] = message[".google.api.apiVersion"]; return object; }; @@ -18482,6 +20205,7 @@ * @property {google.protobuf.IFeatureSet|null} [features] MethodOptions features * @property {Array.|null} [uninterpretedOption] MethodOptions uninterpretedOption * @property {google.api.IHttpRule|null} [".google.api.http"] MethodOptions .google.api.http + * @property {google.api.IMediaUpload|null} [".google.api.mediaUpload"] MethodOptions .google.api.mediaUpload * @property {google.api.IRoutingRule|null} [".google.api.routing"] MethodOptions .google.api.routing * @property {Array.|null} [".google.api.methodSignature"] MethodOptions .google.api.methodSignature * @property {google.longrunning.IOperationInfo|null} [".google.longrunning.operationInfo"] MethodOptions .google.longrunning.operationInfo @@ -18500,7 +20224,7 @@ this[".google.api.methodSignature"] = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -18544,6 +20268,14 @@ */ MethodOptions.prototype[".google.api.http"] = null; + /** + * MethodOptions .google.api.mediaUpload. + * @member {google.api.IMediaUpload|null|undefined} .google.api.mediaUpload + * @memberof google.protobuf.MethodOptions + * @instance + */ + MethodOptions.prototype[".google.api.mediaUpload"] = null; + /** * MethodOptions .google.api.routing. * @member {google.api.IRoutingRule|null|undefined} .google.api.routing @@ -18589,27 +20321,33 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - MethodOptions.encode = function encode(message, writer) { + MethodOptions.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) writer.uint32(/* id 33, wireType 0 =*/264).bool(message.deprecated); if (message.idempotencyLevel != null && Object.hasOwnProperty.call(message, "idempotencyLevel")) writer.uint32(/* id 34, wireType 0 =*/272).int32(message.idempotencyLevel); if (message.features != null && Object.hasOwnProperty.call(message, "features")) - $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 35, wireType 2 =*/282).fork()).ldelim(); + $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 35, wireType 2 =*/282).fork(), q + 1).ldelim(); if (message.uninterpretedOption != null && message.uninterpretedOption.length) for (var i = 0; i < message.uninterpretedOption.length; ++i) - $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork()).ldelim(); + $root.google.protobuf.UninterpretedOption.encode(message.uninterpretedOption[i], writer.uint32(/* id 999, wireType 2 =*/7994).fork(), q + 1).ldelim(); if (message[".google.longrunning.operationInfo"] != null && Object.hasOwnProperty.call(message, ".google.longrunning.operationInfo")) - $root.google.longrunning.OperationInfo.encode(message[".google.longrunning.operationInfo"], writer.uint32(/* id 1049, wireType 2 =*/8394).fork()).ldelim(); + $root.google.longrunning.OperationInfo.encode(message[".google.longrunning.operationInfo"], writer.uint32(/* id 1049, wireType 2 =*/8394).fork(), q + 1).ldelim(); if (message[".google.api.methodSignature"] != null && message[".google.api.methodSignature"].length) for (var i = 0; i < message[".google.api.methodSignature"].length; ++i) writer.uint32(/* id 1051, wireType 2 =*/8410).string(message[".google.api.methodSignature"][i]); + if (message[".google.api.mediaUpload"] != null && Object.hasOwnProperty.call(message, ".google.api.mediaUpload")) + $root.google.api.MediaUpload.encode(message[".google.api.mediaUpload"], writer.uint32(/* id 1052, wireType 2 =*/8418).fork(), q + 1).ldelim(); if (message[".google.api.http"] != null && Object.hasOwnProperty.call(message, ".google.api.http")) - $root.google.api.HttpRule.encode(message[".google.api.http"], writer.uint32(/* id 72295728, wireType 2 =*/578365826).fork()).ldelim(); + $root.google.api.HttpRule.encode(message[".google.api.http"], writer.uint32(/* id 72295728, wireType 2 =*/578365826).fork(), q + 1).ldelim(); if (message[".google.api.routing"] != null && Object.hasOwnProperty.call(message, ".google.api.routing")) - $root.google.api.RoutingRule.encode(message[".google.api.routing"], writer.uint32(/* id 72295729, wireType 2 =*/578365834).fork()).ldelim(); + $root.google.api.RoutingRule.encode(message[".google.api.routing"], writer.uint32(/* id 72295729, wireType 2 =*/578365834).fork(), q + 1).ldelim(); return writer; }; @@ -18637,12 +20375,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - MethodOptions.decode = function decode(reader, length) { + MethodOptions.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.MethodOptions(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 33: { message.deprecated = reader.bool(); @@ -18653,21 +20397,25 @@ break; } case 35: { - message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32()); + message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32(), undefined, long + 1); break; } case 999: { if (!(message.uninterpretedOption && message.uninterpretedOption.length)) message.uninterpretedOption = []; - message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32())); + message.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 72295728: { - message[".google.api.http"] = $root.google.api.HttpRule.decode(reader, reader.uint32()); + message[".google.api.http"] = $root.google.api.HttpRule.decode(reader, reader.uint32(), undefined, long + 1); + break; + } + case 1052: { + message[".google.api.mediaUpload"] = $root.google.api.MediaUpload.decode(reader, reader.uint32(), undefined, long + 1); break; } case 72295729: { - message[".google.api.routing"] = $root.google.api.RoutingRule.decode(reader, reader.uint32()); + message[".google.api.routing"] = $root.google.api.RoutingRule.decode(reader, reader.uint32(), undefined, long + 1); break; } case 1051: { @@ -18677,11 +20425,11 @@ break; } case 1049: { - message[".google.longrunning.operationInfo"] = $root.google.longrunning.OperationInfo.decode(reader, reader.uint32()); + message[".google.longrunning.operationInfo"] = $root.google.longrunning.OperationInfo.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -18712,13 +20460,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - MethodOptions.verify = function verify(message) { + MethodOptions.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) if (typeof message.deprecated !== "boolean") return "deprecated: boolean expected"; - if (message.idempotencyLevel != null && message.hasOwnProperty("idempotencyLevel")) + if (message.idempotencyLevel != null && Object.hasOwnProperty.call(message, "idempotencyLevel")) switch (message.idempotencyLevel) { default: return "idempotencyLevel: enum value expected"; @@ -18727,39 +20479,44 @@ case 2: break; } - if (message.features != null && message.hasOwnProperty("features")) { - var error = $root.google.protobuf.FeatureSet.verify(message.features); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) { + var error = $root.google.protobuf.FeatureSet.verify(message.features, long + 1); if (error) return "features." + error; } - if (message.uninterpretedOption != null && message.hasOwnProperty("uninterpretedOption")) { + if (message.uninterpretedOption != null && Object.hasOwnProperty.call(message, "uninterpretedOption")) { if (!Array.isArray(message.uninterpretedOption)) return "uninterpretedOption: array expected"; for (var i = 0; i < message.uninterpretedOption.length; ++i) { - var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i]); + var error = $root.google.protobuf.UninterpretedOption.verify(message.uninterpretedOption[i], long + 1); if (error) return "uninterpretedOption." + error; } } - if (message[".google.api.http"] != null && message.hasOwnProperty(".google.api.http")) { - var error = $root.google.api.HttpRule.verify(message[".google.api.http"]); + if (message[".google.api.http"] != null && Object.hasOwnProperty.call(message, ".google.api.http")) { + var error = $root.google.api.HttpRule.verify(message[".google.api.http"], long + 1); if (error) return ".google.api.http." + error; } - if (message[".google.api.routing"] != null && message.hasOwnProperty(".google.api.routing")) { - var error = $root.google.api.RoutingRule.verify(message[".google.api.routing"]); + if (message[".google.api.mediaUpload"] != null && Object.hasOwnProperty.call(message, ".google.api.mediaUpload")) { + var error = $root.google.api.MediaUpload.verify(message[".google.api.mediaUpload"], long + 1); + if (error) + return ".google.api.mediaUpload." + error; + } + if (message[".google.api.routing"] != null && Object.hasOwnProperty.call(message, ".google.api.routing")) { + var error = $root.google.api.RoutingRule.verify(message[".google.api.routing"], long + 1); if (error) return ".google.api.routing." + error; } - if (message[".google.api.methodSignature"] != null && message.hasOwnProperty(".google.api.methodSignature")) { + if (message[".google.api.methodSignature"] != null && Object.hasOwnProperty.call(message, ".google.api.methodSignature")) { if (!Array.isArray(message[".google.api.methodSignature"])) return ".google.api.methodSignature: array expected"; for (var i = 0; i < message[".google.api.methodSignature"].length; ++i) if (!$util.isString(message[".google.api.methodSignature"][i])) return ".google.api.methodSignature: string[] expected"; } - if (message[".google.longrunning.operationInfo"] != null && message.hasOwnProperty(".google.longrunning.operationInfo")) { - var error = $root.google.longrunning.OperationInfo.verify(message[".google.longrunning.operationInfo"]); + if (message[".google.longrunning.operationInfo"] != null && Object.hasOwnProperty.call(message, ".google.longrunning.operationInfo")) { + var error = $root.google.longrunning.OperationInfo.verify(message[".google.longrunning.operationInfo"], long + 1); if (error) return ".google.longrunning.operationInfo." + error; } @@ -18774,9 +20531,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.MethodOptions} MethodOptions */ - MethodOptions.fromObject = function fromObject(object) { + MethodOptions.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.MethodOptions) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.MethodOptions: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.MethodOptions(); if (object.deprecated != null) message.deprecated = Boolean(object.deprecated); @@ -18801,29 +20564,34 @@ break; } if (object.features != null) { - if (typeof object.features !== "object") + if (!$util.isObject(object.features)) throw TypeError(".google.protobuf.MethodOptions.features: object expected"); - message.features = $root.google.protobuf.FeatureSet.fromObject(object.features); + message.features = $root.google.protobuf.FeatureSet.fromObject(object.features, long + 1); } if (object.uninterpretedOption) { if (!Array.isArray(object.uninterpretedOption)) throw TypeError(".google.protobuf.MethodOptions.uninterpretedOption: array expected"); message.uninterpretedOption = []; for (var i = 0; i < object.uninterpretedOption.length; ++i) { - if (typeof object.uninterpretedOption[i] !== "object") + if (!$util.isObject(object.uninterpretedOption[i])) throw TypeError(".google.protobuf.MethodOptions.uninterpretedOption: object expected"); - message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i]); + message.uninterpretedOption[i] = $root.google.protobuf.UninterpretedOption.fromObject(object.uninterpretedOption[i], long + 1); } } if (object[".google.api.http"] != null) { - if (typeof object[".google.api.http"] !== "object") + if (!$util.isObject(object[".google.api.http"])) throw TypeError(".google.protobuf.MethodOptions..google.api.http: object expected"); - message[".google.api.http"] = $root.google.api.HttpRule.fromObject(object[".google.api.http"]); + message[".google.api.http"] = $root.google.api.HttpRule.fromObject(object[".google.api.http"], long + 1); + } + if (object[".google.api.mediaUpload"] != null) { + if (!$util.isObject(object[".google.api.mediaUpload"])) + throw TypeError(".google.protobuf.MethodOptions..google.api.mediaUpload: object expected"); + message[".google.api.mediaUpload"] = $root.google.api.MediaUpload.fromObject(object[".google.api.mediaUpload"], long + 1); } if (object[".google.api.routing"] != null) { - if (typeof object[".google.api.routing"] !== "object") + if (!$util.isObject(object[".google.api.routing"])) throw TypeError(".google.protobuf.MethodOptions..google.api.routing: object expected"); - message[".google.api.routing"] = $root.google.api.RoutingRule.fromObject(object[".google.api.routing"]); + message[".google.api.routing"] = $root.google.api.RoutingRule.fromObject(object[".google.api.routing"], long + 1); } if (object[".google.api.methodSignature"]) { if (!Array.isArray(object[".google.api.methodSignature"])) @@ -18833,9 +20601,9 @@ message[".google.api.methodSignature"][i] = String(object[".google.api.methodSignature"][i]); } if (object[".google.longrunning.operationInfo"] != null) { - if (typeof object[".google.longrunning.operationInfo"] !== "object") + if (!$util.isObject(object[".google.longrunning.operationInfo"])) throw TypeError(".google.protobuf.MethodOptions..google.longrunning.operationInfo: object expected"); - message[".google.longrunning.operationInfo"] = $root.google.longrunning.OperationInfo.fromObject(object[".google.longrunning.operationInfo"]); + message[".google.longrunning.operationInfo"] = $root.google.longrunning.OperationInfo.fromObject(object[".google.longrunning.operationInfo"], long + 1); } return message; }; @@ -18849,9 +20617,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - MethodOptions.toObject = function toObject(message, options) { + MethodOptions.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.uninterpretedOption = []; @@ -18862,31 +20634,34 @@ object.idempotencyLevel = options.enums === String ? "IDEMPOTENCY_UNKNOWN" : 0; object.features = null; object[".google.longrunning.operationInfo"] = null; + object[".google.api.mediaUpload"] = null; object[".google.api.http"] = null; object[".google.api.routing"] = null; } - if (message.deprecated != null && message.hasOwnProperty("deprecated")) + if (message.deprecated != null && Object.hasOwnProperty.call(message, "deprecated")) object.deprecated = message.deprecated; - if (message.idempotencyLevel != null && message.hasOwnProperty("idempotencyLevel")) + if (message.idempotencyLevel != null && Object.hasOwnProperty.call(message, "idempotencyLevel")) object.idempotencyLevel = options.enums === String ? $root.google.protobuf.MethodOptions.IdempotencyLevel[message.idempotencyLevel] === undefined ? message.idempotencyLevel : $root.google.protobuf.MethodOptions.IdempotencyLevel[message.idempotencyLevel] : message.idempotencyLevel; - if (message.features != null && message.hasOwnProperty("features")) - object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) + object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options, q + 1); if (message.uninterpretedOption && message.uninterpretedOption.length) { object.uninterpretedOption = []; for (var j = 0; j < message.uninterpretedOption.length; ++j) - object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options); + object.uninterpretedOption[j] = $root.google.protobuf.UninterpretedOption.toObject(message.uninterpretedOption[j], options, q + 1); } - if (message[".google.longrunning.operationInfo"] != null && message.hasOwnProperty(".google.longrunning.operationInfo")) - object[".google.longrunning.operationInfo"] = $root.google.longrunning.OperationInfo.toObject(message[".google.longrunning.operationInfo"], options); + if (message[".google.longrunning.operationInfo"] != null && Object.hasOwnProperty.call(message, ".google.longrunning.operationInfo")) + object[".google.longrunning.operationInfo"] = $root.google.longrunning.OperationInfo.toObject(message[".google.longrunning.operationInfo"], options, q + 1); if (message[".google.api.methodSignature"] && message[".google.api.methodSignature"].length) { object[".google.api.methodSignature"] = []; for (var j = 0; j < message[".google.api.methodSignature"].length; ++j) object[".google.api.methodSignature"][j] = message[".google.api.methodSignature"][j]; } - if (message[".google.api.http"] != null && message.hasOwnProperty(".google.api.http")) - object[".google.api.http"] = $root.google.api.HttpRule.toObject(message[".google.api.http"], options); - if (message[".google.api.routing"] != null && message.hasOwnProperty(".google.api.routing")) - object[".google.api.routing"] = $root.google.api.RoutingRule.toObject(message[".google.api.routing"], options); + if (message[".google.api.mediaUpload"] != null && Object.hasOwnProperty.call(message, ".google.api.mediaUpload")) + object[".google.api.mediaUpload"] = $root.google.api.MediaUpload.toObject(message[".google.api.mediaUpload"], options, q + 1); + if (message[".google.api.http"] != null && Object.hasOwnProperty.call(message, ".google.api.http")) + object[".google.api.http"] = $root.google.api.HttpRule.toObject(message[".google.api.http"], options, q + 1); + if (message[".google.api.routing"] != null && Object.hasOwnProperty.call(message, ".google.api.routing")) + object[".google.api.routing"] = $root.google.api.RoutingRule.toObject(message[".google.api.routing"], options, q + 1); return object; }; @@ -18962,7 +20737,7 @@ this.name = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -19043,12 +20818,16 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - UninterpretedOption.encode = function encode(message, writer) { + UninterpretedOption.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && message.name.length) for (var i = 0; i < message.name.length; ++i) - $root.google.protobuf.UninterpretedOption.NamePart.encode(message.name[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.UninterpretedOption.NamePart.encode(message.name[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.identifierValue != null && Object.hasOwnProperty.call(message, "identifierValue")) writer.uint32(/* id 3, wireType 2 =*/26).string(message.identifierValue); if (message.positiveIntValue != null && Object.hasOwnProperty.call(message, "positiveIntValue")) @@ -19088,17 +20867,23 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - UninterpretedOption.decode = function decode(reader, length) { + UninterpretedOption.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.UninterpretedOption(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 2: { if (!(message.name && message.name.length)) message.name = []; - message.name.push($root.google.protobuf.UninterpretedOption.NamePart.decode(reader, reader.uint32())); + message.name.push($root.google.protobuf.UninterpretedOption.NamePart.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 3: { @@ -19126,7 +20911,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -19157,34 +20942,38 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - UninterpretedOption.verify = function verify(message) { + UninterpretedOption.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) { if (!Array.isArray(message.name)) return "name: array expected"; for (var i = 0; i < message.name.length; ++i) { - var error = $root.google.protobuf.UninterpretedOption.NamePart.verify(message.name[i]); + var error = $root.google.protobuf.UninterpretedOption.NamePart.verify(message.name[i], long + 1); if (error) return "name." + error; } } - if (message.identifierValue != null && message.hasOwnProperty("identifierValue")) + if (message.identifierValue != null && Object.hasOwnProperty.call(message, "identifierValue")) if (!$util.isString(message.identifierValue)) return "identifierValue: string expected"; - if (message.positiveIntValue != null && message.hasOwnProperty("positiveIntValue")) + if (message.positiveIntValue != null && Object.hasOwnProperty.call(message, "positiveIntValue")) if (!$util.isInteger(message.positiveIntValue) && !(message.positiveIntValue && $util.isInteger(message.positiveIntValue.low) && $util.isInteger(message.positiveIntValue.high))) return "positiveIntValue: integer|Long expected"; - if (message.negativeIntValue != null && message.hasOwnProperty("negativeIntValue")) + if (message.negativeIntValue != null && Object.hasOwnProperty.call(message, "negativeIntValue")) if (!$util.isInteger(message.negativeIntValue) && !(message.negativeIntValue && $util.isInteger(message.negativeIntValue.low) && $util.isInteger(message.negativeIntValue.high))) return "negativeIntValue: integer|Long expected"; - if (message.doubleValue != null && message.hasOwnProperty("doubleValue")) + if (message.doubleValue != null && Object.hasOwnProperty.call(message, "doubleValue")) if (typeof message.doubleValue !== "number") return "doubleValue: number expected"; - if (message.stringValue != null && message.hasOwnProperty("stringValue")) + if (message.stringValue != null && Object.hasOwnProperty.call(message, "stringValue")) if (!(message.stringValue && typeof message.stringValue.length === "number" || $util.isString(message.stringValue))) return "stringValue: buffer expected"; - if (message.aggregateValue != null && message.hasOwnProperty("aggregateValue")) + if (message.aggregateValue != null && Object.hasOwnProperty.call(message, "aggregateValue")) if (!$util.isString(message.aggregateValue)) return "aggregateValue: string expected"; return null; @@ -19198,25 +20987,31 @@ * @param {Object.} object Plain object * @returns {google.protobuf.UninterpretedOption} UninterpretedOption */ - UninterpretedOption.fromObject = function fromObject(object) { + UninterpretedOption.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.UninterpretedOption) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.UninterpretedOption: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.UninterpretedOption(); if (object.name) { if (!Array.isArray(object.name)) throw TypeError(".google.protobuf.UninterpretedOption.name: array expected"); message.name = []; for (var i = 0; i < object.name.length; ++i) { - if (typeof object.name[i] !== "object") + if (!$util.isObject(object.name[i])) throw TypeError(".google.protobuf.UninterpretedOption.name: object expected"); - message.name[i] = $root.google.protobuf.UninterpretedOption.NamePart.fromObject(object.name[i]); + message.name[i] = $root.google.protobuf.UninterpretedOption.NamePart.fromObject(object.name[i], long + 1); } } if (object.identifierValue != null) message.identifierValue = String(object.identifierValue); if (object.positiveIntValue != null) if ($util.Long) - (message.positiveIntValue = $util.Long.fromValue(object.positiveIntValue)).unsigned = true; + message.positiveIntValue = $util.Long.fromValue(object.positiveIntValue, true); else if (typeof object.positiveIntValue === "string") message.positiveIntValue = parseInt(object.positiveIntValue, 10); else if (typeof object.positiveIntValue === "number") @@ -19225,7 +21020,7 @@ message.positiveIntValue = new $util.LongBits(object.positiveIntValue.low >>> 0, object.positiveIntValue.high >>> 0).toNumber(true); if (object.negativeIntValue != null) if ($util.Long) - (message.negativeIntValue = $util.Long.fromValue(object.negativeIntValue)).unsigned = false; + message.negativeIntValue = $util.Long.fromValue(object.negativeIntValue, false); else if (typeof object.negativeIntValue === "string") message.negativeIntValue = parseInt(object.negativeIntValue, 10); else if (typeof object.negativeIntValue === "number") @@ -19253,9 +21048,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - UninterpretedOption.toObject = function toObject(message, options) { + UninterpretedOption.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.name = []; @@ -19263,14 +21062,14 @@ object.identifierValue = ""; if ($util.Long) { var long = new $util.Long(0, 0, true); - object.positiveIntValue = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + object.positiveIntValue = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : typeof BigInt !== "undefined" && options.longs === BigInt ? long.toBigInt() : long; } else - object.positiveIntValue = options.longs === String ? "0" : 0; + object.positiveIntValue = options.longs === String ? "0" : typeof BigInt !== "undefined" && options.longs === BigInt ? BigInt("0") : 0; if ($util.Long) { var long = new $util.Long(0, 0, false); - object.negativeIntValue = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + object.negativeIntValue = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : typeof BigInt !== "undefined" && options.longs === BigInt ? long.toBigInt() : long; } else - object.negativeIntValue = options.longs === String ? "0" : 0; + object.negativeIntValue = options.longs === String ? "0" : typeof BigInt !== "undefined" && options.longs === BigInt ? BigInt("0") : 0; object.doubleValue = 0; if (options.bytes === String) object.stringValue = ""; @@ -19284,25 +21083,29 @@ if (message.name && message.name.length) { object.name = []; for (var j = 0; j < message.name.length; ++j) - object.name[j] = $root.google.protobuf.UninterpretedOption.NamePart.toObject(message.name[j], options); + object.name[j] = $root.google.protobuf.UninterpretedOption.NamePart.toObject(message.name[j], options, q + 1); } - if (message.identifierValue != null && message.hasOwnProperty("identifierValue")) + if (message.identifierValue != null && Object.hasOwnProperty.call(message, "identifierValue")) object.identifierValue = message.identifierValue; - if (message.positiveIntValue != null && message.hasOwnProperty("positiveIntValue")) - if (typeof message.positiveIntValue === "number") + if (message.positiveIntValue != null && Object.hasOwnProperty.call(message, "positiveIntValue")) + if (typeof BigInt !== "undefined" && options.longs === BigInt) + object.positiveIntValue = typeof message.positiveIntValue === "number" ? BigInt(message.positiveIntValue) : $util.Long.fromBits(message.positiveIntValue.low >>> 0, message.positiveIntValue.high >>> 0, true).toBigInt(); + else if (typeof message.positiveIntValue === "number") object.positiveIntValue = options.longs === String ? String(message.positiveIntValue) : message.positiveIntValue; else object.positiveIntValue = options.longs === String ? $util.Long.prototype.toString.call(message.positiveIntValue) : options.longs === Number ? new $util.LongBits(message.positiveIntValue.low >>> 0, message.positiveIntValue.high >>> 0).toNumber(true) : message.positiveIntValue; - if (message.negativeIntValue != null && message.hasOwnProperty("negativeIntValue")) - if (typeof message.negativeIntValue === "number") + if (message.negativeIntValue != null && Object.hasOwnProperty.call(message, "negativeIntValue")) + if (typeof BigInt !== "undefined" && options.longs === BigInt) + object.negativeIntValue = typeof message.negativeIntValue === "number" ? BigInt(message.negativeIntValue) : $util.Long.fromBits(message.negativeIntValue.low >>> 0, message.negativeIntValue.high >>> 0, false).toBigInt(); + else if (typeof message.negativeIntValue === "number") object.negativeIntValue = options.longs === String ? String(message.negativeIntValue) : message.negativeIntValue; else object.negativeIntValue = options.longs === String ? $util.Long.prototype.toString.call(message.negativeIntValue) : options.longs === Number ? new $util.LongBits(message.negativeIntValue.low >>> 0, message.negativeIntValue.high >>> 0).toNumber() : message.negativeIntValue; - if (message.doubleValue != null && message.hasOwnProperty("doubleValue")) + if (message.doubleValue != null && Object.hasOwnProperty.call(message, "doubleValue")) object.doubleValue = options.json && !isFinite(message.doubleValue) ? String(message.doubleValue) : message.doubleValue; - if (message.stringValue != null && message.hasOwnProperty("stringValue")) + if (message.stringValue != null && Object.hasOwnProperty.call(message, "stringValue")) object.stringValue = options.bytes === String ? $util.base64.encode(message.stringValue, 0, message.stringValue.length) : options.bytes === Array ? Array.prototype.slice.call(message.stringValue) : message.stringValue; - if (message.aggregateValue != null && message.hasOwnProperty("aggregateValue")) + if (message.aggregateValue != null && Object.hasOwnProperty.call(message, "aggregateValue")) object.aggregateValue = message.aggregateValue; return object; }; @@ -19354,7 +21157,7 @@ function NamePart(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -19395,9 +21198,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - NamePart.encode = function encode(message, writer) { + NamePart.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); writer.uint32(/* id 1, wireType 2 =*/10).string(message.namePart); writer.uint32(/* id 2, wireType 0 =*/16).bool(message.isExtension); return writer; @@ -19427,12 +21234,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - NamePart.decode = function decode(reader, length) { + NamePart.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.UninterpretedOption.NamePart(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.namePart = reader.string(); @@ -19443,13 +21256,13 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } - if (!message.hasOwnProperty("namePart")) + if (!Object.hasOwnProperty.call(message, "namePart")) throw $util.ProtocolError("missing required 'namePart'", { instance: message }); - if (!message.hasOwnProperty("isExtension")) + if (!Object.hasOwnProperty.call(message, "isExtension")) throw $util.ProtocolError("missing required 'isExtension'", { instance: message }); return message; }; @@ -19478,9 +21291,13 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - NamePart.verify = function verify(message) { + NamePart.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; if (!$util.isString(message.namePart)) return "namePart: string expected"; if (typeof message.isExtension !== "boolean") @@ -19496,9 +21313,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.UninterpretedOption.NamePart} NamePart */ - NamePart.fromObject = function fromObject(object) { + NamePart.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.UninterpretedOption.NamePart) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.UninterpretedOption.NamePart: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.UninterpretedOption.NamePart(); if (object.namePart != null) message.namePart = String(object.namePart); @@ -19516,17 +21339,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - NamePart.toObject = function toObject(message, options) { + NamePart.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.namePart = ""; object.isExtension = false; } - if (message.namePart != null && message.hasOwnProperty("namePart")) + if (message.namePart != null && Object.hasOwnProperty.call(message, "namePart")) object.namePart = message.namePart; - if (message.isExtension != null && message.hasOwnProperty("isExtension")) + if (message.isExtension != null && Object.hasOwnProperty.call(message, "isExtension")) object.isExtension = message.isExtension; return object; }; @@ -19588,7 +21415,7 @@ function FeatureSet(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -19661,9 +21488,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - FeatureSet.encode = function encode(message, writer) { + FeatureSet.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.fieldPresence != null && Object.hasOwnProperty.call(message, "fieldPresence")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.fieldPresence); if (message.enumType != null && Object.hasOwnProperty.call(message, "enumType")) @@ -19703,12 +21534,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - FeatureSet.decode = function decode(reader, length) { + FeatureSet.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FeatureSet(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.fieldPresence = reader.int32(); @@ -19735,7 +21572,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -19766,10 +21603,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - FeatureSet.verify = function verify(message) { + FeatureSet.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.fieldPresence != null && message.hasOwnProperty("fieldPresence")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.fieldPresence != null && Object.hasOwnProperty.call(message, "fieldPresence")) switch (message.fieldPresence) { default: return "fieldPresence: enum value expected"; @@ -19779,7 +21620,7 @@ case 3: break; } - if (message.enumType != null && message.hasOwnProperty("enumType")) + if (message.enumType != null && Object.hasOwnProperty.call(message, "enumType")) switch (message.enumType) { default: return "enumType: enum value expected"; @@ -19788,7 +21629,7 @@ case 2: break; } - if (message.repeatedFieldEncoding != null && message.hasOwnProperty("repeatedFieldEncoding")) + if (message.repeatedFieldEncoding != null && Object.hasOwnProperty.call(message, "repeatedFieldEncoding")) switch (message.repeatedFieldEncoding) { default: return "repeatedFieldEncoding: enum value expected"; @@ -19797,7 +21638,7 @@ case 2: break; } - if (message.utf8Validation != null && message.hasOwnProperty("utf8Validation")) + if (message.utf8Validation != null && Object.hasOwnProperty.call(message, "utf8Validation")) switch (message.utf8Validation) { default: return "utf8Validation: enum value expected"; @@ -19806,7 +21647,7 @@ case 3: break; } - if (message.messageEncoding != null && message.hasOwnProperty("messageEncoding")) + if (message.messageEncoding != null && Object.hasOwnProperty.call(message, "messageEncoding")) switch (message.messageEncoding) { default: return "messageEncoding: enum value expected"; @@ -19815,7 +21656,7 @@ case 2: break; } - if (message.jsonFormat != null && message.hasOwnProperty("jsonFormat")) + if (message.jsonFormat != null && Object.hasOwnProperty.call(message, "jsonFormat")) switch (message.jsonFormat) { default: return "jsonFormat: enum value expected"; @@ -19835,9 +21676,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.FeatureSet} FeatureSet */ - FeatureSet.fromObject = function fromObject(object) { + FeatureSet.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.FeatureSet) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.FeatureSet: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.FeatureSet(); switch (object.fieldPresence) { default: @@ -19975,9 +21822,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - FeatureSet.toObject = function toObject(message, options) { + FeatureSet.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.fieldPresence = options.enums === String ? "FIELD_PRESENCE_UNKNOWN" : 0; @@ -19987,17 +21838,17 @@ object.messageEncoding = options.enums === String ? "MESSAGE_ENCODING_UNKNOWN" : 0; object.jsonFormat = options.enums === String ? "JSON_FORMAT_UNKNOWN" : 0; } - if (message.fieldPresence != null && message.hasOwnProperty("fieldPresence")) + if (message.fieldPresence != null && Object.hasOwnProperty.call(message, "fieldPresence")) object.fieldPresence = options.enums === String ? $root.google.protobuf.FeatureSet.FieldPresence[message.fieldPresence] === undefined ? message.fieldPresence : $root.google.protobuf.FeatureSet.FieldPresence[message.fieldPresence] : message.fieldPresence; - if (message.enumType != null && message.hasOwnProperty("enumType")) + if (message.enumType != null && Object.hasOwnProperty.call(message, "enumType")) object.enumType = options.enums === String ? $root.google.protobuf.FeatureSet.EnumType[message.enumType] === undefined ? message.enumType : $root.google.protobuf.FeatureSet.EnumType[message.enumType] : message.enumType; - if (message.repeatedFieldEncoding != null && message.hasOwnProperty("repeatedFieldEncoding")) + if (message.repeatedFieldEncoding != null && Object.hasOwnProperty.call(message, "repeatedFieldEncoding")) object.repeatedFieldEncoding = options.enums === String ? $root.google.protobuf.FeatureSet.RepeatedFieldEncoding[message.repeatedFieldEncoding] === undefined ? message.repeatedFieldEncoding : $root.google.protobuf.FeatureSet.RepeatedFieldEncoding[message.repeatedFieldEncoding] : message.repeatedFieldEncoding; - if (message.utf8Validation != null && message.hasOwnProperty("utf8Validation")) + if (message.utf8Validation != null && Object.hasOwnProperty.call(message, "utf8Validation")) object.utf8Validation = options.enums === String ? $root.google.protobuf.FeatureSet.Utf8Validation[message.utf8Validation] === undefined ? message.utf8Validation : $root.google.protobuf.FeatureSet.Utf8Validation[message.utf8Validation] : message.utf8Validation; - if (message.messageEncoding != null && message.hasOwnProperty("messageEncoding")) + if (message.messageEncoding != null && Object.hasOwnProperty.call(message, "messageEncoding")) object.messageEncoding = options.enums === String ? $root.google.protobuf.FeatureSet.MessageEncoding[message.messageEncoding] === undefined ? message.messageEncoding : $root.google.protobuf.FeatureSet.MessageEncoding[message.messageEncoding] : message.messageEncoding; - if (message.jsonFormat != null && message.hasOwnProperty("jsonFormat")) + if (message.jsonFormat != null && Object.hasOwnProperty.call(message, "jsonFormat")) object.jsonFormat = options.enums === String ? $root.google.protobuf.FeatureSet.JsonFormat[message.jsonFormat] === undefined ? message.jsonFormat : $root.google.protobuf.FeatureSet.JsonFormat[message.jsonFormat] : message.jsonFormat; return object; }; @@ -20152,7 +22003,7 @@ this.defaults = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -20201,12 +22052,16 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - FeatureSetDefaults.encode = function encode(message, writer) { + FeatureSetDefaults.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.defaults != null && message.defaults.length) for (var i = 0; i < message.defaults.length; ++i) - $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.encode(message.defaults[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.encode(message.defaults[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); if (message.minimumEdition != null && Object.hasOwnProperty.call(message, "minimumEdition")) writer.uint32(/* id 4, wireType 0 =*/32).int32(message.minimumEdition); if (message.maximumEdition != null && Object.hasOwnProperty.call(message, "maximumEdition")) @@ -20238,17 +22093,23 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - FeatureSetDefaults.decode = function decode(reader, length) { + FeatureSetDefaults.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FeatureSetDefaults(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.defaults && message.defaults.length)) message.defaults = []; - message.defaults.push($root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.decode(reader, reader.uint32())); + message.defaults.push($root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 4: { @@ -20260,7 +22121,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -20291,19 +22152,23 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - FeatureSetDefaults.verify = function verify(message) { + FeatureSetDefaults.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.defaults != null && message.hasOwnProperty("defaults")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.defaults != null && Object.hasOwnProperty.call(message, "defaults")) { if (!Array.isArray(message.defaults)) return "defaults: array expected"; for (var i = 0; i < message.defaults.length; ++i) { - var error = $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.verify(message.defaults[i]); + var error = $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.verify(message.defaults[i], long + 1); if (error) return "defaults." + error; } } - if (message.minimumEdition != null && message.hasOwnProperty("minimumEdition")) + if (message.minimumEdition != null && Object.hasOwnProperty.call(message, "minimumEdition")) switch (message.minimumEdition) { default: return "minimumEdition: enum value expected"; @@ -20320,7 +22185,7 @@ case 2147483647: break; } - if (message.maximumEdition != null && message.hasOwnProperty("maximumEdition")) + if (message.maximumEdition != null && Object.hasOwnProperty.call(message, "maximumEdition")) switch (message.maximumEdition) { default: return "maximumEdition: enum value expected"; @@ -20348,18 +22213,24 @@ * @param {Object.} object Plain object * @returns {google.protobuf.FeatureSetDefaults} FeatureSetDefaults */ - FeatureSetDefaults.fromObject = function fromObject(object) { + FeatureSetDefaults.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.FeatureSetDefaults) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.FeatureSetDefaults: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.FeatureSetDefaults(); if (object.defaults) { if (!Array.isArray(object.defaults)) throw TypeError(".google.protobuf.FeatureSetDefaults.defaults: array expected"); message.defaults = []; for (var i = 0; i < object.defaults.length; ++i) { - if (typeof object.defaults[i] !== "object") + if (!$util.isObject(object.defaults[i])) throw TypeError(".google.protobuf.FeatureSetDefaults.defaults: object expected"); - message.defaults[i] = $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.fromObject(object.defaults[i]); + message.defaults[i] = $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.fromObject(object.defaults[i], long + 1); } } switch (object.minimumEdition) { @@ -20478,9 +22349,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - FeatureSetDefaults.toObject = function toObject(message, options) { + FeatureSetDefaults.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.defaults = []; @@ -20491,11 +22366,11 @@ if (message.defaults && message.defaults.length) { object.defaults = []; for (var j = 0; j < message.defaults.length; ++j) - object.defaults[j] = $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.toObject(message.defaults[j], options); + object.defaults[j] = $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.toObject(message.defaults[j], options, q + 1); } - if (message.minimumEdition != null && message.hasOwnProperty("minimumEdition")) + if (message.minimumEdition != null && Object.hasOwnProperty.call(message, "minimumEdition")) object.minimumEdition = options.enums === String ? $root.google.protobuf.Edition[message.minimumEdition] === undefined ? message.minimumEdition : $root.google.protobuf.Edition[message.minimumEdition] : message.minimumEdition; - if (message.maximumEdition != null && message.hasOwnProperty("maximumEdition")) + if (message.maximumEdition != null && Object.hasOwnProperty.call(message, "maximumEdition")) object.maximumEdition = options.enums === String ? $root.google.protobuf.Edition[message.maximumEdition] === undefined ? message.maximumEdition : $root.google.protobuf.Edition[message.maximumEdition] : message.maximumEdition; return object; }; @@ -20547,7 +22422,7 @@ function FeatureSetEditionDefault(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -20588,11 +22463,15 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - FeatureSetEditionDefault.encode = function encode(message, writer) { + FeatureSetEditionDefault.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.features != null && Object.hasOwnProperty.call(message, "features")) - $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.FeatureSet.encode(message.features, writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.edition != null && Object.hasOwnProperty.call(message, "edition")) writer.uint32(/* id 3, wireType 0 =*/24).int32(message.edition); return writer; @@ -20622,23 +22501,29 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - FeatureSetEditionDefault.decode = function decode(reader, length) { + FeatureSetEditionDefault.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 3: { message.edition = reader.int32(); break; } case 2: { - message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32()); + message.features = $root.google.protobuf.FeatureSet.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -20669,10 +22554,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - FeatureSetEditionDefault.verify = function verify(message) { + FeatureSetEditionDefault.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.edition != null && message.hasOwnProperty("edition")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.edition != null && Object.hasOwnProperty.call(message, "edition")) switch (message.edition) { default: return "edition: enum value expected"; @@ -20689,8 +22578,8 @@ case 2147483647: break; } - if (message.features != null && message.hasOwnProperty("features")) { - var error = $root.google.protobuf.FeatureSet.verify(message.features); + if (message.features != null && Object.hasOwnProperty.call(message, "features")) { + var error = $root.google.protobuf.FeatureSet.verify(message.features, long + 1); if (error) return "features." + error; } @@ -20705,9 +22594,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault} FeatureSetEditionDefault */ - FeatureSetEditionDefault.fromObject = function fromObject(object) { + FeatureSetEditionDefault.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault(); switch (object.edition) { default: @@ -20762,9 +22657,9 @@ break; } if (object.features != null) { - if (typeof object.features !== "object") + if (!$util.isObject(object.features)) throw TypeError(".google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.features: object expected"); - message.features = $root.google.protobuf.FeatureSet.fromObject(object.features); + message.features = $root.google.protobuf.FeatureSet.fromObject(object.features, long + 1); } return message; }; @@ -20778,17 +22673,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - FeatureSetEditionDefault.toObject = function toObject(message, options) { + FeatureSetEditionDefault.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.features = null; object.edition = options.enums === String ? "EDITION_UNKNOWN" : 0; } - if (message.features != null && message.hasOwnProperty("features")) - object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options); - if (message.edition != null && message.hasOwnProperty("edition")) + if (message.features != null && Object.hasOwnProperty.call(message, "features")) + object.features = $root.google.protobuf.FeatureSet.toObject(message.features, options, q + 1); + if (message.edition != null && Object.hasOwnProperty.call(message, "edition")) object.edition = options.enums === String ? $root.google.protobuf.Edition[message.edition] === undefined ? message.edition : $root.google.protobuf.Edition[message.edition] : message.edition; return object; }; @@ -20846,7 +22745,7 @@ this.location = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -20879,12 +22778,16 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - SourceCodeInfo.encode = function encode(message, writer) { + SourceCodeInfo.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.location != null && message.location.length) for (var i = 0; i < message.location.length; ++i) - $root.google.protobuf.SourceCodeInfo.Location.encode(message.location[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.protobuf.SourceCodeInfo.Location.encode(message.location[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -20912,21 +22815,27 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - SourceCodeInfo.decode = function decode(reader, length) { + SourceCodeInfo.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.SourceCodeInfo(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.location && message.location.length)) message.location = []; - message.location.push($root.google.protobuf.SourceCodeInfo.Location.decode(reader, reader.uint32())); + message.location.push($root.google.protobuf.SourceCodeInfo.Location.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -20957,14 +22866,18 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - SourceCodeInfo.verify = function verify(message) { + SourceCodeInfo.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.location != null && message.hasOwnProperty("location")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.location != null && Object.hasOwnProperty.call(message, "location")) { if (!Array.isArray(message.location)) return "location: array expected"; for (var i = 0; i < message.location.length; ++i) { - var error = $root.google.protobuf.SourceCodeInfo.Location.verify(message.location[i]); + var error = $root.google.protobuf.SourceCodeInfo.Location.verify(message.location[i], long + 1); if (error) return "location." + error; } @@ -20980,18 +22893,24 @@ * @param {Object.} object Plain object * @returns {google.protobuf.SourceCodeInfo} SourceCodeInfo */ - SourceCodeInfo.fromObject = function fromObject(object) { + SourceCodeInfo.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.SourceCodeInfo) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.SourceCodeInfo: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.SourceCodeInfo(); if (object.location) { if (!Array.isArray(object.location)) throw TypeError(".google.protobuf.SourceCodeInfo.location: array expected"); message.location = []; for (var i = 0; i < object.location.length; ++i) { - if (typeof object.location[i] !== "object") + if (!$util.isObject(object.location[i])) throw TypeError(".google.protobuf.SourceCodeInfo.location: object expected"); - message.location[i] = $root.google.protobuf.SourceCodeInfo.Location.fromObject(object.location[i]); + message.location[i] = $root.google.protobuf.SourceCodeInfo.Location.fromObject(object.location[i], long + 1); } } return message; @@ -21006,16 +22925,20 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - SourceCodeInfo.toObject = function toObject(message, options) { + SourceCodeInfo.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.location = []; if (message.location && message.location.length) { object.location = []; for (var j = 0; j < message.location.length; ++j) - object.location[j] = $root.google.protobuf.SourceCodeInfo.Location.toObject(message.location[j], options); + object.location[j] = $root.google.protobuf.SourceCodeInfo.Location.toObject(message.location[j], options, q + 1); } return object; }; @@ -21073,7 +22996,7 @@ this.leadingDetachedComments = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -21138,9 +23061,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Location.encode = function encode(message, writer) { + Location.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.path != null && message.path.length) { writer.uint32(/* id 1, wireType 2 =*/10).fork(); for (var i = 0; i < message.path.length; ++i) @@ -21187,12 +23114,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Location.decode = function decode(reader, length) { + Location.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.SourceCodeInfo.Location(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.path && message.path.length)) @@ -21231,7 +23164,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -21262,30 +23195,34 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Location.verify = function verify(message) { + Location.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.path != null && message.hasOwnProperty("path")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.path != null && Object.hasOwnProperty.call(message, "path")) { if (!Array.isArray(message.path)) return "path: array expected"; for (var i = 0; i < message.path.length; ++i) if (!$util.isInteger(message.path[i])) return "path: integer[] expected"; } - if (message.span != null && message.hasOwnProperty("span")) { + if (message.span != null && Object.hasOwnProperty.call(message, "span")) { if (!Array.isArray(message.span)) return "span: array expected"; for (var i = 0; i < message.span.length; ++i) if (!$util.isInteger(message.span[i])) return "span: integer[] expected"; } - if (message.leadingComments != null && message.hasOwnProperty("leadingComments")) + if (message.leadingComments != null && Object.hasOwnProperty.call(message, "leadingComments")) if (!$util.isString(message.leadingComments)) return "leadingComments: string expected"; - if (message.trailingComments != null && message.hasOwnProperty("trailingComments")) + if (message.trailingComments != null && Object.hasOwnProperty.call(message, "trailingComments")) if (!$util.isString(message.trailingComments)) return "trailingComments: string expected"; - if (message.leadingDetachedComments != null && message.hasOwnProperty("leadingDetachedComments")) { + if (message.leadingDetachedComments != null && Object.hasOwnProperty.call(message, "leadingDetachedComments")) { if (!Array.isArray(message.leadingDetachedComments)) return "leadingDetachedComments: array expected"; for (var i = 0; i < message.leadingDetachedComments.length; ++i) @@ -21303,9 +23240,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.SourceCodeInfo.Location} Location */ - Location.fromObject = function fromObject(object) { + Location.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.SourceCodeInfo.Location) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.SourceCodeInfo.Location: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.SourceCodeInfo.Location(); if (object.path) { if (!Array.isArray(object.path)) @@ -21344,9 +23287,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Location.toObject = function toObject(message, options) { + Location.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.path = []; @@ -21367,9 +23314,9 @@ for (var j = 0; j < message.span.length; ++j) object.span[j] = message.span[j]; } - if (message.leadingComments != null && message.hasOwnProperty("leadingComments")) + if (message.leadingComments != null && Object.hasOwnProperty.call(message, "leadingComments")) object.leadingComments = message.leadingComments; - if (message.trailingComments != null && message.hasOwnProperty("trailingComments")) + if (message.trailingComments != null && Object.hasOwnProperty.call(message, "trailingComments")) object.trailingComments = message.trailingComments; if (message.leadingDetachedComments && message.leadingDetachedComments.length) { object.leadingDetachedComments = []; @@ -21432,7 +23379,7 @@ this.annotation = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -21465,12 +23412,16 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - GeneratedCodeInfo.encode = function encode(message, writer) { + GeneratedCodeInfo.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.annotation != null && message.annotation.length) for (var i = 0; i < message.annotation.length; ++i) - $root.google.protobuf.GeneratedCodeInfo.Annotation.encode(message.annotation[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.protobuf.GeneratedCodeInfo.Annotation.encode(message.annotation[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); return writer; }; @@ -21498,21 +23449,27 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - GeneratedCodeInfo.decode = function decode(reader, length) { + GeneratedCodeInfo.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.GeneratedCodeInfo(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.annotation && message.annotation.length)) message.annotation = []; - message.annotation.push($root.google.protobuf.GeneratedCodeInfo.Annotation.decode(reader, reader.uint32())); + message.annotation.push($root.google.protobuf.GeneratedCodeInfo.Annotation.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -21543,14 +23500,18 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - GeneratedCodeInfo.verify = function verify(message) { + GeneratedCodeInfo.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.annotation != null && message.hasOwnProperty("annotation")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.annotation != null && Object.hasOwnProperty.call(message, "annotation")) { if (!Array.isArray(message.annotation)) return "annotation: array expected"; for (var i = 0; i < message.annotation.length; ++i) { - var error = $root.google.protobuf.GeneratedCodeInfo.Annotation.verify(message.annotation[i]); + var error = $root.google.protobuf.GeneratedCodeInfo.Annotation.verify(message.annotation[i], long + 1); if (error) return "annotation." + error; } @@ -21566,18 +23527,24 @@ * @param {Object.} object Plain object * @returns {google.protobuf.GeneratedCodeInfo} GeneratedCodeInfo */ - GeneratedCodeInfo.fromObject = function fromObject(object) { + GeneratedCodeInfo.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.GeneratedCodeInfo) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.GeneratedCodeInfo: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.GeneratedCodeInfo(); if (object.annotation) { if (!Array.isArray(object.annotation)) throw TypeError(".google.protobuf.GeneratedCodeInfo.annotation: array expected"); message.annotation = []; for (var i = 0; i < object.annotation.length; ++i) { - if (typeof object.annotation[i] !== "object") + if (!$util.isObject(object.annotation[i])) throw TypeError(".google.protobuf.GeneratedCodeInfo.annotation: object expected"); - message.annotation[i] = $root.google.protobuf.GeneratedCodeInfo.Annotation.fromObject(object.annotation[i]); + message.annotation[i] = $root.google.protobuf.GeneratedCodeInfo.Annotation.fromObject(object.annotation[i], long + 1); } } return message; @@ -21592,16 +23559,20 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - GeneratedCodeInfo.toObject = function toObject(message, options) { + GeneratedCodeInfo.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.annotation = []; if (message.annotation && message.annotation.length) { object.annotation = []; for (var j = 0; j < message.annotation.length; ++j) - object.annotation[j] = $root.google.protobuf.GeneratedCodeInfo.Annotation.toObject(message.annotation[j], options); + object.annotation[j] = $root.google.protobuf.GeneratedCodeInfo.Annotation.toObject(message.annotation[j], options, q + 1); } return object; }; @@ -21657,7 +23628,7 @@ this.path = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -21722,9 +23693,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Annotation.encode = function encode(message, writer) { + Annotation.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.path != null && message.path.length) { writer.uint32(/* id 1, wireType 2 =*/10).fork(); for (var i = 0; i < message.path.length; ++i) @@ -21766,12 +23741,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Annotation.decode = function decode(reader, length) { + Annotation.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.GeneratedCodeInfo.Annotation(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.path && message.path.length)) @@ -21801,7 +23782,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -21832,26 +23813,30 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Annotation.verify = function verify(message) { + Annotation.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.path != null && message.hasOwnProperty("path")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.path != null && Object.hasOwnProperty.call(message, "path")) { if (!Array.isArray(message.path)) return "path: array expected"; for (var i = 0; i < message.path.length; ++i) if (!$util.isInteger(message.path[i])) return "path: integer[] expected"; } - if (message.sourceFile != null && message.hasOwnProperty("sourceFile")) + if (message.sourceFile != null && Object.hasOwnProperty.call(message, "sourceFile")) if (!$util.isString(message.sourceFile)) return "sourceFile: string expected"; - if (message.begin != null && message.hasOwnProperty("begin")) + if (message.begin != null && Object.hasOwnProperty.call(message, "begin")) if (!$util.isInteger(message.begin)) return "begin: integer expected"; - if (message.end != null && message.hasOwnProperty("end")) + if (message.end != null && Object.hasOwnProperty.call(message, "end")) if (!$util.isInteger(message.end)) return "end: integer expected"; - if (message.semantic != null && message.hasOwnProperty("semantic")) + if (message.semantic != null && Object.hasOwnProperty.call(message, "semantic")) switch (message.semantic) { default: return "semantic: enum value expected"; @@ -21871,9 +23856,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.GeneratedCodeInfo.Annotation} Annotation */ - Annotation.fromObject = function fromObject(object) { + Annotation.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.GeneratedCodeInfo.Annotation) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.GeneratedCodeInfo.Annotation: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.GeneratedCodeInfo.Annotation(); if (object.path) { if (!Array.isArray(object.path)) @@ -21920,9 +23911,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Annotation.toObject = function toObject(message, options) { + Annotation.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.path = []; @@ -21937,13 +23932,13 @@ for (var j = 0; j < message.path.length; ++j) object.path[j] = message.path[j]; } - if (message.sourceFile != null && message.hasOwnProperty("sourceFile")) + if (message.sourceFile != null && Object.hasOwnProperty.call(message, "sourceFile")) object.sourceFile = message.sourceFile; - if (message.begin != null && message.hasOwnProperty("begin")) + if (message.begin != null && Object.hasOwnProperty.call(message, "begin")) object.begin = message.begin; - if (message.end != null && message.hasOwnProperty("end")) + if (message.end != null && Object.hasOwnProperty.call(message, "end")) object.end = message.end; - if (message.semantic != null && message.hasOwnProperty("semantic")) + if (message.semantic != null && Object.hasOwnProperty.call(message, "semantic")) object.semantic = options.enums === String ? $root.google.protobuf.GeneratedCodeInfo.Annotation.Semantic[message.semantic] === undefined ? message.semantic : $root.google.protobuf.GeneratedCodeInfo.Annotation.Semantic[message.semantic] : message.semantic; return object; }; @@ -22017,7 +24012,7 @@ function Duration(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -22058,9 +24053,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Duration.encode = function encode(message, writer) { + Duration.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.seconds != null && Object.hasOwnProperty.call(message, "seconds")) writer.uint32(/* id 1, wireType 0 =*/8).int64(message.seconds); if (message.nanos != null && Object.hasOwnProperty.call(message, "nanos")) @@ -22092,12 +24091,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Duration.decode = function decode(reader, length) { + Duration.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.Duration(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.seconds = reader.int64(); @@ -22108,7 +24113,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -22139,13 +24144,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Duration.verify = function verify(message) { + Duration.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.seconds != null && message.hasOwnProperty("seconds")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.seconds != null && Object.hasOwnProperty.call(message, "seconds")) if (!$util.isInteger(message.seconds) && !(message.seconds && $util.isInteger(message.seconds.low) && $util.isInteger(message.seconds.high))) return "seconds: integer|Long expected"; - if (message.nanos != null && message.hasOwnProperty("nanos")) + if (message.nanos != null && Object.hasOwnProperty.call(message, "nanos")) if (!$util.isInteger(message.nanos)) return "nanos: integer expected"; return null; @@ -22159,13 +24168,19 @@ * @param {Object.} object Plain object * @returns {google.protobuf.Duration} Duration */ - Duration.fromObject = function fromObject(object) { + Duration.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.Duration) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.Duration: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.Duration(); if (object.seconds != null) if ($util.Long) - (message.seconds = $util.Long.fromValue(object.seconds)).unsigned = false; + message.seconds = $util.Long.fromValue(object.seconds, false); else if (typeof object.seconds === "string") message.seconds = parseInt(object.seconds, 10); else if (typeof object.seconds === "number") @@ -22186,24 +24201,30 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Duration.toObject = function toObject(message, options) { + Duration.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { if ($util.Long) { var long = new $util.Long(0, 0, false); - object.seconds = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + object.seconds = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : typeof BigInt !== "undefined" && options.longs === BigInt ? long.toBigInt() : long; } else - object.seconds = options.longs === String ? "0" : 0; + object.seconds = options.longs === String ? "0" : typeof BigInt !== "undefined" && options.longs === BigInt ? BigInt("0") : 0; object.nanos = 0; } - if (message.seconds != null && message.hasOwnProperty("seconds")) - if (typeof message.seconds === "number") + if (message.seconds != null && Object.hasOwnProperty.call(message, "seconds")) + if (typeof BigInt !== "undefined" && options.longs === BigInt) + object.seconds = typeof message.seconds === "number" ? BigInt(message.seconds) : $util.Long.fromBits(message.seconds.low >>> 0, message.seconds.high >>> 0, false).toBigInt(); + else if (typeof message.seconds === "number") object.seconds = options.longs === String ? String(message.seconds) : message.seconds; else object.seconds = options.longs === String ? $util.Long.prototype.toString.call(message.seconds) : options.longs === Number ? new $util.LongBits(message.seconds.low >>> 0, message.seconds.high >>> 0).toNumber() : message.seconds; - if (message.nanos != null && message.hasOwnProperty("nanos")) + if (message.nanos != null && Object.hasOwnProperty.call(message, "nanos")) object.nanos = message.nanos; return object; }; @@ -22258,7 +24279,7 @@ function Any(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -22299,9 +24320,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Any.encode = function encode(message, writer) { + Any.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.type_url != null && Object.hasOwnProperty.call(message, "type_url")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.type_url); if (message.value != null && Object.hasOwnProperty.call(message, "value")) @@ -22333,12 +24358,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Any.decode = function decode(reader, length) { + Any.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.Any(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.type_url = reader.string(); @@ -22349,7 +24380,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -22380,13 +24411,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Any.verify = function verify(message) { + Any.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.type_url != null && message.hasOwnProperty("type_url")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.type_url != null && Object.hasOwnProperty.call(message, "type_url")) if (!$util.isString(message.type_url)) return "type_url: string expected"; - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (!(message.value && typeof message.value.length === "number" || $util.isString(message.value))) return "value: buffer expected"; return null; @@ -22400,9 +24435,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.Any} Any */ - Any.fromObject = function fromObject(object) { + Any.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.Any) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.Any: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.Any(); if (object.type_url != null) message.type_url = String(object.type_url); @@ -22423,9 +24464,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Any.toObject = function toObject(message, options) { + Any.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.type_url = ""; @@ -22437,9 +24482,9 @@ object.value = $util.newBuffer(object.value); } } - if (message.type_url != null && message.hasOwnProperty("type_url")) + if (message.type_url != null && Object.hasOwnProperty.call(message, "type_url")) object.type_url = message.type_url; - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) object.value = options.bytes === String ? $util.base64.encode(message.value, 0, message.value.length) : options.bytes === Array ? Array.prototype.slice.call(message.value) : message.value; return object; }; @@ -22492,7 +24537,7 @@ function Empty(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -22517,9 +24562,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Empty.encode = function encode(message, writer) { + Empty.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); return writer; }; @@ -22547,15 +24596,21 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Empty.decode = function decode(reader, length) { + Empty.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.Empty(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -22586,9 +24641,13 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Empty.verify = function verify(message) { + Empty.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; return null; }; @@ -22600,7 +24659,7 @@ * @param {Object.} object Plain object * @returns {google.protobuf.Empty} Empty */ - Empty.fromObject = function fromObject(object) { + Empty.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.Empty) return object; return new $root.google.protobuf.Empty(); @@ -22680,7 +24739,7 @@ function Version(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -22737,9 +24796,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Version.encode = function encode(message, writer) { + Version.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.major != null && Object.hasOwnProperty.call(message, "major")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.major); if (message.minor != null && Object.hasOwnProperty.call(message, "minor")) @@ -22775,12 +24838,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Version.decode = function decode(reader, length) { + Version.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.compiler.Version(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.major = reader.int32(); @@ -22799,7 +24868,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -22830,19 +24899,23 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Version.verify = function verify(message) { + Version.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.major != null && message.hasOwnProperty("major")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.major != null && Object.hasOwnProperty.call(message, "major")) if (!$util.isInteger(message.major)) return "major: integer expected"; - if (message.minor != null && message.hasOwnProperty("minor")) + if (message.minor != null && Object.hasOwnProperty.call(message, "minor")) if (!$util.isInteger(message.minor)) return "minor: integer expected"; - if (message.patch != null && message.hasOwnProperty("patch")) + if (message.patch != null && Object.hasOwnProperty.call(message, "patch")) if (!$util.isInteger(message.patch)) return "patch: integer expected"; - if (message.suffix != null && message.hasOwnProperty("suffix")) + if (message.suffix != null && Object.hasOwnProperty.call(message, "suffix")) if (!$util.isString(message.suffix)) return "suffix: string expected"; return null; @@ -22856,9 +24929,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.compiler.Version} Version */ - Version.fromObject = function fromObject(object) { + Version.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.compiler.Version) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.compiler.Version: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.compiler.Version(); if (object.major != null) message.major = object.major | 0; @@ -22880,9 +24959,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Version.toObject = function toObject(message, options) { + Version.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.major = 0; @@ -22890,13 +24973,13 @@ object.patch = 0; object.suffix = ""; } - if (message.major != null && message.hasOwnProperty("major")) + if (message.major != null && Object.hasOwnProperty.call(message, "major")) object.major = message.major; - if (message.minor != null && message.hasOwnProperty("minor")) + if (message.minor != null && Object.hasOwnProperty.call(message, "minor")) object.minor = message.minor; - if (message.patch != null && message.hasOwnProperty("patch")) + if (message.patch != null && Object.hasOwnProperty.call(message, "patch")) object.patch = message.patch; - if (message.suffix != null && message.hasOwnProperty("suffix")) + if (message.suffix != null && Object.hasOwnProperty.call(message, "suffix")) object.suffix = message.suffix; return object; }; @@ -22957,7 +25040,7 @@ this.sourceFileDescriptors = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -23022,22 +25105,26 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - CodeGeneratorRequest.encode = function encode(message, writer) { + CodeGeneratorRequest.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.fileToGenerate != null && message.fileToGenerate.length) for (var i = 0; i < message.fileToGenerate.length; ++i) writer.uint32(/* id 1, wireType 2 =*/10).string(message.fileToGenerate[i]); if (message.parameter != null && Object.hasOwnProperty.call(message, "parameter")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.parameter); if (message.compilerVersion != null && Object.hasOwnProperty.call(message, "compilerVersion")) - $root.google.protobuf.compiler.Version.encode(message.compilerVersion, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.protobuf.compiler.Version.encode(message.compilerVersion, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); if (message.protoFile != null && message.protoFile.length) for (var i = 0; i < message.protoFile.length; ++i) - $root.google.protobuf.FileDescriptorProto.encode(message.protoFile[i], writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim(); + $root.google.protobuf.FileDescriptorProto.encode(message.protoFile[i], writer.uint32(/* id 15, wireType 2 =*/122).fork(), q + 1).ldelim(); if (message.sourceFileDescriptors != null && message.sourceFileDescriptors.length) for (var i = 0; i < message.sourceFileDescriptors.length; ++i) - $root.google.protobuf.FileDescriptorProto.encode(message.sourceFileDescriptors[i], writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim(); + $root.google.protobuf.FileDescriptorProto.encode(message.sourceFileDescriptors[i], writer.uint32(/* id 17, wireType 2 =*/138).fork(), q + 1).ldelim(); return writer; }; @@ -23065,12 +25152,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - CodeGeneratorRequest.decode = function decode(reader, length) { + CodeGeneratorRequest.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.compiler.CodeGeneratorRequest(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.fileToGenerate && message.fileToGenerate.length)) @@ -23085,21 +25178,21 @@ case 15: { if (!(message.protoFile && message.protoFile.length)) message.protoFile = []; - message.protoFile.push($root.google.protobuf.FileDescriptorProto.decode(reader, reader.uint32())); + message.protoFile.push($root.google.protobuf.FileDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 17: { if (!(message.sourceFileDescriptors && message.sourceFileDescriptors.length)) message.sourceFileDescriptors = []; - message.sourceFileDescriptors.push($root.google.protobuf.FileDescriptorProto.decode(reader, reader.uint32())); + message.sourceFileDescriptors.push($root.google.protobuf.FileDescriptorProto.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 3: { - message.compilerVersion = $root.google.protobuf.compiler.Version.decode(reader, reader.uint32()); + message.compilerVersion = $root.google.protobuf.compiler.Version.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -23130,39 +25223,43 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - CodeGeneratorRequest.verify = function verify(message) { + CodeGeneratorRequest.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.fileToGenerate != null && message.hasOwnProperty("fileToGenerate")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.fileToGenerate != null && Object.hasOwnProperty.call(message, "fileToGenerate")) { if (!Array.isArray(message.fileToGenerate)) return "fileToGenerate: array expected"; for (var i = 0; i < message.fileToGenerate.length; ++i) if (!$util.isString(message.fileToGenerate[i])) return "fileToGenerate: string[] expected"; } - if (message.parameter != null && message.hasOwnProperty("parameter")) + if (message.parameter != null && Object.hasOwnProperty.call(message, "parameter")) if (!$util.isString(message.parameter)) return "parameter: string expected"; - if (message.protoFile != null && message.hasOwnProperty("protoFile")) { + if (message.protoFile != null && Object.hasOwnProperty.call(message, "protoFile")) { if (!Array.isArray(message.protoFile)) return "protoFile: array expected"; for (var i = 0; i < message.protoFile.length; ++i) { - var error = $root.google.protobuf.FileDescriptorProto.verify(message.protoFile[i]); + var error = $root.google.protobuf.FileDescriptorProto.verify(message.protoFile[i], long + 1); if (error) return "protoFile." + error; } } - if (message.sourceFileDescriptors != null && message.hasOwnProperty("sourceFileDescriptors")) { + if (message.sourceFileDescriptors != null && Object.hasOwnProperty.call(message, "sourceFileDescriptors")) { if (!Array.isArray(message.sourceFileDescriptors)) return "sourceFileDescriptors: array expected"; for (var i = 0; i < message.sourceFileDescriptors.length; ++i) { - var error = $root.google.protobuf.FileDescriptorProto.verify(message.sourceFileDescriptors[i]); + var error = $root.google.protobuf.FileDescriptorProto.verify(message.sourceFileDescriptors[i], long + 1); if (error) return "sourceFileDescriptors." + error; } } - if (message.compilerVersion != null && message.hasOwnProperty("compilerVersion")) { - var error = $root.google.protobuf.compiler.Version.verify(message.compilerVersion); + if (message.compilerVersion != null && Object.hasOwnProperty.call(message, "compilerVersion")) { + var error = $root.google.protobuf.compiler.Version.verify(message.compilerVersion, long + 1); if (error) return "compilerVersion." + error; } @@ -23177,9 +25274,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.compiler.CodeGeneratorRequest} CodeGeneratorRequest */ - CodeGeneratorRequest.fromObject = function fromObject(object) { + CodeGeneratorRequest.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.compiler.CodeGeneratorRequest) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.compiler.CodeGeneratorRequest: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.compiler.CodeGeneratorRequest(); if (object.fileToGenerate) { if (!Array.isArray(object.fileToGenerate)) @@ -23195,9 +25298,9 @@ throw TypeError(".google.protobuf.compiler.CodeGeneratorRequest.protoFile: array expected"); message.protoFile = []; for (var i = 0; i < object.protoFile.length; ++i) { - if (typeof object.protoFile[i] !== "object") + if (!$util.isObject(object.protoFile[i])) throw TypeError(".google.protobuf.compiler.CodeGeneratorRequest.protoFile: object expected"); - message.protoFile[i] = $root.google.protobuf.FileDescriptorProto.fromObject(object.protoFile[i]); + message.protoFile[i] = $root.google.protobuf.FileDescriptorProto.fromObject(object.protoFile[i], long + 1); } } if (object.sourceFileDescriptors) { @@ -23205,15 +25308,15 @@ throw TypeError(".google.protobuf.compiler.CodeGeneratorRequest.sourceFileDescriptors: array expected"); message.sourceFileDescriptors = []; for (var i = 0; i < object.sourceFileDescriptors.length; ++i) { - if (typeof object.sourceFileDescriptors[i] !== "object") + if (!$util.isObject(object.sourceFileDescriptors[i])) throw TypeError(".google.protobuf.compiler.CodeGeneratorRequest.sourceFileDescriptors: object expected"); - message.sourceFileDescriptors[i] = $root.google.protobuf.FileDescriptorProto.fromObject(object.sourceFileDescriptors[i]); + message.sourceFileDescriptors[i] = $root.google.protobuf.FileDescriptorProto.fromObject(object.sourceFileDescriptors[i], long + 1); } } if (object.compilerVersion != null) { - if (typeof object.compilerVersion !== "object") + if (!$util.isObject(object.compilerVersion)) throw TypeError(".google.protobuf.compiler.CodeGeneratorRequest.compilerVersion: object expected"); - message.compilerVersion = $root.google.protobuf.compiler.Version.fromObject(object.compilerVersion); + message.compilerVersion = $root.google.protobuf.compiler.Version.fromObject(object.compilerVersion, long + 1); } return message; }; @@ -23227,9 +25330,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - CodeGeneratorRequest.toObject = function toObject(message, options) { + CodeGeneratorRequest.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) { object.fileToGenerate = []; @@ -23245,19 +25352,19 @@ for (var j = 0; j < message.fileToGenerate.length; ++j) object.fileToGenerate[j] = message.fileToGenerate[j]; } - if (message.parameter != null && message.hasOwnProperty("parameter")) + if (message.parameter != null && Object.hasOwnProperty.call(message, "parameter")) object.parameter = message.parameter; - if (message.compilerVersion != null && message.hasOwnProperty("compilerVersion")) - object.compilerVersion = $root.google.protobuf.compiler.Version.toObject(message.compilerVersion, options); + if (message.compilerVersion != null && Object.hasOwnProperty.call(message, "compilerVersion")) + object.compilerVersion = $root.google.protobuf.compiler.Version.toObject(message.compilerVersion, options, q + 1); if (message.protoFile && message.protoFile.length) { object.protoFile = []; for (var j = 0; j < message.protoFile.length; ++j) - object.protoFile[j] = $root.google.protobuf.FileDescriptorProto.toObject(message.protoFile[j], options); + object.protoFile[j] = $root.google.protobuf.FileDescriptorProto.toObject(message.protoFile[j], options, q + 1); } if (message.sourceFileDescriptors && message.sourceFileDescriptors.length) { object.sourceFileDescriptors = []; for (var j = 0; j < message.sourceFileDescriptors.length; ++j) - object.sourceFileDescriptors[j] = $root.google.protobuf.FileDescriptorProto.toObject(message.sourceFileDescriptors[j], options); + object.sourceFileDescriptors[j] = $root.google.protobuf.FileDescriptorProto.toObject(message.sourceFileDescriptors[j], options, q + 1); } return object; }; @@ -23316,7 +25423,7 @@ this.file = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -23381,9 +25488,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - CodeGeneratorResponse.encode = function encode(message, writer) { + CodeGeneratorResponse.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.error != null && Object.hasOwnProperty.call(message, "error")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.error); if (message.supportedFeatures != null && Object.hasOwnProperty.call(message, "supportedFeatures")) @@ -23394,7 +25505,7 @@ writer.uint32(/* id 4, wireType 0 =*/32).int32(message.maximumEdition); if (message.file != null && message.file.length) for (var i = 0; i < message.file.length; ++i) - $root.google.protobuf.compiler.CodeGeneratorResponse.File.encode(message.file[i], writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim(); + $root.google.protobuf.compiler.CodeGeneratorResponse.File.encode(message.file[i], writer.uint32(/* id 15, wireType 2 =*/122).fork(), q + 1).ldelim(); return writer; }; @@ -23422,12 +25533,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - CodeGeneratorResponse.decode = function decode(reader, length) { + CodeGeneratorResponse.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.compiler.CodeGeneratorResponse(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.error = reader.string(); @@ -23448,11 +25565,11 @@ case 15: { if (!(message.file && message.file.length)) message.file = []; - message.file.push($root.google.protobuf.compiler.CodeGeneratorResponse.File.decode(reader, reader.uint32())); + message.file.push($root.google.protobuf.compiler.CodeGeneratorResponse.File.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -23483,26 +25600,30 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - CodeGeneratorResponse.verify = function verify(message) { + CodeGeneratorResponse.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.error != null && message.hasOwnProperty("error")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.error != null && Object.hasOwnProperty.call(message, "error")) if (!$util.isString(message.error)) return "error: string expected"; - if (message.supportedFeatures != null && message.hasOwnProperty("supportedFeatures")) + if (message.supportedFeatures != null && Object.hasOwnProperty.call(message, "supportedFeatures")) if (!$util.isInteger(message.supportedFeatures) && !(message.supportedFeatures && $util.isInteger(message.supportedFeatures.low) && $util.isInteger(message.supportedFeatures.high))) return "supportedFeatures: integer|Long expected"; - if (message.minimumEdition != null && message.hasOwnProperty("minimumEdition")) + if (message.minimumEdition != null && Object.hasOwnProperty.call(message, "minimumEdition")) if (!$util.isInteger(message.minimumEdition)) return "minimumEdition: integer expected"; - if (message.maximumEdition != null && message.hasOwnProperty("maximumEdition")) + if (message.maximumEdition != null && Object.hasOwnProperty.call(message, "maximumEdition")) if (!$util.isInteger(message.maximumEdition)) return "maximumEdition: integer expected"; - if (message.file != null && message.hasOwnProperty("file")) { + if (message.file != null && Object.hasOwnProperty.call(message, "file")) { if (!Array.isArray(message.file)) return "file: array expected"; for (var i = 0; i < message.file.length; ++i) { - var error = $root.google.protobuf.compiler.CodeGeneratorResponse.File.verify(message.file[i]); + var error = $root.google.protobuf.compiler.CodeGeneratorResponse.File.verify(message.file[i], long + 1); if (error) return "file." + error; } @@ -23518,15 +25639,21 @@ * @param {Object.} object Plain object * @returns {google.protobuf.compiler.CodeGeneratorResponse} CodeGeneratorResponse */ - CodeGeneratorResponse.fromObject = function fromObject(object) { + CodeGeneratorResponse.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.compiler.CodeGeneratorResponse) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.compiler.CodeGeneratorResponse: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.compiler.CodeGeneratorResponse(); if (object.error != null) message.error = String(object.error); if (object.supportedFeatures != null) if ($util.Long) - (message.supportedFeatures = $util.Long.fromValue(object.supportedFeatures)).unsigned = true; + message.supportedFeatures = $util.Long.fromValue(object.supportedFeatures, true); else if (typeof object.supportedFeatures === "string") message.supportedFeatures = parseInt(object.supportedFeatures, 10); else if (typeof object.supportedFeatures === "number") @@ -23542,9 +25669,9 @@ throw TypeError(".google.protobuf.compiler.CodeGeneratorResponse.file: array expected"); message.file = []; for (var i = 0; i < object.file.length; ++i) { - if (typeof object.file[i] !== "object") + if (!$util.isObject(object.file[i])) throw TypeError(".google.protobuf.compiler.CodeGeneratorResponse.file: object expected"); - message.file[i] = $root.google.protobuf.compiler.CodeGeneratorResponse.File.fromObject(object.file[i]); + message.file[i] = $root.google.protobuf.compiler.CodeGeneratorResponse.File.fromObject(object.file[i], long + 1); } } return message; @@ -23559,9 +25686,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - CodeGeneratorResponse.toObject = function toObject(message, options) { + CodeGeneratorResponse.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.file = []; @@ -23569,27 +25700,29 @@ object.error = ""; if ($util.Long) { var long = new $util.Long(0, 0, true); - object.supportedFeatures = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + object.supportedFeatures = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : typeof BigInt !== "undefined" && options.longs === BigInt ? long.toBigInt() : long; } else - object.supportedFeatures = options.longs === String ? "0" : 0; + object.supportedFeatures = options.longs === String ? "0" : typeof BigInt !== "undefined" && options.longs === BigInt ? BigInt("0") : 0; object.minimumEdition = 0; object.maximumEdition = 0; } - if (message.error != null && message.hasOwnProperty("error")) + if (message.error != null && Object.hasOwnProperty.call(message, "error")) object.error = message.error; - if (message.supportedFeatures != null && message.hasOwnProperty("supportedFeatures")) - if (typeof message.supportedFeatures === "number") + if (message.supportedFeatures != null && Object.hasOwnProperty.call(message, "supportedFeatures")) + if (typeof BigInt !== "undefined" && options.longs === BigInt) + object.supportedFeatures = typeof message.supportedFeatures === "number" ? BigInt(message.supportedFeatures) : $util.Long.fromBits(message.supportedFeatures.low >>> 0, message.supportedFeatures.high >>> 0, true).toBigInt(); + else if (typeof message.supportedFeatures === "number") object.supportedFeatures = options.longs === String ? String(message.supportedFeatures) : message.supportedFeatures; else object.supportedFeatures = options.longs === String ? $util.Long.prototype.toString.call(message.supportedFeatures) : options.longs === Number ? new $util.LongBits(message.supportedFeatures.low >>> 0, message.supportedFeatures.high >>> 0).toNumber(true) : message.supportedFeatures; - if (message.minimumEdition != null && message.hasOwnProperty("minimumEdition")) + if (message.minimumEdition != null && Object.hasOwnProperty.call(message, "minimumEdition")) object.minimumEdition = message.minimumEdition; - if (message.maximumEdition != null && message.hasOwnProperty("maximumEdition")) + if (message.maximumEdition != null && Object.hasOwnProperty.call(message, "maximumEdition")) object.maximumEdition = message.maximumEdition; if (message.file && message.file.length) { object.file = []; for (var j = 0; j < message.file.length; ++j) - object.file[j] = $root.google.protobuf.compiler.CodeGeneratorResponse.File.toObject(message.file[j], options); + object.file[j] = $root.google.protobuf.compiler.CodeGeneratorResponse.File.toObject(message.file[j], options, q + 1); } return object; }; @@ -23659,7 +25792,7 @@ function File(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -23716,9 +25849,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - File.encode = function encode(message, writer) { + File.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.insertionPoint != null && Object.hasOwnProperty.call(message, "insertionPoint")) @@ -23726,7 +25863,7 @@ if (message.content != null && Object.hasOwnProperty.call(message, "content")) writer.uint32(/* id 15, wireType 2 =*/122).string(message.content); if (message.generatedCodeInfo != null && Object.hasOwnProperty.call(message, "generatedCodeInfo")) - $root.google.protobuf.GeneratedCodeInfo.encode(message.generatedCodeInfo, writer.uint32(/* id 16, wireType 2 =*/130).fork()).ldelim(); + $root.google.protobuf.GeneratedCodeInfo.encode(message.generatedCodeInfo, writer.uint32(/* id 16, wireType 2 =*/130).fork(), q + 1).ldelim(); return writer; }; @@ -23754,12 +25891,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - File.decode = function decode(reader, length) { + File.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.compiler.CodeGeneratorResponse.File(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); @@ -23774,11 +25917,11 @@ break; } case 16: { - message.generatedCodeInfo = $root.google.protobuf.GeneratedCodeInfo.decode(reader, reader.uint32()); + message.generatedCodeInfo = $root.google.protobuf.GeneratedCodeInfo.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -23809,20 +25952,24 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - File.verify = function verify(message) { + File.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.insertionPoint != null && message.hasOwnProperty("insertionPoint")) + if (message.insertionPoint != null && Object.hasOwnProperty.call(message, "insertionPoint")) if (!$util.isString(message.insertionPoint)) return "insertionPoint: string expected"; - if (message.content != null && message.hasOwnProperty("content")) + if (message.content != null && Object.hasOwnProperty.call(message, "content")) if (!$util.isString(message.content)) return "content: string expected"; - if (message.generatedCodeInfo != null && message.hasOwnProperty("generatedCodeInfo")) { - var error = $root.google.protobuf.GeneratedCodeInfo.verify(message.generatedCodeInfo); + if (message.generatedCodeInfo != null && Object.hasOwnProperty.call(message, "generatedCodeInfo")) { + var error = $root.google.protobuf.GeneratedCodeInfo.verify(message.generatedCodeInfo, long + 1); if (error) return "generatedCodeInfo." + error; } @@ -23837,9 +25984,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.compiler.CodeGeneratorResponse.File} File */ - File.fromObject = function fromObject(object) { + File.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.compiler.CodeGeneratorResponse.File) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.compiler.CodeGeneratorResponse.File: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.compiler.CodeGeneratorResponse.File(); if (object.name != null) message.name = String(object.name); @@ -23848,9 +26001,9 @@ if (object.content != null) message.content = String(object.content); if (object.generatedCodeInfo != null) { - if (typeof object.generatedCodeInfo !== "object") + if (!$util.isObject(object.generatedCodeInfo)) throw TypeError(".google.protobuf.compiler.CodeGeneratorResponse.File.generatedCodeInfo: object expected"); - message.generatedCodeInfo = $root.google.protobuf.GeneratedCodeInfo.fromObject(object.generatedCodeInfo); + message.generatedCodeInfo = $root.google.protobuf.GeneratedCodeInfo.fromObject(object.generatedCodeInfo, long + 1); } return message; }; @@ -23864,9 +26017,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - File.toObject = function toObject(message, options) { + File.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.name = ""; @@ -23874,14 +26031,14 @@ object.content = ""; object.generatedCodeInfo = null; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; - if (message.insertionPoint != null && message.hasOwnProperty("insertionPoint")) + if (message.insertionPoint != null && Object.hasOwnProperty.call(message, "insertionPoint")) object.insertionPoint = message.insertionPoint; - if (message.content != null && message.hasOwnProperty("content")) + if (message.content != null && Object.hasOwnProperty.call(message, "content")) object.content = message.content; - if (message.generatedCodeInfo != null && message.hasOwnProperty("generatedCodeInfo")) - object.generatedCodeInfo = $root.google.protobuf.GeneratedCodeInfo.toObject(message.generatedCodeInfo, options); + if (message.generatedCodeInfo != null && Object.hasOwnProperty.call(message, "generatedCodeInfo")) + object.generatedCodeInfo = $root.google.protobuf.GeneratedCodeInfo.toObject(message.generatedCodeInfo, options, q + 1); return object; }; @@ -23940,7 +26097,7 @@ function DoubleValue(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -23973,9 +26130,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - DoubleValue.encode = function encode(message, writer) { + DoubleValue.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.value != null && Object.hasOwnProperty.call(message, "value")) writer.uint32(/* id 1, wireType 1 =*/9).double(message.value); return writer; @@ -24005,19 +26166,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - DoubleValue.decode = function decode(reader, length) { + DoubleValue.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.DoubleValue(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.value = reader.double(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -24048,10 +26215,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - DoubleValue.verify = function verify(message) { + DoubleValue.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.value != null && message.hasOwnProperty("value")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (typeof message.value !== "number") return "value: number expected"; return null; @@ -24065,9 +26236,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.DoubleValue} DoubleValue */ - DoubleValue.fromObject = function fromObject(object) { + DoubleValue.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.DoubleValue) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.DoubleValue: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.DoubleValue(); if (object.value != null) message.value = Number(object.value); @@ -24083,13 +26260,17 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - DoubleValue.toObject = function toObject(message, options) { + DoubleValue.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.value = 0; - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) object.value = options.json && !isFinite(message.value) ? String(message.value) : message.value; return object; }; @@ -24143,7 +26324,7 @@ function FloatValue(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -24176,9 +26357,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - FloatValue.encode = function encode(message, writer) { + FloatValue.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.value != null && Object.hasOwnProperty.call(message, "value")) writer.uint32(/* id 1, wireType 5 =*/13).float(message.value); return writer; @@ -24208,19 +26393,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - FloatValue.decode = function decode(reader, length) { + FloatValue.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FloatValue(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.value = reader.float(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -24251,10 +26442,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - FloatValue.verify = function verify(message) { + FloatValue.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.value != null && message.hasOwnProperty("value")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (typeof message.value !== "number") return "value: number expected"; return null; @@ -24268,9 +26463,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.FloatValue} FloatValue */ - FloatValue.fromObject = function fromObject(object) { + FloatValue.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.FloatValue) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.FloatValue: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.FloatValue(); if (object.value != null) message.value = Number(object.value); @@ -24286,13 +26487,17 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - FloatValue.toObject = function toObject(message, options) { + FloatValue.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.value = 0; - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) object.value = options.json && !isFinite(message.value) ? String(message.value) : message.value; return object; }; @@ -24346,7 +26551,7 @@ function Int64Value(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -24379,9 +26584,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Int64Value.encode = function encode(message, writer) { + Int64Value.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.value != null && Object.hasOwnProperty.call(message, "value")) writer.uint32(/* id 1, wireType 0 =*/8).int64(message.value); return writer; @@ -24411,19 +26620,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Int64Value.decode = function decode(reader, length) { + Int64Value.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.Int64Value(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.value = reader.int64(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -24454,10 +26669,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Int64Value.verify = function verify(message) { + Int64Value.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.value != null && message.hasOwnProperty("value")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (!$util.isInteger(message.value) && !(message.value && $util.isInteger(message.value.low) && $util.isInteger(message.value.high))) return "value: integer|Long expected"; return null; @@ -24471,13 +26690,19 @@ * @param {Object.} object Plain object * @returns {google.protobuf.Int64Value} Int64Value */ - Int64Value.fromObject = function fromObject(object) { + Int64Value.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.Int64Value) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.Int64Value: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.Int64Value(); if (object.value != null) if ($util.Long) - (message.value = $util.Long.fromValue(object.value)).unsigned = false; + message.value = $util.Long.fromValue(object.value, false); else if (typeof object.value === "string") message.value = parseInt(object.value, 10); else if (typeof object.value === "number") @@ -24496,18 +26721,24 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Int64Value.toObject = function toObject(message, options) { + Int64Value.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) if ($util.Long) { var long = new $util.Long(0, 0, false); - object.value = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + object.value = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : typeof BigInt !== "undefined" && options.longs === BigInt ? long.toBigInt() : long; } else - object.value = options.longs === String ? "0" : 0; - if (message.value != null && message.hasOwnProperty("value")) - if (typeof message.value === "number") + object.value = options.longs === String ? "0" : typeof BigInt !== "undefined" && options.longs === BigInt ? BigInt("0") : 0; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) + if (typeof BigInt !== "undefined" && options.longs === BigInt) + object.value = typeof message.value === "number" ? BigInt(message.value) : $util.Long.fromBits(message.value.low >>> 0, message.value.high >>> 0, false).toBigInt(); + else if (typeof message.value === "number") object.value = options.longs === String ? String(message.value) : message.value; else object.value = options.longs === String ? $util.Long.prototype.toString.call(message.value) : options.longs === Number ? new $util.LongBits(message.value.low >>> 0, message.value.high >>> 0).toNumber() : message.value; @@ -24563,7 +26794,7 @@ function UInt64Value(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -24596,9 +26827,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - UInt64Value.encode = function encode(message, writer) { + UInt64Value.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.value != null && Object.hasOwnProperty.call(message, "value")) writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.value); return writer; @@ -24628,19 +26863,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - UInt64Value.decode = function decode(reader, length) { + UInt64Value.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.UInt64Value(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.value = reader.uint64(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -24671,10 +26912,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - UInt64Value.verify = function verify(message) { + UInt64Value.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.value != null && message.hasOwnProperty("value")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (!$util.isInteger(message.value) && !(message.value && $util.isInteger(message.value.low) && $util.isInteger(message.value.high))) return "value: integer|Long expected"; return null; @@ -24688,13 +26933,19 @@ * @param {Object.} object Plain object * @returns {google.protobuf.UInt64Value} UInt64Value */ - UInt64Value.fromObject = function fromObject(object) { + UInt64Value.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.UInt64Value) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.UInt64Value: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.UInt64Value(); if (object.value != null) if ($util.Long) - (message.value = $util.Long.fromValue(object.value)).unsigned = true; + message.value = $util.Long.fromValue(object.value, true); else if (typeof object.value === "string") message.value = parseInt(object.value, 10); else if (typeof object.value === "number") @@ -24713,18 +26964,24 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - UInt64Value.toObject = function toObject(message, options) { + UInt64Value.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) if ($util.Long) { var long = new $util.Long(0, 0, true); - object.value = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + object.value = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : typeof BigInt !== "undefined" && options.longs === BigInt ? long.toBigInt() : long; } else - object.value = options.longs === String ? "0" : 0; - if (message.value != null && message.hasOwnProperty("value")) - if (typeof message.value === "number") + object.value = options.longs === String ? "0" : typeof BigInt !== "undefined" && options.longs === BigInt ? BigInt("0") : 0; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) + if (typeof BigInt !== "undefined" && options.longs === BigInt) + object.value = typeof message.value === "number" ? BigInt(message.value) : $util.Long.fromBits(message.value.low >>> 0, message.value.high >>> 0, true).toBigInt(); + else if (typeof message.value === "number") object.value = options.longs === String ? String(message.value) : message.value; else object.value = options.longs === String ? $util.Long.prototype.toString.call(message.value) : options.longs === Number ? new $util.LongBits(message.value.low >>> 0, message.value.high >>> 0).toNumber(true) : message.value; @@ -24780,7 +27037,7 @@ function Int32Value(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -24813,9 +27070,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Int32Value.encode = function encode(message, writer) { + Int32Value.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.value != null && Object.hasOwnProperty.call(message, "value")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.value); return writer; @@ -24845,19 +27106,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Int32Value.decode = function decode(reader, length) { + Int32Value.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.Int32Value(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.value = reader.int32(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -24888,10 +27155,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Int32Value.verify = function verify(message) { + Int32Value.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.value != null && message.hasOwnProperty("value")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (!$util.isInteger(message.value)) return "value: integer expected"; return null; @@ -24905,9 +27176,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.Int32Value} Int32Value */ - Int32Value.fromObject = function fromObject(object) { + Int32Value.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.Int32Value) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.Int32Value: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.Int32Value(); if (object.value != null) message.value = object.value | 0; @@ -24923,13 +27200,17 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Int32Value.toObject = function toObject(message, options) { + Int32Value.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.value = 0; - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) object.value = message.value; return object; }; @@ -24983,7 +27264,7 @@ function UInt32Value(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -25016,9 +27297,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - UInt32Value.encode = function encode(message, writer) { + UInt32Value.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.value != null && Object.hasOwnProperty.call(message, "value")) writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.value); return writer; @@ -25048,19 +27333,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - UInt32Value.decode = function decode(reader, length) { + UInt32Value.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.UInt32Value(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.value = reader.uint32(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -25091,10 +27382,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - UInt32Value.verify = function verify(message) { + UInt32Value.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.value != null && message.hasOwnProperty("value")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (!$util.isInteger(message.value)) return "value: integer expected"; return null; @@ -25108,9 +27403,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.UInt32Value} UInt32Value */ - UInt32Value.fromObject = function fromObject(object) { + UInt32Value.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.UInt32Value) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.UInt32Value: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.UInt32Value(); if (object.value != null) message.value = object.value >>> 0; @@ -25126,13 +27427,17 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - UInt32Value.toObject = function toObject(message, options) { + UInt32Value.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.value = 0; - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) object.value = message.value; return object; }; @@ -25186,7 +27491,7 @@ function BoolValue(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -25219,9 +27524,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - BoolValue.encode = function encode(message, writer) { + BoolValue.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.value != null && Object.hasOwnProperty.call(message, "value")) writer.uint32(/* id 1, wireType 0 =*/8).bool(message.value); return writer; @@ -25251,19 +27560,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - BoolValue.decode = function decode(reader, length) { + BoolValue.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.BoolValue(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.value = reader.bool(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -25294,10 +27609,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - BoolValue.verify = function verify(message) { + BoolValue.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.value != null && message.hasOwnProperty("value")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (typeof message.value !== "boolean") return "value: boolean expected"; return null; @@ -25311,9 +27630,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.BoolValue} BoolValue */ - BoolValue.fromObject = function fromObject(object) { + BoolValue.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.BoolValue) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.BoolValue: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.BoolValue(); if (object.value != null) message.value = Boolean(object.value); @@ -25329,13 +27654,17 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - BoolValue.toObject = function toObject(message, options) { + BoolValue.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.value = false; - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) object.value = message.value; return object; }; @@ -25389,7 +27718,7 @@ function StringValue(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -25422,9 +27751,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - StringValue.encode = function encode(message, writer) { + StringValue.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.value != null && Object.hasOwnProperty.call(message, "value")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.value); return writer; @@ -25454,19 +27787,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - StringValue.decode = function decode(reader, length) { + StringValue.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.StringValue(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.value = reader.string(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -25497,10 +27836,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - StringValue.verify = function verify(message) { + StringValue.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.value != null && message.hasOwnProperty("value")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (!$util.isString(message.value)) return "value: string expected"; return null; @@ -25514,9 +27857,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.StringValue} StringValue */ - StringValue.fromObject = function fromObject(object) { + StringValue.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.StringValue) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.StringValue: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.StringValue(); if (object.value != null) message.value = String(object.value); @@ -25532,13 +27881,17 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - StringValue.toObject = function toObject(message, options) { + StringValue.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.value = ""; - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) object.value = message.value; return object; }; @@ -25592,7 +27945,7 @@ function BytesValue(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -25625,9 +27978,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - BytesValue.encode = function encode(message, writer) { + BytesValue.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.value != null && Object.hasOwnProperty.call(message, "value")) writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.value); return writer; @@ -25657,19 +28014,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - BytesValue.decode = function decode(reader, length) { + BytesValue.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.BytesValue(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.value = reader.bytes(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -25700,10 +28063,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - BytesValue.verify = function verify(message) { + BytesValue.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.value != null && message.hasOwnProperty("value")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.value != null && Object.hasOwnProperty.call(message, "value")) if (!(message.value && typeof message.value.length === "number" || $util.isString(message.value))) return "value: buffer expected"; return null; @@ -25717,9 +28084,15 @@ * @param {Object.} object Plain object * @returns {google.protobuf.BytesValue} BytesValue */ - BytesValue.fromObject = function fromObject(object) { + BytesValue.fromObject = function fromObject(object, long) { if (object instanceof $root.google.protobuf.BytesValue) return object; + if (!$util.isObject(object)) + throw TypeError(".google.protobuf.BytesValue: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.protobuf.BytesValue(); if (object.value != null) if (typeof object.value === "string") @@ -25738,9 +28111,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - BytesValue.toObject = function toObject(message, options) { + BytesValue.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) if (options.bytes === String) @@ -25750,7 +28127,7 @@ if (options.bytes !== Array) object.value = $util.newBuffer(object.value); } - if (message.value != null && message.hasOwnProperty("value")) + if (message.value != null && Object.hasOwnProperty.call(message, "value")) object.value = options.bytes === String ? $util.base64.encode(message.value, 0, message.value.length) : options.bytes === Array ? Array.prototype.slice.call(message.value) : message.value; return object; }; @@ -26020,7 +28397,7 @@ function Operation(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -26099,19 +28476,23 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Operation.encode = function encode(message, writer) { + Operation.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.metadata != null && Object.hasOwnProperty.call(message, "metadata")) - $root.google.protobuf.Any.encode(message.metadata, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.Any.encode(message.metadata, writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); if (message.done != null && Object.hasOwnProperty.call(message, "done")) writer.uint32(/* id 3, wireType 0 =*/24).bool(message.done); if (message.error != null && Object.hasOwnProperty.call(message, "error")) - $root.google.rpc.Status.encode(message.error, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.google.rpc.Status.encode(message.error, writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); if (message.response != null && Object.hasOwnProperty.call(message, "response")) - $root.google.protobuf.Any.encode(message.response, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim(); + $root.google.protobuf.Any.encode(message.response, writer.uint32(/* id 5, wireType 2 =*/42).fork(), q + 1).ldelim(); return writer; }; @@ -26139,19 +28520,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Operation.decode = function decode(reader, length) { + Operation.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.longrunning.Operation(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); break; } case 2: { - message.metadata = $root.google.protobuf.Any.decode(reader, reader.uint32()); + message.metadata = $root.google.protobuf.Any.decode(reader, reader.uint32(), undefined, long + 1); break; } case 3: { @@ -26159,15 +28546,15 @@ break; } case 4: { - message.error = $root.google.rpc.Status.decode(reader, reader.uint32()); + message.error = $root.google.rpc.Status.decode(reader, reader.uint32(), undefined, long + 1); break; } case 5: { - message.response = $root.google.protobuf.Any.decode(reader, reader.uint32()); + message.response = $root.google.protobuf.Any.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -26198,35 +28585,39 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Operation.verify = function verify(message) { + Operation.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; var properties = {}; - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.metadata != null && message.hasOwnProperty("metadata")) { - var error = $root.google.protobuf.Any.verify(message.metadata); + if (message.metadata != null && Object.hasOwnProperty.call(message, "metadata")) { + var error = $root.google.protobuf.Any.verify(message.metadata, long + 1); if (error) return "metadata." + error; } - if (message.done != null && message.hasOwnProperty("done")) + if (message.done != null && Object.hasOwnProperty.call(message, "done")) if (typeof message.done !== "boolean") return "done: boolean expected"; - if (message.error != null && message.hasOwnProperty("error")) { + if (message.error != null && Object.hasOwnProperty.call(message, "error")) { properties.result = 1; { - var error = $root.google.rpc.Status.verify(message.error); + var error = $root.google.rpc.Status.verify(message.error, long + 1); if (error) return "error." + error; } } - if (message.response != null && message.hasOwnProperty("response")) { + if (message.response != null && Object.hasOwnProperty.call(message, "response")) { if (properties.result === 1) return "result: multiple values"; properties.result = 1; { - var error = $root.google.protobuf.Any.verify(message.response); + var error = $root.google.protobuf.Any.verify(message.response, long + 1); if (error) return "response." + error; } @@ -26242,28 +28633,34 @@ * @param {Object.} object Plain object * @returns {google.longrunning.Operation} Operation */ - Operation.fromObject = function fromObject(object) { + Operation.fromObject = function fromObject(object, long) { if (object instanceof $root.google.longrunning.Operation) return object; + if (!$util.isObject(object)) + throw TypeError(".google.longrunning.Operation: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.longrunning.Operation(); if (object.name != null) message.name = String(object.name); if (object.metadata != null) { - if (typeof object.metadata !== "object") + if (!$util.isObject(object.metadata)) throw TypeError(".google.longrunning.Operation.metadata: object expected"); - message.metadata = $root.google.protobuf.Any.fromObject(object.metadata); + message.metadata = $root.google.protobuf.Any.fromObject(object.metadata, long + 1); } if (object.done != null) message.done = Boolean(object.done); if (object.error != null) { - if (typeof object.error !== "object") + if (!$util.isObject(object.error)) throw TypeError(".google.longrunning.Operation.error: object expected"); - message.error = $root.google.rpc.Status.fromObject(object.error); + message.error = $root.google.rpc.Status.fromObject(object.error, long + 1); } if (object.response != null) { - if (typeof object.response !== "object") + if (!$util.isObject(object.response)) throw TypeError(".google.longrunning.Operation.response: object expected"); - message.response = $root.google.protobuf.Any.fromObject(object.response); + message.response = $root.google.protobuf.Any.fromObject(object.response, long + 1); } return message; }; @@ -26277,28 +28674,32 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Operation.toObject = function toObject(message, options) { + Operation.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.name = ""; object.metadata = null; object.done = false; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; - if (message.metadata != null && message.hasOwnProperty("metadata")) - object.metadata = $root.google.protobuf.Any.toObject(message.metadata, options); - if (message.done != null && message.hasOwnProperty("done")) + if (message.metadata != null && Object.hasOwnProperty.call(message, "metadata")) + object.metadata = $root.google.protobuf.Any.toObject(message.metadata, options, q + 1); + if (message.done != null && Object.hasOwnProperty.call(message, "done")) object.done = message.done; - if (message.error != null && message.hasOwnProperty("error")) { - object.error = $root.google.rpc.Status.toObject(message.error, options); + if (message.error != null && Object.hasOwnProperty.call(message, "error")) { + object.error = $root.google.rpc.Status.toObject(message.error, options, q + 1); if (options.oneofs) object.result = "error"; } - if (message.response != null && message.hasOwnProperty("response")) { - object.response = $root.google.protobuf.Any.toObject(message.response, options); + if (message.response != null && Object.hasOwnProperty.call(message, "response")) { + object.response = $root.google.protobuf.Any.toObject(message.response, options, q + 1); if (options.oneofs) object.result = "response"; } @@ -26354,7 +28755,7 @@ function GetOperationRequest(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -26387,9 +28788,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - GetOperationRequest.encode = function encode(message, writer) { + GetOperationRequest.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); return writer; @@ -26419,19 +28824,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - GetOperationRequest.decode = function decode(reader, length) { + GetOperationRequest.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.longrunning.GetOperationRequest(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -26462,10 +28873,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - GetOperationRequest.verify = function verify(message) { + GetOperationRequest.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; return null; @@ -26479,9 +28894,15 @@ * @param {Object.} object Plain object * @returns {google.longrunning.GetOperationRequest} GetOperationRequest */ - GetOperationRequest.fromObject = function fromObject(object) { + GetOperationRequest.fromObject = function fromObject(object, long) { if (object instanceof $root.google.longrunning.GetOperationRequest) return object; + if (!$util.isObject(object)) + throw TypeError(".google.longrunning.GetOperationRequest: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.longrunning.GetOperationRequest(); if (object.name != null) message.name = String(object.name); @@ -26497,13 +28918,17 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - GetOperationRequest.toObject = function toObject(message, options) { + GetOperationRequest.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.name = ""; - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; return object; }; @@ -26560,7 +28985,7 @@ function ListOperationsRequest(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -26617,9 +29042,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ListOperationsRequest.encode = function encode(message, writer) { + ListOperationsRequest.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.filter != null && Object.hasOwnProperty.call(message, "filter")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.filter); if (message.pageSize != null && Object.hasOwnProperty.call(message, "pageSize")) @@ -26655,12 +29084,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ListOperationsRequest.decode = function decode(reader, length) { + ListOperationsRequest.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.longrunning.ListOperationsRequest(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 4: { message.name = reader.string(); @@ -26679,7 +29114,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -26710,19 +29145,23 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ListOperationsRequest.verify = function verify(message) { + ListOperationsRequest.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.filter != null && message.hasOwnProperty("filter")) + if (message.filter != null && Object.hasOwnProperty.call(message, "filter")) if (!$util.isString(message.filter)) return "filter: string expected"; - if (message.pageSize != null && message.hasOwnProperty("pageSize")) + if (message.pageSize != null && Object.hasOwnProperty.call(message, "pageSize")) if (!$util.isInteger(message.pageSize)) return "pageSize: integer expected"; - if (message.pageToken != null && message.hasOwnProperty("pageToken")) + if (message.pageToken != null && Object.hasOwnProperty.call(message, "pageToken")) if (!$util.isString(message.pageToken)) return "pageToken: string expected"; return null; @@ -26736,9 +29175,15 @@ * @param {Object.} object Plain object * @returns {google.longrunning.ListOperationsRequest} ListOperationsRequest */ - ListOperationsRequest.fromObject = function fromObject(object) { + ListOperationsRequest.fromObject = function fromObject(object, long) { if (object instanceof $root.google.longrunning.ListOperationsRequest) return object; + if (!$util.isObject(object)) + throw TypeError(".google.longrunning.ListOperationsRequest: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.longrunning.ListOperationsRequest(); if (object.name != null) message.name = String(object.name); @@ -26760,9 +29205,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ListOperationsRequest.toObject = function toObject(message, options) { + ListOperationsRequest.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.filter = ""; @@ -26770,13 +29219,13 @@ object.pageToken = ""; object.name = ""; } - if (message.filter != null && message.hasOwnProperty("filter")) + if (message.filter != null && Object.hasOwnProperty.call(message, "filter")) object.filter = message.filter; - if (message.pageSize != null && message.hasOwnProperty("pageSize")) + if (message.pageSize != null && Object.hasOwnProperty.call(message, "pageSize")) object.pageSize = message.pageSize; - if (message.pageToken != null && message.hasOwnProperty("pageToken")) + if (message.pageToken != null && Object.hasOwnProperty.call(message, "pageToken")) object.pageToken = message.pageToken; - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; return object; }; @@ -26832,7 +29281,7 @@ this.operations = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -26873,12 +29322,16 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ListOperationsResponse.encode = function encode(message, writer) { + ListOperationsResponse.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.operations != null && message.operations.length) for (var i = 0; i < message.operations.length; ++i) - $root.google.longrunning.Operation.encode(message.operations[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.longrunning.Operation.encode(message.operations[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); if (message.nextPageToken != null && Object.hasOwnProperty.call(message, "nextPageToken")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.nextPageToken); return writer; @@ -26908,17 +29361,23 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ListOperationsResponse.decode = function decode(reader, length) { + ListOperationsResponse.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.longrunning.ListOperationsResponse(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { if (!(message.operations && message.operations.length)) message.operations = []; - message.operations.push($root.google.longrunning.Operation.decode(reader, reader.uint32())); + message.operations.push($root.google.longrunning.Operation.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 2: { @@ -26926,7 +29385,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -26957,19 +29416,23 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ListOperationsResponse.verify = function verify(message) { + ListOperationsResponse.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.operations != null && message.hasOwnProperty("operations")) { + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.operations != null && Object.hasOwnProperty.call(message, "operations")) { if (!Array.isArray(message.operations)) return "operations: array expected"; for (var i = 0; i < message.operations.length; ++i) { - var error = $root.google.longrunning.Operation.verify(message.operations[i]); + var error = $root.google.longrunning.Operation.verify(message.operations[i], long + 1); if (error) return "operations." + error; } } - if (message.nextPageToken != null && message.hasOwnProperty("nextPageToken")) + if (message.nextPageToken != null && Object.hasOwnProperty.call(message, "nextPageToken")) if (!$util.isString(message.nextPageToken)) return "nextPageToken: string expected"; return null; @@ -26983,18 +29446,24 @@ * @param {Object.} object Plain object * @returns {google.longrunning.ListOperationsResponse} ListOperationsResponse */ - ListOperationsResponse.fromObject = function fromObject(object) { + ListOperationsResponse.fromObject = function fromObject(object, long) { if (object instanceof $root.google.longrunning.ListOperationsResponse) return object; + if (!$util.isObject(object)) + throw TypeError(".google.longrunning.ListOperationsResponse: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.longrunning.ListOperationsResponse(); if (object.operations) { if (!Array.isArray(object.operations)) throw TypeError(".google.longrunning.ListOperationsResponse.operations: array expected"); message.operations = []; for (var i = 0; i < object.operations.length; ++i) { - if (typeof object.operations[i] !== "object") + if (!$util.isObject(object.operations[i])) throw TypeError(".google.longrunning.ListOperationsResponse.operations: object expected"); - message.operations[i] = $root.google.longrunning.Operation.fromObject(object.operations[i]); + message.operations[i] = $root.google.longrunning.Operation.fromObject(object.operations[i], long + 1); } } if (object.nextPageToken != null) @@ -27011,9 +29480,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ListOperationsResponse.toObject = function toObject(message, options) { + ListOperationsResponse.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.operations = []; @@ -27022,9 +29495,9 @@ if (message.operations && message.operations.length) { object.operations = []; for (var j = 0; j < message.operations.length; ++j) - object.operations[j] = $root.google.longrunning.Operation.toObject(message.operations[j], options); + object.operations[j] = $root.google.longrunning.Operation.toObject(message.operations[j], options, q + 1); } - if (message.nextPageToken != null && message.hasOwnProperty("nextPageToken")) + if (message.nextPageToken != null && Object.hasOwnProperty.call(message, "nextPageToken")) object.nextPageToken = message.nextPageToken; return object; }; @@ -27078,7 +29551,7 @@ function CancelOperationRequest(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -27111,9 +29584,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - CancelOperationRequest.encode = function encode(message, writer) { + CancelOperationRequest.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); return writer; @@ -27143,19 +29620,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - CancelOperationRequest.decode = function decode(reader, length) { + CancelOperationRequest.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.longrunning.CancelOperationRequest(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -27186,10 +29669,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - CancelOperationRequest.verify = function verify(message) { + CancelOperationRequest.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; return null; @@ -27203,9 +29690,15 @@ * @param {Object.} object Plain object * @returns {google.longrunning.CancelOperationRequest} CancelOperationRequest */ - CancelOperationRequest.fromObject = function fromObject(object) { + CancelOperationRequest.fromObject = function fromObject(object, long) { if (object instanceof $root.google.longrunning.CancelOperationRequest) return object; + if (!$util.isObject(object)) + throw TypeError(".google.longrunning.CancelOperationRequest: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.longrunning.CancelOperationRequest(); if (object.name != null) message.name = String(object.name); @@ -27221,13 +29714,17 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - CancelOperationRequest.toObject = function toObject(message, options) { + CancelOperationRequest.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.name = ""; - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; return object; }; @@ -27281,7 +29778,7 @@ function DeleteOperationRequest(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -27314,9 +29811,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - DeleteOperationRequest.encode = function encode(message, writer) { + DeleteOperationRequest.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); return writer; @@ -27346,19 +29847,25 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - DeleteOperationRequest.decode = function decode(reader, length) { + DeleteOperationRequest.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.longrunning.DeleteOperationRequest(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -27389,10 +29896,14 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - DeleteOperationRequest.verify = function verify(message) { + DeleteOperationRequest.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; return null; @@ -27406,9 +29917,15 @@ * @param {Object.} object Plain object * @returns {google.longrunning.DeleteOperationRequest} DeleteOperationRequest */ - DeleteOperationRequest.fromObject = function fromObject(object) { + DeleteOperationRequest.fromObject = function fromObject(object, long) { if (object instanceof $root.google.longrunning.DeleteOperationRequest) return object; + if (!$util.isObject(object)) + throw TypeError(".google.longrunning.DeleteOperationRequest: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.longrunning.DeleteOperationRequest(); if (object.name != null) message.name = String(object.name); @@ -27424,13 +29941,17 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - DeleteOperationRequest.toObject = function toObject(message, options) { + DeleteOperationRequest.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) object.name = ""; - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; return object; }; @@ -27485,7 +30006,7 @@ function WaitOperationRequest(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -27526,13 +30047,17 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - WaitOperationRequest.encode = function encode(message, writer) { + WaitOperationRequest.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.timeout != null && Object.hasOwnProperty.call(message, "timeout")) - $root.google.protobuf.Duration.encode(message.timeout, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.protobuf.Duration.encode(message.timeout, writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); return writer; }; @@ -27560,23 +30085,29 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - WaitOperationRequest.decode = function decode(reader, length) { + WaitOperationRequest.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.longrunning.WaitOperationRequest(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); break; } case 2: { - message.timeout = $root.google.protobuf.Duration.decode(reader, reader.uint32()); + message.timeout = $root.google.protobuf.Duration.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -27607,14 +30138,18 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - WaitOperationRequest.verify = function verify(message) { + WaitOperationRequest.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.timeout != null && message.hasOwnProperty("timeout")) { - var error = $root.google.protobuf.Duration.verify(message.timeout); + if (message.timeout != null && Object.hasOwnProperty.call(message, "timeout")) { + var error = $root.google.protobuf.Duration.verify(message.timeout, long + 1); if (error) return "timeout." + error; } @@ -27629,16 +30164,22 @@ * @param {Object.} object Plain object * @returns {google.longrunning.WaitOperationRequest} WaitOperationRequest */ - WaitOperationRequest.fromObject = function fromObject(object) { + WaitOperationRequest.fromObject = function fromObject(object, long) { if (object instanceof $root.google.longrunning.WaitOperationRequest) return object; + if (!$util.isObject(object)) + throw TypeError(".google.longrunning.WaitOperationRequest: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.longrunning.WaitOperationRequest(); if (object.name != null) message.name = String(object.name); if (object.timeout != null) { - if (typeof object.timeout !== "object") + if (!$util.isObject(object.timeout)) throw TypeError(".google.longrunning.WaitOperationRequest.timeout: object expected"); - message.timeout = $root.google.protobuf.Duration.fromObject(object.timeout); + message.timeout = $root.google.protobuf.Duration.fromObject(object.timeout, long + 1); } return message; }; @@ -27652,18 +30193,22 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - WaitOperationRequest.toObject = function toObject(message, options) { + WaitOperationRequest.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.name = ""; object.timeout = null; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; - if (message.timeout != null && message.hasOwnProperty("timeout")) - object.timeout = $root.google.protobuf.Duration.toObject(message.timeout, options); + if (message.timeout != null && Object.hasOwnProperty.call(message, "timeout")) + object.timeout = $root.google.protobuf.Duration.toObject(message.timeout, options, q + 1); return object; }; @@ -27717,7 +30262,7 @@ function OperationInfo(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -27758,9 +30303,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - OperationInfo.encode = function encode(message, writer) { + OperationInfo.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.responseType != null && Object.hasOwnProperty.call(message, "responseType")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.responseType); if (message.metadataType != null && Object.hasOwnProperty.call(message, "metadataType")) @@ -27792,12 +30341,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - OperationInfo.decode = function decode(reader, length) { + OperationInfo.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.longrunning.OperationInfo(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.responseType = reader.string(); @@ -27808,7 +30363,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -27839,13 +30394,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - OperationInfo.verify = function verify(message) { + OperationInfo.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.responseType != null && message.hasOwnProperty("responseType")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.responseType != null && Object.hasOwnProperty.call(message, "responseType")) if (!$util.isString(message.responseType)) return "responseType: string expected"; - if (message.metadataType != null && message.hasOwnProperty("metadataType")) + if (message.metadataType != null && Object.hasOwnProperty.call(message, "metadataType")) if (!$util.isString(message.metadataType)) return "metadataType: string expected"; return null; @@ -27859,9 +30418,15 @@ * @param {Object.} object Plain object * @returns {google.longrunning.OperationInfo} OperationInfo */ - OperationInfo.fromObject = function fromObject(object) { + OperationInfo.fromObject = function fromObject(object, long) { if (object instanceof $root.google.longrunning.OperationInfo) return object; + if (!$util.isObject(object)) + throw TypeError(".google.longrunning.OperationInfo: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.longrunning.OperationInfo(); if (object.responseType != null) message.responseType = String(object.responseType); @@ -27879,17 +30444,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - OperationInfo.toObject = function toObject(message, options) { + OperationInfo.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.responseType = ""; object.metadataType = ""; } - if (message.responseType != null && message.hasOwnProperty("responseType")) + if (message.responseType != null && Object.hasOwnProperty.call(message, "responseType")) object.responseType = message.responseType; - if (message.metadataType != null && message.hasOwnProperty("metadataType")) + if (message.metadataType != null && Object.hasOwnProperty.call(message, "metadataType")) object.metadataType = message.metadataType; return object; }; @@ -27958,7 +30527,7 @@ this.details = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -28007,16 +30576,20 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Status.encode = function encode(message, writer) { + Status.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.code != null && Object.hasOwnProperty.call(message, "code")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.code); if (message.message != null && Object.hasOwnProperty.call(message, "message")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.message); if (message.details != null && message.details.length) for (var i = 0; i < message.details.length; ++i) - $root.google.protobuf.Any.encode(message.details[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.protobuf.Any.encode(message.details[i], writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); return writer; }; @@ -28044,12 +30617,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Status.decode = function decode(reader, length) { + Status.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.rpc.Status(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.code = reader.int32(); @@ -28062,11 +30641,11 @@ case 3: { if (!(message.details && message.details.length)) message.details = []; - message.details.push($root.google.protobuf.Any.decode(reader, reader.uint32())); + message.details.push($root.google.protobuf.Any.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -28097,20 +30676,24 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Status.verify = function verify(message) { + Status.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.code != null && message.hasOwnProperty("code")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.code != null && Object.hasOwnProperty.call(message, "code")) if (!$util.isInteger(message.code)) return "code: integer expected"; - if (message.message != null && message.hasOwnProperty("message")) + if (message.message != null && Object.hasOwnProperty.call(message, "message")) if (!$util.isString(message.message)) return "message: string expected"; - if (message.details != null && message.hasOwnProperty("details")) { + if (message.details != null && Object.hasOwnProperty.call(message, "details")) { if (!Array.isArray(message.details)) return "details: array expected"; for (var i = 0; i < message.details.length; ++i) { - var error = $root.google.protobuf.Any.verify(message.details[i]); + var error = $root.google.protobuf.Any.verify(message.details[i], long + 1); if (error) return "details." + error; } @@ -28126,9 +30709,15 @@ * @param {Object.} object Plain object * @returns {google.rpc.Status} Status */ - Status.fromObject = function fromObject(object) { + Status.fromObject = function fromObject(object, long) { if (object instanceof $root.google.rpc.Status) return object; + if (!$util.isObject(object)) + throw TypeError(".google.rpc.Status: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.rpc.Status(); if (object.code != null) message.code = object.code | 0; @@ -28139,9 +30728,9 @@ throw TypeError(".google.rpc.Status.details: array expected"); message.details = []; for (var i = 0; i < object.details.length; ++i) { - if (typeof object.details[i] !== "object") + if (!$util.isObject(object.details[i])) throw TypeError(".google.rpc.Status.details: object expected"); - message.details[i] = $root.google.protobuf.Any.fromObject(object.details[i]); + message.details[i] = $root.google.protobuf.Any.fromObject(object.details[i], long + 1); } } return message; @@ -28156,9 +30745,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Status.toObject = function toObject(message, options) { + Status.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.details = []; @@ -28166,14 +30759,14 @@ object.code = 0; object.message = ""; } - if (message.code != null && message.hasOwnProperty("code")) + if (message.code != null && Object.hasOwnProperty.call(message, "code")) object.code = message.code; - if (message.message != null && message.hasOwnProperty("message")) + if (message.message != null && Object.hasOwnProperty.call(message, "message")) object.message = message.message; if (message.details && message.details.length) { object.details = []; for (var j = 0; j < message.details.length; ++j) - object.details[j] = $root.google.protobuf.Any.toObject(message.details[j], options); + object.details[j] = $root.google.protobuf.Any.toObject(message.details[j], options, q + 1); } return object; }; @@ -28321,7 +30914,7 @@ this.snippets = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -28362,14 +30955,18 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Index.encode = function encode(message, writer) { + Index.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.clientLibrary != null && Object.hasOwnProperty.call(message, "clientLibrary")) - $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.encode(message.clientLibrary, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.encode(message.clientLibrary, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim(); if (message.snippets != null && message.snippets.length) for (var i = 0; i < message.snippets.length; ++i) - $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.encode(message.snippets[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.encode(message.snippets[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim(); return writer; }; @@ -28397,25 +30994,31 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Index.decode = function decode(reader, length) { + Index.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Index(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { - message.clientLibrary = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.decode(reader, reader.uint32()); + message.clientLibrary = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.decode(reader, reader.uint32(), undefined, long + 1); break; } case 2: { if (!(message.snippets && message.snippets.length)) message.snippets = []; - message.snippets.push($root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.decode(reader, reader.uint32())); + message.snippets.push($root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -28446,19 +31049,23 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Index.verify = function verify(message) { + Index.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.clientLibrary != null && message.hasOwnProperty("clientLibrary")) { - var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.verify(message.clientLibrary); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.clientLibrary != null && Object.hasOwnProperty.call(message, "clientLibrary")) { + var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.verify(message.clientLibrary, long + 1); if (error) return "clientLibrary." + error; } - if (message.snippets != null && message.hasOwnProperty("snippets")) { + if (message.snippets != null && Object.hasOwnProperty.call(message, "snippets")) { if (!Array.isArray(message.snippets)) return "snippets: array expected"; for (var i = 0; i < message.snippets.length; ++i) { - var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.verify(message.snippets[i]); + var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.verify(message.snippets[i], long + 1); if (error) return "snippets." + error; } @@ -28474,23 +31081,29 @@ * @param {Object.} object Plain object * @returns {google.cloud.tools.snippetgen.snippetindex.v1.Index} Index */ - Index.fromObject = function fromObject(object) { + Index.fromObject = function fromObject(object, long) { if (object instanceof $root.google.cloud.tools.snippetgen.snippetindex.v1.Index) return object; + if (!$util.isObject(object)) + throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Index: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Index(); if (object.clientLibrary != null) { - if (typeof object.clientLibrary !== "object") + if (!$util.isObject(object.clientLibrary)) throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Index.clientLibrary: object expected"); - message.clientLibrary = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.fromObject(object.clientLibrary); + message.clientLibrary = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.fromObject(object.clientLibrary, long + 1); } if (object.snippets) { if (!Array.isArray(object.snippets)) throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Index.snippets: array expected"); message.snippets = []; for (var i = 0; i < object.snippets.length; ++i) { - if (typeof object.snippets[i] !== "object") + if (!$util.isObject(object.snippets[i])) throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Index.snippets: object expected"); - message.snippets[i] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.fromObject(object.snippets[i]); + message.snippets[i] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.fromObject(object.snippets[i], long + 1); } } return message; @@ -28505,20 +31118,24 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Index.toObject = function toObject(message, options) { + Index.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.snippets = []; if (options.defaults) object.clientLibrary = null; - if (message.clientLibrary != null && message.hasOwnProperty("clientLibrary")) - object.clientLibrary = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.toObject(message.clientLibrary, options); + if (message.clientLibrary != null && Object.hasOwnProperty.call(message, "clientLibrary")) + object.clientLibrary = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.toObject(message.clientLibrary, options, q + 1); if (message.snippets && message.snippets.length) { object.snippets = []; for (var j = 0; j < message.snippets.length; ++j) - object.snippets[j] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.toObject(message.snippets[j], options); + object.snippets[j] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.toObject(message.snippets[j], options, q + 1); } return object; }; @@ -28581,7 +31198,7 @@ this.segments = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -28678,9 +31295,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Snippet.encode = function encode(message, writer) { + Snippet.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.regionTag != null && Object.hasOwnProperty.call(message, "regionTag")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.regionTag); if (message.title != null && Object.hasOwnProperty.call(message, "title")) @@ -28692,14 +31313,14 @@ if (message.language != null && Object.hasOwnProperty.call(message, "language")) writer.uint32(/* id 5, wireType 0 =*/40).int32(message.language); if (message.clientMethod != null && Object.hasOwnProperty.call(message, "clientMethod")) - $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.encode(message.clientMethod, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim(); + $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.encode(message.clientMethod, writer.uint32(/* id 6, wireType 2 =*/50).fork(), q + 1).ldelim(); if (message.canonical != null && Object.hasOwnProperty.call(message, "canonical")) writer.uint32(/* id 7, wireType 0 =*/56).bool(message.canonical); if (message.origin != null && Object.hasOwnProperty.call(message, "origin")) writer.uint32(/* id 8, wireType 0 =*/64).int32(message.origin); if (message.segments != null && message.segments.length) for (var i = 0; i < message.segments.length; ++i) - $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.encode(message.segments[i], writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim(); + $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.encode(message.segments[i], writer.uint32(/* id 9, wireType 2 =*/74).fork(), q + 1).ldelim(); return writer; }; @@ -28727,12 +31348,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Snippet.decode = function decode(reader, length) { + Snippet.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.regionTag = reader.string(); @@ -28755,7 +31382,7 @@ break; } case 6: { - message.clientMethod = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.decode(reader, reader.uint32()); + message.clientMethod = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.decode(reader, reader.uint32(), undefined, long + 1); break; } case 7: { @@ -28769,11 +31396,11 @@ case 9: { if (!(message.segments && message.segments.length)) message.segments = []; - message.segments.push($root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.decode(reader, reader.uint32())); + message.segments.push($root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -28804,22 +31431,26 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Snippet.verify = function verify(message) { + Snippet.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.regionTag != null && message.hasOwnProperty("regionTag")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.regionTag != null && Object.hasOwnProperty.call(message, "regionTag")) if (!$util.isString(message.regionTag)) return "regionTag: string expected"; - if (message.title != null && message.hasOwnProperty("title")) + if (message.title != null && Object.hasOwnProperty.call(message, "title")) if (!$util.isString(message.title)) return "title: string expected"; - if (message.description != null && message.hasOwnProperty("description")) + if (message.description != null && Object.hasOwnProperty.call(message, "description")) if (!$util.isString(message.description)) return "description: string expected"; - if (message.file != null && message.hasOwnProperty("file")) + if (message.file != null && Object.hasOwnProperty.call(message, "file")) if (!$util.isString(message.file)) return "file: string expected"; - if (message.language != null && message.hasOwnProperty("language")) + if (message.language != null && Object.hasOwnProperty.call(message, "language")) switch (message.language) { default: return "language: enum value expected"; @@ -28843,15 +31474,15 @@ case 17: break; } - if (message.clientMethod != null && message.hasOwnProperty("clientMethod")) { - var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.verify(message.clientMethod); + if (message.clientMethod != null && Object.hasOwnProperty.call(message, "clientMethod")) { + var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.verify(message.clientMethod, long + 1); if (error) return "clientMethod." + error; } - if (message.canonical != null && message.hasOwnProperty("canonical")) + if (message.canonical != null && Object.hasOwnProperty.call(message, "canonical")) if (typeof message.canonical !== "boolean") return "canonical: boolean expected"; - if (message.origin != null && message.hasOwnProperty("origin")) + if (message.origin != null && Object.hasOwnProperty.call(message, "origin")) switch (message.origin) { default: return "origin: enum value expected"; @@ -28861,11 +31492,11 @@ case 3: break; } - if (message.segments != null && message.hasOwnProperty("segments")) { + if (message.segments != null && Object.hasOwnProperty.call(message, "segments")) { if (!Array.isArray(message.segments)) return "segments: array expected"; for (var i = 0; i < message.segments.length; ++i) { - var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.verify(message.segments[i]); + var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.verify(message.segments[i], long + 1); if (error) return "segments." + error; } @@ -28881,9 +31512,15 @@ * @param {Object.} object Plain object * @returns {google.cloud.tools.snippetgen.snippetindex.v1.Snippet} Snippet */ - Snippet.fromObject = function fromObject(object) { + Snippet.fromObject = function fromObject(object, long) { if (object instanceof $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet) return object; + if (!$util.isObject(object)) + throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Snippet: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet(); if (object.regionTag != null) message.regionTag = String(object.regionTag); @@ -28974,9 +31611,9 @@ break; } if (object.clientMethod != null) { - if (typeof object.clientMethod !== "object") + if (!$util.isObject(object.clientMethod)) throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Snippet.clientMethod: object expected"); - message.clientMethod = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.fromObject(object.clientMethod); + message.clientMethod = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.fromObject(object.clientMethod, long + 1); } if (object.canonical != null) message.canonical = Boolean(object.canonical); @@ -29009,9 +31646,9 @@ throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Snippet.segments: array expected"); message.segments = []; for (var i = 0; i < object.segments.length; ++i) { - if (typeof object.segments[i] !== "object") + if (!$util.isObject(object.segments[i])) throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Snippet.segments: object expected"); - message.segments[i] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.fromObject(object.segments[i]); + message.segments[i] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.fromObject(object.segments[i], long + 1); } } return message; @@ -29026,9 +31663,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Snippet.toObject = function toObject(message, options) { + Snippet.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.segments = []; @@ -29042,26 +31683,26 @@ object.canonical = false; object.origin = options.enums === String ? "ORIGIN_UNSPECIFIED" : 0; } - if (message.regionTag != null && message.hasOwnProperty("regionTag")) + if (message.regionTag != null && Object.hasOwnProperty.call(message, "regionTag")) object.regionTag = message.regionTag; - if (message.title != null && message.hasOwnProperty("title")) + if (message.title != null && Object.hasOwnProperty.call(message, "title")) object.title = message.title; - if (message.description != null && message.hasOwnProperty("description")) + if (message.description != null && Object.hasOwnProperty.call(message, "description")) object.description = message.description; - if (message.file != null && message.hasOwnProperty("file")) + if (message.file != null && Object.hasOwnProperty.call(message, "file")) object.file = message.file; - if (message.language != null && message.hasOwnProperty("language")) + if (message.language != null && Object.hasOwnProperty.call(message, "language")) object.language = options.enums === String ? $root.google.cloud.tools.snippetgen.snippetindex.v1.Language[message.language] === undefined ? message.language : $root.google.cloud.tools.snippetgen.snippetindex.v1.Language[message.language] : message.language; - if (message.clientMethod != null && message.hasOwnProperty("clientMethod")) - object.clientMethod = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.toObject(message.clientMethod, options); - if (message.canonical != null && message.hasOwnProperty("canonical")) + if (message.clientMethod != null && Object.hasOwnProperty.call(message, "clientMethod")) + object.clientMethod = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.toObject(message.clientMethod, options, q + 1); + if (message.canonical != null && Object.hasOwnProperty.call(message, "canonical")) object.canonical = message.canonical; - if (message.origin != null && message.hasOwnProperty("origin")) + if (message.origin != null && Object.hasOwnProperty.call(message, "origin")) object.origin = options.enums === String ? $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Origin[message.origin] === undefined ? message.origin : $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Origin[message.origin] : message.origin; if (message.segments && message.segments.length) { object.segments = []; for (var j = 0; j < message.segments.length; ++j) - object.segments[j] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.toObject(message.segments[j], options); + object.segments[j] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.toObject(message.segments[j], options, q + 1); } return object; }; @@ -29132,7 +31773,7 @@ function Segment(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -29181,9 +31822,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Segment.encode = function encode(message, writer) { + Segment.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.start != null && Object.hasOwnProperty.call(message, "start")) writer.uint32(/* id 1, wireType 0 =*/8).int32(message.start); if (message.end != null && Object.hasOwnProperty.call(message, "end")) @@ -29217,12 +31862,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Segment.decode = function decode(reader, length) { + Segment.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.start = reader.int32(); @@ -29237,7 +31888,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -29268,16 +31919,20 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Segment.verify = function verify(message) { + Segment.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.start != null && message.hasOwnProperty("start")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.start != null && Object.hasOwnProperty.call(message, "start")) if (!$util.isInteger(message.start)) return "start: integer expected"; - if (message.end != null && message.hasOwnProperty("end")) + if (message.end != null && Object.hasOwnProperty.call(message, "end")) if (!$util.isInteger(message.end)) return "end: integer expected"; - if (message.type != null && message.hasOwnProperty("type")) + if (message.type != null && Object.hasOwnProperty.call(message, "type")) switch (message.type) { default: return "type: enum value expected"; @@ -29301,9 +31956,15 @@ * @param {Object.} object Plain object * @returns {google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment} Segment */ - Segment.fromObject = function fromObject(object) { + Segment.fromObject = function fromObject(object, long) { if (object instanceof $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment) return object; + if (!$util.isObject(object)) + throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment(); if (object.start != null) message.start = object.start | 0; @@ -29357,20 +32018,24 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Segment.toObject = function toObject(message, options) { + Segment.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.start = 0; object.end = 0; object.type = options.enums === String ? "SEGMENT_TYPE_UNSPECIFIED" : 0; } - if (message.start != null && message.hasOwnProperty("start")) + if (message.start != null && Object.hasOwnProperty.call(message, "start")) object.start = message.start; - if (message.end != null && message.hasOwnProperty("end")) + if (message.end != null && Object.hasOwnProperty.call(message, "end")) object.end = message.end; - if (message.type != null && message.hasOwnProperty("type")) + if (message.type != null && Object.hasOwnProperty.call(message, "type")) object.type = options.enums === String ? $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.SegmentType[message.type] === undefined ? message.type : $root.google.cloud.tools.snippetgen.snippetindex.v1.Snippet.Segment.SegmentType[message.type] : message.type; return object; }; @@ -29458,7 +32123,7 @@ this.parameters = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -29539,9 +32204,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ClientMethod.encode = function encode(message, writer) { + ClientMethod.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.shortName); if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) @@ -29550,13 +32219,13 @@ writer.uint32(/* id 3, wireType 0 =*/24).bool(message.async); if (message.parameters != null && message.parameters.length) for (var i = 0; i < message.parameters.length; ++i) - $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter.encode(message.parameters[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter.encode(message.parameters[i], writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); if (message.resultType != null && Object.hasOwnProperty.call(message, "resultType")) writer.uint32(/* id 5, wireType 2 =*/42).string(message.resultType); if (message.client != null && Object.hasOwnProperty.call(message, "client")) - $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient.encode(message.client, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim(); + $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient.encode(message.client, writer.uint32(/* id 6, wireType 2 =*/50).fork(), q + 1).ldelim(); if (message.method != null && Object.hasOwnProperty.call(message, "method")) - $root.google.cloud.tools.snippetgen.snippetindex.v1.Method.encode(message.method, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim(); + $root.google.cloud.tools.snippetgen.snippetindex.v1.Method.encode(message.method, writer.uint32(/* id 7, wireType 2 =*/58).fork(), q + 1).ldelim(); return writer; }; @@ -29584,12 +32253,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ClientMethod.decode = function decode(reader, length) { + ClientMethod.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.shortName = reader.string(); @@ -29606,7 +32281,7 @@ case 4: { if (!(message.parameters && message.parameters.length)) message.parameters = []; - message.parameters.push($root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter.decode(reader, reader.uint32())); + message.parameters.push($root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter.decode(reader, reader.uint32(), undefined, long + 1)); break; } case 5: { @@ -29614,15 +32289,15 @@ break; } case 6: { - message.client = $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient.decode(reader, reader.uint32()); + message.client = $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient.decode(reader, reader.uint32(), undefined, long + 1); break; } case 7: { - message.method = $root.google.cloud.tools.snippetgen.snippetindex.v1.Method.decode(reader, reader.uint32()); + message.method = $root.google.cloud.tools.snippetgen.snippetindex.v1.Method.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -29653,37 +32328,41 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ClientMethod.verify = function verify(message) { + ClientMethod.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.shortName != null && message.hasOwnProperty("shortName")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) if (!$util.isString(message.shortName)) return "shortName: string expected"; - if (message.fullName != null && message.hasOwnProperty("fullName")) + if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) if (!$util.isString(message.fullName)) return "fullName: string expected"; - if (message.async != null && message.hasOwnProperty("async")) + if (message.async != null && Object.hasOwnProperty.call(message, "async")) if (typeof message.async !== "boolean") return "async: boolean expected"; - if (message.parameters != null && message.hasOwnProperty("parameters")) { + if (message.parameters != null && Object.hasOwnProperty.call(message, "parameters")) { if (!Array.isArray(message.parameters)) return "parameters: array expected"; for (var i = 0; i < message.parameters.length; ++i) { - var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter.verify(message.parameters[i]); + var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter.verify(message.parameters[i], long + 1); if (error) return "parameters." + error; } } - if (message.resultType != null && message.hasOwnProperty("resultType")) + if (message.resultType != null && Object.hasOwnProperty.call(message, "resultType")) if (!$util.isString(message.resultType)) return "resultType: string expected"; - if (message.client != null && message.hasOwnProperty("client")) { - var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient.verify(message.client); + if (message.client != null && Object.hasOwnProperty.call(message, "client")) { + var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient.verify(message.client, long + 1); if (error) return "client." + error; } - if (message.method != null && message.hasOwnProperty("method")) { - var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.Method.verify(message.method); + if (message.method != null && Object.hasOwnProperty.call(message, "method")) { + var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.Method.verify(message.method, long + 1); if (error) return "method." + error; } @@ -29698,9 +32377,15 @@ * @param {Object.} object Plain object * @returns {google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod} ClientMethod */ - ClientMethod.fromObject = function fromObject(object) { + ClientMethod.fromObject = function fromObject(object, long) { if (object instanceof $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod) return object; + if (!$util.isObject(object)) + throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod(); if (object.shortName != null) message.shortName = String(object.shortName); @@ -29713,22 +32398,22 @@ throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.parameters: array expected"); message.parameters = []; for (var i = 0; i < object.parameters.length; ++i) { - if (typeof object.parameters[i] !== "object") + if (!$util.isObject(object.parameters[i])) throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.parameters: object expected"); - message.parameters[i] = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter.fromObject(object.parameters[i]); + message.parameters[i] = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter.fromObject(object.parameters[i], long + 1); } } if (object.resultType != null) message.resultType = String(object.resultType); if (object.client != null) { - if (typeof object.client !== "object") + if (!$util.isObject(object.client)) throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.client: object expected"); - message.client = $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient.fromObject(object.client); + message.client = $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient.fromObject(object.client, long + 1); } if (object.method != null) { - if (typeof object.method !== "object") + if (!$util.isObject(object.method)) throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.method: object expected"); - message.method = $root.google.cloud.tools.snippetgen.snippetindex.v1.Method.fromObject(object.method); + message.method = $root.google.cloud.tools.snippetgen.snippetindex.v1.Method.fromObject(object.method, long + 1); } return message; }; @@ -29742,9 +32427,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ClientMethod.toObject = function toObject(message, options) { + ClientMethod.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.parameters = []; @@ -29756,23 +32445,23 @@ object.client = null; object.method = null; } - if (message.shortName != null && message.hasOwnProperty("shortName")) + if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) object.shortName = message.shortName; - if (message.fullName != null && message.hasOwnProperty("fullName")) + if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) object.fullName = message.fullName; - if (message.async != null && message.hasOwnProperty("async")) + if (message.async != null && Object.hasOwnProperty.call(message, "async")) object.async = message.async; if (message.parameters && message.parameters.length) { object.parameters = []; for (var j = 0; j < message.parameters.length; ++j) - object.parameters[j] = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter.toObject(message.parameters[j], options); + object.parameters[j] = $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter.toObject(message.parameters[j], options, q + 1); } - if (message.resultType != null && message.hasOwnProperty("resultType")) + if (message.resultType != null && Object.hasOwnProperty.call(message, "resultType")) object.resultType = message.resultType; - if (message.client != null && message.hasOwnProperty("client")) - object.client = $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient.toObject(message.client, options); - if (message.method != null && message.hasOwnProperty("method")) - object.method = $root.google.cloud.tools.snippetgen.snippetindex.v1.Method.toObject(message.method, options); + if (message.client != null && Object.hasOwnProperty.call(message, "client")) + object.client = $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient.toObject(message.client, options, q + 1); + if (message.method != null && Object.hasOwnProperty.call(message, "method")) + object.method = $root.google.cloud.tools.snippetgen.snippetindex.v1.Method.toObject(message.method, options, q + 1); return object; }; @@ -29823,7 +32512,7 @@ function Parameter(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -29864,9 +32553,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Parameter.encode = function encode(message, writer) { + Parameter.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.type != null && Object.hasOwnProperty.call(message, "type")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.type); if (message.name != null && Object.hasOwnProperty.call(message, "name")) @@ -29898,12 +32591,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Parameter.decode = function decode(reader, length) { + Parameter.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.type = reader.string(); @@ -29914,7 +32613,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -29945,13 +32644,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Parameter.verify = function verify(message) { + Parameter.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.type != null && message.hasOwnProperty("type")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.type != null && Object.hasOwnProperty.call(message, "type")) if (!$util.isString(message.type)) return "type: string expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; return null; @@ -29965,9 +32668,15 @@ * @param {Object.} object Plain object * @returns {google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter} Parameter */ - Parameter.fromObject = function fromObject(object) { + Parameter.fromObject = function fromObject(object, long) { if (object instanceof $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter) return object; + if (!$util.isObject(object)) + throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientMethod.Parameter(); if (object.type != null) message.type = String(object.type); @@ -29985,17 +32694,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Parameter.toObject = function toObject(message, options) { + Parameter.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.type = ""; object.name = ""; } - if (message.type != null && message.hasOwnProperty("type")) + if (message.type != null && Object.hasOwnProperty.call(message, "type")) object.type = message.type; - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; return object; }; @@ -30053,7 +32766,7 @@ function ServiceClient(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -30094,9 +32807,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ServiceClient.encode = function encode(message, writer) { + ServiceClient.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.shortName); if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) @@ -30128,12 +32845,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ServiceClient.decode = function decode(reader, length) { + ServiceClient.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.shortName = reader.string(); @@ -30144,7 +32867,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -30175,13 +32898,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ServiceClient.verify = function verify(message) { + ServiceClient.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.shortName != null && message.hasOwnProperty("shortName")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) if (!$util.isString(message.shortName)) return "shortName: string expected"; - if (message.fullName != null && message.hasOwnProperty("fullName")) + if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) if (!$util.isString(message.fullName)) return "fullName: string expected"; return null; @@ -30195,9 +32922,15 @@ * @param {Object.} object Plain object * @returns {google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient} ServiceClient */ - ServiceClient.fromObject = function fromObject(object) { + ServiceClient.fromObject = function fromObject(object, long) { if (object instanceof $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient) return object; + if (!$util.isObject(object)) + throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.ServiceClient(); if (object.shortName != null) message.shortName = String(object.shortName); @@ -30215,17 +32948,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ServiceClient.toObject = function toObject(message, options) { + ServiceClient.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.shortName = ""; object.fullName = ""; } - if (message.shortName != null && message.hasOwnProperty("shortName")) + if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) object.shortName = message.shortName; - if (message.fullName != null && message.hasOwnProperty("fullName")) + if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) object.fullName = message.fullName; return object; }; @@ -30283,7 +33020,7 @@ this.apis = []; if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -30340,9 +33077,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - ClientLibrary.encode = function encode(message, writer) { + ClientLibrary.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.name); if (message.version != null && Object.hasOwnProperty.call(message, "version")) @@ -30351,7 +33092,7 @@ writer.uint32(/* id 3, wireType 0 =*/24).int32(message.language); if (message.apis != null && message.apis.length) for (var i = 0; i < message.apis.length; ++i) - $root.google.cloud.tools.snippetgen.snippetindex.v1.Api.encode(message.apis[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + $root.google.cloud.tools.snippetgen.snippetindex.v1.Api.encode(message.apis[i], writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim(); return writer; }; @@ -30379,12 +33120,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - ClientLibrary.decode = function decode(reader, length) { + ClientLibrary.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.name = reader.string(); @@ -30401,11 +33148,11 @@ case 4: { if (!(message.apis && message.apis.length)) message.apis = []; - message.apis.push($root.google.cloud.tools.snippetgen.snippetindex.v1.Api.decode(reader, reader.uint32())); + message.apis.push($root.google.cloud.tools.snippetgen.snippetindex.v1.Api.decode(reader, reader.uint32(), undefined, long + 1)); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -30436,16 +33183,20 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - ClientLibrary.verify = function verify(message) { + ClientLibrary.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.name != null && message.hasOwnProperty("name")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.name != null && Object.hasOwnProperty.call(message, "name")) if (!$util.isString(message.name)) return "name: string expected"; - if (message.version != null && message.hasOwnProperty("version")) + if (message.version != null && Object.hasOwnProperty.call(message, "version")) if (!$util.isString(message.version)) return "version: string expected"; - if (message.language != null && message.hasOwnProperty("language")) + if (message.language != null && Object.hasOwnProperty.call(message, "language")) switch (message.language) { default: return "language: enum value expected"; @@ -30469,11 +33220,11 @@ case 17: break; } - if (message.apis != null && message.hasOwnProperty("apis")) { + if (message.apis != null && Object.hasOwnProperty.call(message, "apis")) { if (!Array.isArray(message.apis)) return "apis: array expected"; for (var i = 0; i < message.apis.length; ++i) { - var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.Api.verify(message.apis[i]); + var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.Api.verify(message.apis[i], long + 1); if (error) return "apis." + error; } @@ -30489,9 +33240,15 @@ * @param {Object.} object Plain object * @returns {google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary} ClientLibrary */ - ClientLibrary.fromObject = function fromObject(object) { + ClientLibrary.fromObject = function fromObject(object, long) { if (object instanceof $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary) return object; + if (!$util.isObject(object)) + throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary(); if (object.name != null) message.name = String(object.name); @@ -30582,9 +33339,9 @@ throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.apis: array expected"); message.apis = []; for (var i = 0; i < object.apis.length; ++i) { - if (typeof object.apis[i] !== "object") + if (!$util.isObject(object.apis[i])) throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.ClientLibrary.apis: object expected"); - message.apis[i] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Api.fromObject(object.apis[i]); + message.apis[i] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Api.fromObject(object.apis[i], long + 1); } } return message; @@ -30599,9 +33356,13 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - ClientLibrary.toObject = function toObject(message, options) { + ClientLibrary.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.arrays || options.defaults) object.apis = []; @@ -30610,16 +33371,16 @@ object.version = ""; object.language = options.enums === String ? "LANGUAGE_UNSPECIFIED" : 0; } - if (message.name != null && message.hasOwnProperty("name")) + if (message.name != null && Object.hasOwnProperty.call(message, "name")) object.name = message.name; - if (message.version != null && message.hasOwnProperty("version")) + if (message.version != null && Object.hasOwnProperty.call(message, "version")) object.version = message.version; - if (message.language != null && message.hasOwnProperty("language")) + if (message.language != null && Object.hasOwnProperty.call(message, "language")) object.language = options.enums === String ? $root.google.cloud.tools.snippetgen.snippetindex.v1.Language[message.language] === undefined ? message.language : $root.google.cloud.tools.snippetgen.snippetindex.v1.Language[message.language] : message.language; if (message.apis && message.apis.length) { object.apis = []; for (var j = 0; j < message.apis.length; ++j) - object.apis[j] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Api.toObject(message.apis[j], options); + object.apis[j] = $root.google.cloud.tools.snippetgen.snippetindex.v1.Api.toObject(message.apis[j], options, q + 1); } return object; }; @@ -30675,7 +33436,7 @@ function Method(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -30724,15 +33485,19 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Method.encode = function encode(message, writer) { + Method.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.shortName); if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) writer.uint32(/* id 2, wireType 2 =*/18).string(message.fullName); if (message.service != null && Object.hasOwnProperty.call(message, "service")) - $root.google.cloud.tools.snippetgen.snippetindex.v1.Service.encode(message.service, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + $root.google.cloud.tools.snippetgen.snippetindex.v1.Service.encode(message.service, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim(); return writer; }; @@ -30760,12 +33525,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Method.decode = function decode(reader, length) { + Method.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Method(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.shortName = reader.string(); @@ -30776,11 +33547,11 @@ break; } case 3: { - message.service = $root.google.cloud.tools.snippetgen.snippetindex.v1.Service.decode(reader, reader.uint32()); + message.service = $root.google.cloud.tools.snippetgen.snippetindex.v1.Service.decode(reader, reader.uint32(), undefined, long + 1); break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -30811,17 +33582,21 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Method.verify = function verify(message) { + Method.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.shortName != null && message.hasOwnProperty("shortName")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) if (!$util.isString(message.shortName)) return "shortName: string expected"; - if (message.fullName != null && message.hasOwnProperty("fullName")) + if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) if (!$util.isString(message.fullName)) return "fullName: string expected"; - if (message.service != null && message.hasOwnProperty("service")) { - var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.Service.verify(message.service); + if (message.service != null && Object.hasOwnProperty.call(message, "service")) { + var error = $root.google.cloud.tools.snippetgen.snippetindex.v1.Service.verify(message.service, long + 1); if (error) return "service." + error; } @@ -30836,18 +33611,24 @@ * @param {Object.} object Plain object * @returns {google.cloud.tools.snippetgen.snippetindex.v1.Method} Method */ - Method.fromObject = function fromObject(object) { + Method.fromObject = function fromObject(object, long) { if (object instanceof $root.google.cloud.tools.snippetgen.snippetindex.v1.Method) return object; + if (!$util.isObject(object)) + throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Method: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Method(); if (object.shortName != null) message.shortName = String(object.shortName); if (object.fullName != null) message.fullName = String(object.fullName); if (object.service != null) { - if (typeof object.service !== "object") + if (!$util.isObject(object.service)) throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Method.service: object expected"); - message.service = $root.google.cloud.tools.snippetgen.snippetindex.v1.Service.fromObject(object.service); + message.service = $root.google.cloud.tools.snippetgen.snippetindex.v1.Service.fromObject(object.service, long + 1); } return message; }; @@ -30861,21 +33642,25 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Method.toObject = function toObject(message, options) { + Method.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.shortName = ""; object.fullName = ""; object.service = null; } - if (message.shortName != null && message.hasOwnProperty("shortName")) + if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) object.shortName = message.shortName; - if (message.fullName != null && message.hasOwnProperty("fullName")) + if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) object.fullName = message.fullName; - if (message.service != null && message.hasOwnProperty("service")) - object.service = $root.google.cloud.tools.snippetgen.snippetindex.v1.Service.toObject(message.service, options); + if (message.service != null && Object.hasOwnProperty.call(message, "service")) + object.service = $root.google.cloud.tools.snippetgen.snippetindex.v1.Service.toObject(message.service, options, q + 1); return object; }; @@ -30929,7 +33714,7 @@ function Service(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -30970,9 +33755,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Service.encode = function encode(message, writer) { + Service.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.shortName); if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) @@ -31004,12 +33793,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Service.decode = function decode(reader, length) { + Service.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Service(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.shortName = reader.string(); @@ -31020,7 +33815,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -31051,13 +33846,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Service.verify = function verify(message) { + Service.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.shortName != null && message.hasOwnProperty("shortName")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) if (!$util.isString(message.shortName)) return "shortName: string expected"; - if (message.fullName != null && message.hasOwnProperty("fullName")) + if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) if (!$util.isString(message.fullName)) return "fullName: string expected"; return null; @@ -31071,9 +33870,15 @@ * @param {Object.} object Plain object * @returns {google.cloud.tools.snippetgen.snippetindex.v1.Service} Service */ - Service.fromObject = function fromObject(object) { + Service.fromObject = function fromObject(object, long) { if (object instanceof $root.google.cloud.tools.snippetgen.snippetindex.v1.Service) return object; + if (!$util.isObject(object)) + throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Service: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Service(); if (object.shortName != null) message.shortName = String(object.shortName); @@ -31091,17 +33896,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Service.toObject = function toObject(message, options) { + Service.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.shortName = ""; object.fullName = ""; } - if (message.shortName != null && message.hasOwnProperty("shortName")) + if (message.shortName != null && Object.hasOwnProperty.call(message, "shortName")) object.shortName = message.shortName; - if (message.fullName != null && message.hasOwnProperty("fullName")) + if (message.fullName != null && Object.hasOwnProperty.call(message, "fullName")) object.fullName = message.fullName; return object; }; @@ -31156,7 +33965,7 @@ function Api(properties) { if (properties) for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) - if (properties[keys[i]] != null) + if (properties[keys[i]] != null && keys[i] !== "__proto__") this[keys[i]] = properties[keys[i]]; } @@ -31197,9 +34006,13 @@ * @param {$protobuf.Writer} [writer] Writer to encode to * @returns {$protobuf.Writer} Writer */ - Api.encode = function encode(message, writer) { + Api.encode = function encode(message, writer, q) { if (!writer) writer = $Writer.create(); + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); if (message.id != null && Object.hasOwnProperty.call(message, "id")) writer.uint32(/* id 1, wireType 2 =*/10).string(message.id); if (message.version != null && Object.hasOwnProperty.call(message, "version")) @@ -31231,12 +34044,18 @@ * @throws {Error} If the payload is not a reader or valid buffer * @throws {$protobuf.util.ProtocolError} If required fields are missing */ - Api.decode = function decode(reader, length) { + Api.decode = function decode(reader, length, error, long) { if (!(reader instanceof $Reader)) reader = $Reader.create(reader); + if (long === undefined) + long = 0; + if (long > $Reader.recursionLimit) + throw Error("maximum nesting depth exceeded"); var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Api(); while (reader.pos < end) { var tag = reader.uint32(); + if (tag === error) + break; switch (tag >>> 3) { case 1: { message.id = reader.string(); @@ -31247,7 +34066,7 @@ break; } default: - reader.skipType(tag & 7); + reader.skipType(tag & 7, long); break; } } @@ -31278,13 +34097,17 @@ * @param {Object.} message Plain object to verify * @returns {string|null} `null` if valid, otherwise the reason why it is not */ - Api.verify = function verify(message) { + Api.verify = function verify(message, long) { if (typeof message !== "object" || message === null) return "object expected"; - if (message.id != null && message.hasOwnProperty("id")) + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + return "maximum nesting depth exceeded"; + if (message.id != null && Object.hasOwnProperty.call(message, "id")) if (!$util.isString(message.id)) return "id: string expected"; - if (message.version != null && message.hasOwnProperty("version")) + if (message.version != null && Object.hasOwnProperty.call(message, "version")) if (!$util.isString(message.version)) return "version: string expected"; return null; @@ -31298,9 +34121,15 @@ * @param {Object.} object Plain object * @returns {google.cloud.tools.snippetgen.snippetindex.v1.Api} Api */ - Api.fromObject = function fromObject(object) { + Api.fromObject = function fromObject(object, long) { if (object instanceof $root.google.cloud.tools.snippetgen.snippetindex.v1.Api) return object; + if (!$util.isObject(object)) + throw TypeError(".google.cloud.tools.snippetgen.snippetindex.v1.Api: object expected"); + if (long === undefined) + long = 0; + if (long > $util.recursionLimit) + throw Error("maximum nesting depth exceeded"); var message = new $root.google.cloud.tools.snippetgen.snippetindex.v1.Api(); if (object.id != null) message.id = String(object.id); @@ -31318,17 +34147,21 @@ * @param {$protobuf.IConversionOptions} [options] Conversion options * @returns {Object.} Plain object */ - Api.toObject = function toObject(message, options) { + Api.toObject = function toObject(message, options, q) { if (!options) options = {}; + if (q === undefined) + q = 0; + if (q > $util.recursionLimit) + throw Error("max depth exceeded"); var object = {}; if (options.defaults) { object.id = ""; object.version = ""; } - if (message.id != null && message.hasOwnProperty("id")) + if (message.id != null && Object.hasOwnProperty.call(message, "id")) object.id = message.id; - if (message.version != null && message.hasOwnProperty("version")) + if (message.version != null && Object.hasOwnProperty.call(message, "version")) object.version = message.version; return object; }; diff --git a/core/generator/gapic-generator-typescript/protos/protos.json b/core/generator/gapic-generator-typescript/protos/protos.json index 40151c1e0c4e..dbe17aee3d83 100644 --- a/core/generator/gapic-generator-typescript/protos/protos.json +++ b/core/generator/gapic-generator-typescript/protos/protos.json @@ -389,6 +389,44 @@ } } }, + "MediaUpload": { + "fields": { + "enabled": { + "type": "bool", + "id": 1 + }, + "mediaUploadPaths": { + "rule": "repeated", + "type": "string", + "id": 2 + }, + "startNotification": { + "type": "bool", + "id": 3 + }, + "uploadNotification": { + "type": "bool", + "id": 4 + }, + "finalizeNotification": { + "type": "bool", + "id": 5 + }, + "directUploadService": { + "type": "string", + "id": 6 + }, + "maxUploadSessionDurationSeconds": { + "type": "int64", + "id": 7 + } + } + }, + "mediaUpload": { + "type": "MediaUpload", + "id": 1052, + "extend": "google.protobuf.MethodOptions" + }, "resourceReference": { "type": "google.api.ResourceReference", "id": 1055, @@ -810,6 +848,7 @@ }, "nested": { "FileDescriptorSet": { + "edition": "proto2", "fields": { "file": { "rule": "repeated", @@ -819,6 +858,7 @@ } }, "Edition": { + "edition": "proto2", "values": { "EDITION_UNKNOWN": 0, "EDITION_PROTO2": 998, @@ -834,6 +874,7 @@ } }, "FileDescriptorProto": { + "edition": "proto2", "fields": { "name": { "type": "string", @@ -851,18 +892,12 @@ "publicDependency": { "rule": "repeated", "type": "int32", - "id": 10, - "options": { - "packed": false - } + "id": 10 }, "weakDependency": { "rule": "repeated", "type": "int32", - "id": 11, - "options": { - "packed": false - } + "id": 11 }, "messageType": { "rule": "repeated", @@ -903,6 +938,7 @@ } }, "DescriptorProto": { + "edition": "proto2", "fields": { "name": { "type": "string", @@ -985,6 +1021,7 @@ } }, "ExtensionRangeOptions": { + "edition": "proto2", "fields": { "uninterpretedOption": { "rule": "repeated", @@ -1058,6 +1095,7 @@ } }, "FieldDescriptorProto": { + "edition": "proto2", "fields": { "name": { "type": "string", @@ -1137,6 +1175,7 @@ } }, "OneofDescriptorProto": { + "edition": "proto2", "fields": { "name": { "type": "string", @@ -1149,6 +1188,7 @@ } }, "EnumDescriptorProto": { + "edition": "proto2", "fields": { "name": { "type": "string", @@ -1190,6 +1230,7 @@ } }, "EnumValueDescriptorProto": { + "edition": "proto2", "fields": { "name": { "type": "string", @@ -1206,6 +1247,7 @@ } }, "ServiceDescriptorProto": { + "edition": "proto2", "fields": { "name": { "type": "string", @@ -1223,6 +1265,7 @@ } }, "MethodDescriptorProto": { + "edition": "proto2", "fields": { "name": { "type": "string", @@ -1257,6 +1300,7 @@ } }, "FileOptions": { + "edition": "proto2", "fields": { "javaPackage": { "type": "string", @@ -1398,6 +1442,7 @@ } }, "MessageOptions": { + "edition": "proto2", "fields": { "messageSetWireFormat": { "type": "bool", @@ -1471,6 +1516,7 @@ ] }, "FieldOptions": { + "edition": "proto2", "fields": { "ctype": { "type": "CType", @@ -1532,10 +1578,7 @@ "targets": { "rule": "repeated", "type": "OptionTargetType", - "id": 19, - "options": { - "packed": false - } + "id": 19 }, "editionDefaults": { "rule": "repeated", @@ -1619,6 +1662,7 @@ } }, "OneofOptions": { + "edition": "proto2", "fields": { "features": { "type": "FeatureSet", @@ -1638,6 +1682,7 @@ ] }, "EnumOptions": { + "edition": "proto2", "fields": { "allowAlias": { "type": "bool", @@ -1681,6 +1726,7 @@ ] }, "EnumValueOptions": { + "edition": "proto2", "fields": { "deprecated": { "type": "bool", @@ -1714,6 +1760,7 @@ ] }, "ServiceOptions": { + "edition": "proto2", "fields": { "features": { "type": "FeatureSet", @@ -1740,6 +1787,7 @@ ] }, "MethodOptions": { + "edition": "proto2", "fields": { "deprecated": { "type": "bool", @@ -1782,6 +1830,7 @@ } }, "UninterpretedOption": { + "edition": "proto2", "fields": { "name": { "rule": "repeated", @@ -1831,6 +1880,7 @@ } }, "FeatureSet": { + "edition": "proto2", "fields": { "fieldPresence": { "type": "FieldPresence", @@ -1972,6 +2022,7 @@ } }, "FeatureSetDefaults": { + "edition": "proto2", "fields": { "defaults": { "rule": "repeated", @@ -2003,6 +2054,7 @@ } }, "SourceCodeInfo": { + "edition": "proto2", "fields": { "location": { "rule": "repeated", @@ -2016,12 +2068,18 @@ "path": { "rule": "repeated", "type": "int32", - "id": 1 + "id": 1, + "options": { + "packed": true + } }, "span": { "rule": "repeated", "type": "int32", - "id": 2 + "id": 2, + "options": { + "packed": true + } }, "leadingComments": { "type": "string", @@ -2041,6 +2099,7 @@ } }, "GeneratedCodeInfo": { + "edition": "proto2", "fields": { "annotation": { "rule": "repeated", @@ -2054,7 +2113,10 @@ "path": { "rule": "repeated", "type": "int32", - "id": 1 + "id": 1, + "options": { + "packed": true + } }, "sourceFile": { "type": "string", @@ -2121,6 +2183,7 @@ }, "nested": { "Version": { + "edition": "proto2", "fields": { "major": { "type": "int32", @@ -2141,6 +2204,7 @@ } }, "CodeGeneratorRequest": { + "edition": "proto2", "fields": { "fileToGenerate": { "rule": "repeated", @@ -2168,6 +2232,7 @@ } }, "CodeGeneratorResponse": { + "edition": "proto2", "fields": { "error": { "type": "string", diff --git a/core/generator/gapic-generator-typescript/templates/cjs/typescript_gapic/src/$version/$service_client.ts.njk b/core/generator/gapic-generator-typescript/templates/cjs/typescript_gapic/src/$version/$service_client.ts.njk index 90553e89770f..b7fa78752de1 100644 --- a/core/generator/gapic-generator-typescript/templates/cjs/typescript_gapic/src/$version/$service_client.ts.njk +++ b/core/generator/gapic-generator-typescript/templates/cjs/typescript_gapic/src/$version/$service_client.ts.njk @@ -78,6 +78,9 @@ export class {{ service.name }}Client { private _providedCustomServicePath: boolean; private _gaxModule: typeof gax{% if not api.legacyProtoLoad %} | typeof gax.fallback{% endif %}; private _gaxGrpc: gax.GrpcClient{% if not api.legacyProtoLoad %} | gax.fallback.GrpcClient{% endif %}; +{%- if not api.legacyProtoLoad and service.resumableUploads.length > 0 %} + private _fallbackRest?: gax.GrpcClient | gax.fallback.GrpcClient; +{%- endif %} private _protos: {}; private _defaults: {[method: string]: gax.CallSettings}; private _universeDomain: string; @@ -90,6 +93,9 @@ export class {{ service.name }}Client { stream: {}, longrunning: {}, batching: {}, +{%- if not api.legacyProtoLoad and service.resumableUploads.length > 0 %} + resumableUpload: {}, +{%- endif %} }; warn: (code: string, message: string, warnType?: string) => void; innerApiCalls: {[name: string]: Function}; @@ -202,6 +208,15 @@ export class {{ service.name }}Client { // Create a `gaxGrpc` object, with any grpc-specific options sent to the client. this._gaxGrpc = new this._gaxModule.GrpcClient(opts); +{%- if not api.legacyProtoLoad and service.resumableUploads.length > 0 %} + + // This service contains resumable upload methods, which are HTTPS-only. + // Make sure the REST transport is available even when the client was + // configured for gRPC. + this._fallbackRest = opts.fallback + ? this._gaxGrpc + : new gaxInstance.fallback.GrpcClient({...opts, fallback: true}); +{%- endif %} // Save options to use in {{ id.get("initialize") }}() method. this._opts = opts; @@ -390,6 +405,21 @@ export class {{ service.name }}Client { {%- endfor %} {%- endif %} +{%- if not api.legacyProtoLoad and service.resumableUploads.length > 0 %} + + // Some methods on this API support resumable uploads; provide + // descriptors for these methods. + this.descriptors.resumableUpload = { +{%- set resumableUploadJoiner = joiner() %} +{%- for method in service.resumableUploads %} + {{- resumableUploadJoiner() }} + {{ method.name.toCamelCase() }}: new this._gaxModule.ResumableUploadDescriptor( + '{{ method.resumableUpload.uploadPrefix }}' + ) +{%- endfor %} + }; +{%- endif %} + // Put together the default options sent with requests. this._defaults = this._gaxGrpc.constructSettings( '{{ api.naming.protoPackage }}.{{ service.name }}', gapicConfig as gax.ClientConfig, @@ -438,10 +468,10 @@ export class {{ service.name }}Client { (this._protos as any).{{api.naming.protoPackage}}.{{ service.name }}, this._opts, this._providedCustomServicePath) as Promise<{[method: string]: Function}>; - {%- set stubMethodsContent %} +{%- set stubMethodsContent %} {%- set stubMethodsJoiner = joiner(', ') -%} {%- for method in service.method -%} - {%- if not method.ignoreMapPagingMethod %} + {%- if not method.ignoreMapPagingMethod and not method.resumableUpload %} {{- stubMethodsJoiner() -}} '{{ method.name.toCamelCase(true) }}' {%- endif %} @@ -499,6 +529,20 @@ export class {{ service.name }}Client { this.innerApiCalls[methodName] = apiCall; } {%- endif -%} +{%- if not api.legacyProtoLoad and service.resumableUploads.length > 0 %} + + // Resumable upload methods do not use the gRPC/REST service stub; the + // ResumableUpload helper performs its own HTTP requests. +{%- for method in service.resumableUploads %} + this.innerApiCalls['{{ method.name.toCamelCase() }}'] = + this._gaxModule.createApiCall( + this._gaxModule.resumableUploadStub, + this._defaults['{{ method.name.toCamelCase() }}'], + this.descriptors.resumableUpload['{{ method.name.toCamelCase() }}'], + this._opts.fallback + ); +{%- endfor %} +{%- endif %} {%- if service.options and service.options.deprecated %} this.warn('DEP${{service.name}}', '{{service.name}} is deprecated and may be removed in a future version.', 'DeprecationWarning'); {%- endif %} @@ -731,6 +775,51 @@ export class {{ service.name }}Client { {%- endif %} } {%- endfor %} +{%- for method in service.resumableUploads %} +{%- if not api.legacyProtoLoad %} +/** + {{- internalWarning(service, method, api) }} +{{- util.printCommentsForMethod(method) }} + {%- if method.options and method.options.deprecated %} + * @deprecated {{method.name}} is deprecated and may be removed in a future version. + {%- endif %} + * @param {object} [request] - The request object. + * @param {object} [options] - Optional parameters. The upload stream, + * chunk size, progress callback, and resume URL are passed to + * {@link gax.ResumableUpload#start} instead. + * @returns {Promise} A resumable upload helper. Call + * `.start(uploadParams)` with the stream to upload, then await + * `.finished()` for the final RPC response. + */ + {{ method.name.toCamelCase() }}( + request?: {{ util.toInterface(method.inputInterface) }}, + options?: CallOptions): Promise { + request = request || {}; + options = options || {}; + this.{{ id.get("initialize") }}().catch(err => {throw err}); + {%- if method.options and method.options.deprecated %} + this.warn('DEP${{service.name}}-${{method.name}}','{{method.name}} is deprecated and may be removed in a future version.', 'DeprecationWarning'); + {%- endif %} + this._log.info('{{ method.name.toCamelCase() }} request %j', request); + return this.innerApiCalls['{{ method.name.toCamelCase() }}'](request, { + ...options, + resumableUpload: { + auth: this._fallbackRest!.auth as gax.GoogleAuth, + servicePath: this._opts.servicePath ?? this._servicePath, + servicePort: this._opts.port || 443, + protocol: this._opts.protocol || 'https', + rpc: this._gaxModule.protobuf.Root.fromJSON(jsonProtos) + .lookupService('{{api.naming.protoPackage}}.{{ service.name }}') + .methods['{{ method.name }}'], + request, + uploadPrefix: '{{ method.resumableUpload.uploadPrefix }}', + numericEnums: this._opts.numericEnums, + minifyJson: this._opts.minifyJson, + }, + }).then(([helper]) => helper); + } +{%- endif %} +{%- endfor %} {% for method in service.streaming %} {%- if method.serverStreaming and method.clientStreaming %} /** @@ -1178,4 +1267,4 @@ export class {{ service.name }}Client { } return Promise.resolve(); } -} \ No newline at end of file +} diff --git a/core/generator/gapic-generator-typescript/templates/cjs/typescript_samples/samples/generated/$version/$service.$method.js.njk b/core/generator/gapic-generator-typescript/templates/cjs/typescript_samples/samples/generated/$version/$service.$method.js.njk index 6d0301838663..ec7800fe49bd 100644 --- a/core/generator/gapic-generator-typescript/templates/cjs/typescript_samples/samples/generated/$version/$service.$method.js.njk +++ b/core/generator/gapic-generator-typescript/templates/cjs/typescript_samples/samples/generated/$version/$service.$method.js.njk @@ -41,7 +41,9 @@ function main({%- for comment in filteredComments -%} {{ "\n" }} // Imports the {{ api.naming.productName }} library const { {{- service.name.toPascalCase() }}Client} = require('{{ api.publishName }}').{{ api.naming.version }}; - +{% if method.resumableUpload %} + const fs = require('fs'); +{% endif %} // Instantiates a client const {{ (api.naming.productName).toCamelCase() }}Client = new {{ service.name.toPascalCase() }}Client(); @@ -94,6 +96,15 @@ function main({%- for comment in filteredComments -%} stream.write(request); stream.end(); } +{% elif method.resumableUpload %} + // Run request + const helper = await {{ (api.naming.productName).toCamelCase() }}Client.{{ method.name.toCamelCase() }}(request); + await helper.start({ + uploadStream: fs.createReadStream('/path/to/file'), + }); + const response = await helper.finished(); + console.log(response); + } {% else %} // Run request const response = await {{ (api.naming.productName).toCamelCase() }}Client.{{ method.name.toCamelCase() }}(request); diff --git a/core/generator/gapic-generator-typescript/templates/esm/typescript_gapic/esm/src/$version/$service_client.ts.njk b/core/generator/gapic-generator-typescript/templates/esm/typescript_gapic/esm/src/$version/$service_client.ts.njk index e505db0eef11..31993b52fd69 100644 --- a/core/generator/gapic-generator-typescript/templates/esm/typescript_gapic/esm/src/$version/$service_client.ts.njk +++ b/core/generator/gapic-generator-typescript/templates/esm/typescript_gapic/esm/src/$version/$service_client.ts.njk @@ -85,6 +85,9 @@ export class {{ service.name }}Client { private _providedCustomServicePath: boolean; private _gaxModule: typeof gax{% if not api.legacyProtoLoad %} | typeof gax.fallback{% endif %}; private _gaxGrpc: gax.GrpcClient{% if not api.legacyProtoLoad %} | gax.fallback.GrpcClient{% endif %}; +{%- if not api.legacyProtoLoad and service.resumableUploads.length > 0 %} + private _fallbackRest?: gax.GrpcClient | gax.fallback.GrpcClient; +{%- endif %} private _protos: {}; private _defaults: {[method: string]: gax.CallSettings}; private _universeDomain: string; @@ -96,6 +99,9 @@ export class {{ service.name }}Client { stream: {}, longrunning: {}, batching: {}, +{%- if not api.legacyProtoLoad and service.resumableUploads.length > 0 %} + resumableUpload: {}, +{%- endif %} }; warn: (code: string, message: string, warnType?: string) => void; innerApiCalls: {[name: string]: Function}; @@ -209,6 +215,15 @@ export class {{ service.name }}Client { // Create a `gaxGrpc` object, with any grpc-specific options sent to the client. this._gaxGrpc = new this._gaxModule.GrpcClient(opts); +{%- if not api.legacyProtoLoad and service.resumableUploads.length > 0 %} + + // This service contains resumable upload methods, which are HTTPS-only. + // Make sure the REST transport is available even when the client was + // configured for gRPC. + this._fallbackRest = opts.fallback + ? this._gaxGrpc + : new gaxInstance.fallback.GrpcClient({...opts, fallback: true}); +{%- endif %} // Save options to use in {{ id.get("initialize") }}() method. this._opts = opts; @@ -401,6 +416,21 @@ export class {{ service.name }}Client { {%- endfor %} {%- endif %} +{%- if not api.legacyProtoLoad and service.resumableUploads.length > 0 %} + + // Some methods on this API support resumable uploads; provide + // descriptors for these methods. + this.descriptors.resumableUpload = { +{%- set resumableUploadJoiner = joiner() %} +{%- for method in service.resumableUploads %} + {{- resumableUploadJoiner() }} + {{ method.name.toCamelCase() }}: new this._gaxModule.ResumableUploadDescriptor( + '{{ method.resumableUpload.uploadPrefix }}' + ) +{%- endfor %} + }; +{%- endif %} + // Put together the default options sent with requests. this._defaults = this._gaxGrpc.constructSettings( '{{ api.naming.protoPackage }}.{{ service.name }}', gapicConfig as gax.ClientConfig, @@ -449,10 +479,10 @@ export class {{ service.name }}Client { (this._protos as any).{{api.naming.protoPackage}}.{{ service.name }}, this._opts, this._providedCustomServicePath) as Promise<{[method: string]: Function}>; - {%- set stubMethodsContent %} +{%- set stubMethodsContent %} {%- set stubMethodsJoiner = joiner(', ') -%} {%- for method in service.method -%} - {%- if not method.ignoreMapPagingMethod %} + {%- if not method.ignoreMapPagingMethod and not method.resumableUpload %} {{- stubMethodsJoiner() -}} '{{ method.name.toCamelCase(true) }}' {%- endif %} @@ -510,6 +540,20 @@ export class {{ service.name }}Client { this.innerApiCalls[methodName] = apiCall; } {%- endif -%} +{%- if not api.legacyProtoLoad and service.resumableUploads.length > 0 %} + + // Resumable upload methods do not use the gRPC/REST service stub; the + // ResumableUpload helper performs its own HTTP requests. +{%- for method in service.resumableUploads %} + this.innerApiCalls['{{ method.name.toCamelCase() }}'] = + this._gaxModule.createApiCall( + this._gaxModule.resumableUploadStub, + this._defaults['{{ method.name.toCamelCase() }}'], + this.descriptors.resumableUpload['{{ method.name.toCamelCase() }}'], + this._opts.fallback + ); +{%- endfor %} +{%- endif %} {%- if service.options and service.options.deprecated %} this.warn('DEP${{service.name}}', '{{service.name}} is deprecated and may be removed in a future version.', 'DeprecationWarning'); {%- endif %} @@ -742,6 +786,51 @@ export class {{ service.name }}Client { {%- endif %} } {%- endfor %} +{%- for method in service.resumableUploads %} +{%- if not api.legacyProtoLoad %} +/** + {{- internalWarning(service, method, api) }} +{{- util.printCommentsForMethod(method) }} + {%- if method.options and method.options.deprecated %} + * @deprecated {{method.name}} is deprecated and may be removed in a future version. + {%- endif %} + * @param {object} [request] - The request object. + * @param {object} [options] - Optional parameters. The upload stream, + * chunk size, progress callback, and resume URL are passed to + * {@link gax.ResumableUpload#start} instead. + * @returns {Promise} A resumable upload helper. Call + * `.start(uploadParams)` with the stream to upload, then await + * `.finished()` for the final RPC response. + */ + {{ method.name.toCamelCase() }}( + request?: {{ util.toInterface(method.inputInterface) }}, + options?: CallOptions): Promise { + request = request || {}; + options = options || {}; + this.{{ id.get("initialize") }}().catch(err => {throw err}); + {%- if method.options and method.options.deprecated %} + this.warn('DEP${{service.name}}-${{method.name}}','{{method.name}} is deprecated and may be removed in a future version.', 'DeprecationWarning'); + {%- endif %} + this._log.info('{{ method.name.toCamelCase() }} request %j', request); + return this.innerApiCalls['{{ method.name.toCamelCase() }}'](request, { + ...options, + resumableUpload: { + auth: this._fallbackRest!.auth as gax.GoogleAuth, + servicePath: this._opts.servicePath ?? this._servicePath, + servicePort: this._opts.port || 443, + protocol: this._opts.protocol || 'https', + rpc: this._gaxModule.protobuf.Root.fromJSON(jsonProtos) + .lookupService('{{api.naming.protoPackage}}.{{ service.name }}') + .methods['{{ method.name }}'], + request, + uploadPrefix: '{{ method.resumableUpload.uploadPrefix }}', + numericEnums: this._opts.numericEnums, + minifyJson: this._opts.minifyJson, + }, + }).then(([helper]) => helper); + } +{%- endif %} +{%- endfor %} {% for method in service.streaming %} {%- if method.serverStreaming and method.clientStreaming %} /** @@ -1185,4 +1274,4 @@ export class {{ service.name }}Client { } return Promise.resolve(); } -} \ No newline at end of file +} diff --git a/core/generator/gapic-generator-typescript/templates/esm/typescript_samples/samples/generated/$version/$service.$method.js.njk b/core/generator/gapic-generator-typescript/templates/esm/typescript_samples/samples/generated/$version/$service.$method.js.njk index 6d0301838663..ec7800fe49bd 100644 --- a/core/generator/gapic-generator-typescript/templates/esm/typescript_samples/samples/generated/$version/$service.$method.js.njk +++ b/core/generator/gapic-generator-typescript/templates/esm/typescript_samples/samples/generated/$version/$service.$method.js.njk @@ -41,7 +41,9 @@ function main({%- for comment in filteredComments -%} {{ "\n" }} // Imports the {{ api.naming.productName }} library const { {{- service.name.toPascalCase() }}Client} = require('{{ api.publishName }}').{{ api.naming.version }}; - +{% if method.resumableUpload %} + const fs = require('fs'); +{% endif %} // Instantiates a client const {{ (api.naming.productName).toCamelCase() }}Client = new {{ service.name.toPascalCase() }}Client(); @@ -94,6 +96,15 @@ function main({%- for comment in filteredComments -%} stream.write(request); stream.end(); } +{% elif method.resumableUpload %} + // Run request + const helper = await {{ (api.naming.productName).toCamelCase() }}Client.{{ method.name.toCamelCase() }}(request); + await helper.start({ + uploadStream: fs.createReadStream('/path/to/file'), + }); + const response = await helper.finished(); + console.log(response); + } {% else %} // Run request const response = await {{ (api.naming.productName).toCamelCase() }}Client.{{ method.name.toCamelCase() }}(request); diff --git a/core/generator/gapic-generator-typescript/test-fixtures/protos/google/api/media_upload.proto b/core/generator/gapic-generator-typescript/test-fixtures/protos/google/api/media_upload.proto new file mode 100644 index 000000000000..f2deed02e29f --- /dev/null +++ b/core/generator/gapic-generator-typescript/test-fixtures/protos/google/api/media_upload.proto @@ -0,0 +1,63 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// NOTE: This is a local copy of the pending `google/api/media_upload.proto` +// definition used to describe resumable upload methods. +// The official proto has not been published to googleapis yet; when it is, +// this file should be replaced by the upstream version and the protos bundle +// regenerated. Detection in the generator matches on the option name +// (`.google.api.mediaUpload`), so the extension number below is a +// placeholder that does not affect method identification. + +syntax = "proto3"; + +package google.api; + +import "google/api/annotations.proto"; +import "google/protobuf/descriptor.proto"; + +option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations"; + +// MediaUpload describes the media upload configuration for a method that +// opts into the resumable upload protocol. +message MediaUpload { + // Whether the method supports media upload. + bool enabled = 1; + + // The paths to which media upload commands are sent. When present, the + // first path is used as the upload prefix for the resumable upload + // session (for example, `/resumable/upload`). + repeated string media_upload_paths = 2; + + // Whether the server notifies the client when the session is started. + bool start_notification = 3; + + // Whether the server notifies the client on each upload command. + bool upload_notification = 4; + + // Whether the server notifies the client when the upload is finalized. + bool finalize_notification = 5; + + // The direct upload service to use, if any. + string direct_upload_service = 6; + + // How long, in seconds, an upload session may remain active. + int64 max_upload_session_duration_seconds = 7; +} + +// Defines a method as a media upload method. Methods annotated with this +// option are routed through the resumable upload protocol. +extend google.protobuf.MethodOptions { + MediaUpload media_upload = 1052; +} diff --git a/core/generator/gapic-generator-typescript/test-fixtures/protos/google/samples/resumable/v1/resumable.proto b/core/generator/gapic-generator-typescript/test-fixtures/protos/google/samples/resumable/v1/resumable.proto new file mode 100644 index 000000000000..75409923f7ef --- /dev/null +++ b/core/generator/gapic-generator-typescript/test-fixtures/protos/google/samples/resumable/v1/resumable.proto @@ -0,0 +1,78 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Synthetic fixture used by the baseline tests to exercise resumable upload +// method generation. The google.api.media_upload annotation is defined by +// the local copy of google/api/media_upload.proto. + +syntax = "proto3"; + +package google.samples.resumable.v1; + +import "google/api/annotations.proto"; +import "google/api/client.proto"; +import "google/api/media_upload.proto"; + +option csharp_namespace = "Google.Samples.Resumable.V1"; +option go_package = "google.golang.org/genproto/googleapis/samples/resumable/v1;resumable"; +option java_multiple_files = true; +option java_outer_classname = "ResumableProto"; +option java_package = "com.google.samples.resumable.v1"; +option php_namespace = "Google\\Samples\\Resumable\\V1"; +option ruby_package = "Google::Samples::Resumable::V1"; + +service ResumableUploadService { + option (google.api.default_host) = "resumable.googleapis.com"; + option (google.api.oauth_scopes) = + "https://www.googleapis.com/auth/cloud-platform"; + + // Creates a resumable upload session. + rpc CreateResumableUpload(CreateResumableUploadRequest) + returns (CreateResumableUploadResponse) { + option (google.api.http) = { + post: "/v1/uploads" + body: "*" + }; + option (google.api.media_upload) = { + enabled: true + media_upload_paths: "/resumable/upload" + }; + } + + // Returns the status of a previously created upload session. + rpc GetUploadStatus(GetUploadStatusRequest) + returns (GetUploadStatusResponse) { + option (google.api.http) = { + get: "/v1/uploads/{upload_url}" + }; + } +} + +message CreateResumableUploadRequest { + string name = 1; + string description = 2; +} + +message CreateResumableUploadResponse { + string upload_url = 1; + string status = 2; +} + +message GetUploadStatusRequest { + string upload_url = 1; +} + +message GetUploadStatusResponse { + string status = 1; +} diff --git a/core/generator/gapic-generator-typescript/typescript/src/schema/proto.ts b/core/generator/gapic-generator-typescript/typescript/src/schema/proto.ts index 60c6673b67bd..1c586b9c1fb2 100644 --- a/core/generator/gapic-generator-typescript/typescript/src/schema/proto.ts +++ b/core/generator/gapic-generator-typescript/typescript/src/schema/proto.ts @@ -79,6 +79,9 @@ export interface MethodDescriptorProto bundleConfig?: BundleConfig; toJSON: Function | undefined; isDiregapicLRO?: boolean; + // If set, the method opts into the resumable upload protocol + // via the google.api.media_upload method option. + resumableUpload?: {uploadPrefix: string} | undefined; // if wrappers are allowed and there is a maxResultsParamter, return true maxResultsParameter?: boolean; } @@ -138,6 +141,7 @@ export interface ServiceDescriptorProto longRunningOperationsMixinFlags?: OperationsMixinConfig; protoFile: string; diregapicLRO?: MethodDescriptorProto[]; + resumableUploads: MethodDescriptorProto[]; httpRules?: protos.google.api.IHttpRule[]; selectiveGapic: SelectiveGapicConfig; } @@ -303,6 +307,26 @@ function streaming(method: MethodDescriptorProto) { return undefined; } +// Detect methods that opt into the resumable upload protocol via +// the google.api.media_upload method option. The upload prefix defaults to +// `/resumable/upload` and can be overridden by the annotation. +function resumableUpload(method: MethodDescriptorProto): { + uploadPrefix: string; +} | undefined { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const mediaUpload = method.options?.['.google.api.mediaUpload'] as + | { + enabled?: boolean; + mediaUploadPaths?: string[]; + } + | undefined; + if (!mediaUpload || mediaUpload.enabled === false) { + return undefined; + } + const paths = mediaUpload.mediaUploadPaths ?? []; + return {uploadPrefix: paths[0] ?? '/resumable/upload'}; +} + // returns true if the method has wrappers for UInt32Value enabled // and is a paginated call with a maxResults parameter instead of pageSize // as of its creation, this should only be true for BigQuery @@ -634,6 +658,7 @@ function augmentMethod( parameters.diregapic, wrappersAllowed, ), + resumableUpload: resumableUpload(method), ignoreMapPagingMethod: ignoreMapPagingMethod( parameters.allMessages, method, @@ -1076,7 +1101,13 @@ export function augmentService(parameters: AugmentServiceParameters) { ); augmentedService.simpleMethods = augmentedService.method.filter( method => - !method.longRunning && !method.streaming && !method.pagingFieldName, + !method.longRunning && + !method.streaming && + !method.pagingFieldName && + !method.resumableUpload, + ); + augmentedService.resumableUploads = augmentedService.method.filter( + method => method.resumableUpload, ); augmentedService.longRunning = augmentedService.method.filter( method => method.longRunning, diff --git a/core/generator/gapic-generator-typescript/typescript/test/unit/baselines-esm.ts b/core/generator/gapic-generator-typescript/typescript/test/unit/baselines-esm.ts index 47ada20e155b..dbe2d8a95616 100644 --- a/core/generator/gapic-generator-typescript/typescript/test/unit/baselines-esm.ts +++ b/core/generator/gapic-generator-typescript/typescript/test/unit/baselines-esm.ts @@ -31,6 +31,13 @@ describe('Baseline tests: ESM', () => { useCommonProto: true, format: 'esm', }); + runBaselineTest({ + baselineName: 'resumable-upload-esm', + outputDir: '.test-out-resumable-upload-esm', + protoPath: 'google/samples/resumable/v1/resumable.proto', + useCommonProto: false, + format: 'esm', + }); runBaselineTest({ baselineName: 'dlp-esm', outputDir: '.test-out-dlp-esm', diff --git a/core/generator/gapic-generator-typescript/typescript/test/unit/baselines.ts b/core/generator/gapic-generator-typescript/typescript/test/unit/baselines.ts index 8475cf03d107..4817641283d9 100644 --- a/core/generator/gapic-generator-typescript/typescript/test/unit/baselines.ts +++ b/core/generator/gapic-generator-typescript/typescript/test/unit/baselines.ts @@ -29,6 +29,12 @@ describe('Baseline tests', () => { serviceYaml: 'google/duplicatemethodstest/v1/duplicate_methods_test_v1.yaml', useCommonProto: true, }); + runBaselineTest({ + baselineName: 'resumable-upload', + outputDir: '.test-out-resumable-upload', + protoPath: 'google/samples/resumable/v1/resumable.proto', + useCommonProto: false, + }); runBaselineTest({ baselineName: 'dlp', outputDir: '.test-out-dlp', diff --git a/core/generator/gapic-generator-typescript/typescript/test/unit/proto.ts b/core/generator/gapic-generator-typescript/typescript/test/unit/proto.ts index 7ef9060a439e..d5cfa633d51a 100644 --- a/core/generator/gapic-generator-typescript/typescript/test/unit/proto.ts +++ b/core/generator/gapic-generator-typescript/typescript/test/unit/proto.ts @@ -1776,3 +1776,100 @@ describe('src/schema/proto.ts', () => { }); }); }); + +describe('src/schema/proto.ts - resumable upload detection', () => { + it('marks methods annotated with google.api.media_upload', () => { + const fd = {} as protos.google.protobuf.FileDescriptorProto; + fd.package = 'google.samples.resumable.v1'; + fd.service = [{} as protos.google.protobuf.ServiceDescriptorProto]; + fd.service[0].name = 'ResumableUploadService'; + fd.service[0].method = [ + { + name: 'CreateResumableUpload', + inputType: '.google.samples.resumable.v1.CreateResumableUploadRequest', + outputType: '.google.samples.resumable.v1.CreateResumableUploadResponse', + options: { + '.google.api.mediaUpload': { + enabled: true, + mediaUploadPaths: ['/resumable/upload'], + }, + }, + }, + { + name: 'GetUploadStatus', + inputType: '.google.samples.resumable.v1.GetUploadStatusRequest', + outputType: '.google.samples.resumable.v1.GetUploadStatusResponse', + }, + ] as protos.google.protobuf.MethodDescriptorProto[]; + + const options: Options = { + grpcServiceConfig: {} as protos.grpc.service_config.ServiceConfig, + }; + const augmentedService = augmentService({ + allMessages: {}, + localMessages: {}, + packageName: 'google.samples.resumable.v1', + service: fd.service[0], + commentsMap: new CommentsMap([fd]), + allResourceDatabase: new ResourceDatabase(), + resourceDatabase: new ResourceDatabase(), + options, + protoFile: 'fd', + }); + + assert.strictEqual(augmentedService.resumableUploads.length, 1); + assert.deepStrictEqual( + augmentedService.resumableUploads[0].resumableUpload, + {uploadPrefix: '/resumable/upload'}, + ); + assert.strictEqual( + augmentedService.method.find(m => m.name === 'GetUploadStatus') + ?.resumableUpload, + undefined, + ); + assert.strictEqual( + augmentedService.simpleMethods.some( + m => m.name === 'CreateResumableUpload', + ), + false, + ); + assert.strictEqual( + augmentedService.simpleMethods.some(m => m.name === 'GetUploadStatus'), + true, + ); + }); + + it('ignores media upload annotations that are not enabled', () => { + const fd = {} as protos.google.protobuf.FileDescriptorProto; + fd.service = [{} as protos.google.protobuf.ServiceDescriptorProto]; + fd.service[0].name = 'TestService'; + fd.service[0].method = [ + { + name: 'CreateUpload', + inputType: '.test.CreateUploadRequest', + outputType: '.test.CreateUploadResponse', + options: { + '.google.api.mediaUpload': {enabled: false}, + }, + }, + ] as protos.google.protobuf.MethodDescriptorProto[]; + + const options: Options = { + grpcServiceConfig: {} as protos.grpc.service_config.ServiceConfig, + }; + const augmentedService = augmentService({ + allMessages: {}, + localMessages: {}, + packageName: 'test', + service: fd.service[0], + commentsMap: new CommentsMap([fd]), + allResourceDatabase: new ResourceDatabase(), + resourceDatabase: new ResourceDatabase(), + options, + protoFile: 'fd', + }); + + assert.strictEqual(augmentedService.resumableUploads.length, 0); + assert.strictEqual(augmentedService.method[0].resumableUpload, undefined); + }); +}); diff --git a/core/packages/gax/client-libraries.md b/core/packages/gax/client-libraries.md index d64cea0550fc..d66025315cd4 100644 --- a/core/packages/gax/client-libraries.md +++ b/core/packages/gax/client-libraries.md @@ -149,6 +149,48 @@ in the second parameter: const [response] = await client.sampleMethod(request, options); ``` +### Resumable uploads + +Some APIs expose methods that upload large payloads through the resumable +upload protocol. For these methods, the client method no +longer returns the response directly; it returns a +[`ResumableUpload`](https://googleapis.dev/nodejs/google-gax/latest/classes/ResumableUpload.html) +helper. Call `start()` with a `NodeJS.ReadableStream` and await `finished()` +for the final response: + +```ts +const helper = await client.createResumableUpload(request); +await helper.start({ + uploadStream: dataStream, + chunkSize: 8 * 1024 * 1024, // 8MB chunks + onProgress: status => { + console.log(`Committed ${status.bytesUploaded} bytes to ${status.uploadUrl}`); + }, +}); +const response = await helper.finished(); +``` + +The session URL is available as `helper.uploadUrl` once the upload has +started. Save it if you need to resume the upload later — for example after a +process crash or network drop. To resume, pass the saved URL to `start()` on a +new helper, along with a fresh stream of the same payload: + +```ts +const helper = await client.createResumableUpload(); +await helper.start({ + uploadStream: dataStream, + resumeUrl: savedUploadUrl, +}); +const response = await helper.finished(); +``` + +The current implementation requires a seekable stream (for example, a file +stream). Errors fall into three categories: transient errors (retried with +exponential backoff), state mismatches (recovered by querying the server for +the committed byte offset), and fatal errors (propagated to the caller). +The whole session is bounded by a global deadline (10 minutes by default, +scaled up for large payloads and overridable via `globalDeadlineMs`). + ### Long-running operations Some methods are expected to run longer. They return an object of type diff --git a/core/packages/gax/src/clientInterface.ts b/core/packages/gax/src/clientInterface.ts index b9f3bd8b8e9c..082441a917c6 100644 --- a/core/packages/gax/src/clientInterface.ts +++ b/core/packages/gax/src/clientInterface.ts @@ -25,6 +25,7 @@ import { PageDescriptor, StreamDescriptor, } from './descriptor'; +import {ResumableUploadDescriptor} from './resumableUpload'; import * as longrunning from './longRunningCalls/longrunning'; import * as operationProtos from '../protos/operations'; @@ -49,6 +50,7 @@ export interface Descriptors { stream: {[name: string]: StreamDescriptor}; longrunning: {[name: string]: LongrunningDescriptor}; batching?: {[name: string]: BundleDescriptor}; + resumableUpload?: {[name: string]: ResumableUploadDescriptor}; } export interface Callback< diff --git a/core/packages/gax/src/descriptor.ts b/core/packages/gax/src/descriptor.ts index 5cfad86eb48e..42a37ceab512 100644 --- a/core/packages/gax/src/descriptor.ts +++ b/core/packages/gax/src/descriptor.ts @@ -31,3 +31,4 @@ export {LongRunningDescriptor as LongrunningDescriptor} from './longRunningCalls export {PageDescriptor} from './paginationCalls/pageDescriptor'; export {StreamDescriptor} from './streamingCalls/streamDescriptor'; export {BundleDescriptor} from './bundlingCalls/bundleDescriptor'; +export {ResumableUploadDescriptor} from './resumableUpload'; diff --git a/core/packages/gax/src/fallback.ts b/core/packages/gax/src/fallback.ts index 9042340a11f2..b0e9132b44ad 100644 --- a/core/packages/gax/src/fallback.ts +++ b/core/packages/gax/src/fallback.ts @@ -54,6 +54,8 @@ export { PageDescriptor, StreamDescriptor, } from './descriptor'; +export {ResumableUploadDescriptor} from './resumableUpload'; +export {resumableUploadStub} from './resumableUpload'; export {StreamType} from './streamingCalls/streaming'; diff --git a/core/packages/gax/src/gax.ts b/core/packages/gax/src/gax.ts index a38152c24290..ccef07c32d00 100644 --- a/core/packages/gax/src/gax.ts +++ b/core/packages/gax/src/gax.ts @@ -19,6 +19,7 @@ */ import type {Message} from 'protobufjs'; +import type {ResumableUploadContext} from './resumableUpload'; import {warn} from './warnings'; import {GoogleError} from './googleError'; import {BundleOptions} from './bundlingCalls/bundleExecutor'; @@ -170,6 +171,11 @@ export interface CallOptions { longrunning?: BackoffSettings; apiName?: string; retryRequestOptions?: RetryRequestOptions; + /** + * Internal context used by resumable upload methods. Populated by + * GAPIC-generated client libraries; do not set manually. + */ + resumableUpload?: ResumableUploadContext; } export class CallSettings { @@ -186,6 +192,7 @@ export class CallSettings { longrunning?: BackoffSettings; apiName?: string; retryRequestOptions?: RetryRequestOptions; + resumableUpload?: ResumableUploadContext; /** * @param {Object} settings - An object containing parameters of this settings. @@ -219,6 +226,8 @@ export class CallSettings { 'longrunning' in settings ? settings.longrunning : undefined; this.apiName = settings.apiName ?? undefined; this.retryRequestOptions = settings.retryRequestOptions; + this.resumableUpload = + 'resumableUpload' in settings ? settings.resumableUpload : undefined; } /** @@ -242,6 +251,7 @@ export class CallSettings { let longrunning = this.longrunning; let apiName = this.apiName; let retryRequestOptions = this.retryRequestOptions; + let resumableUpload = this.resumableUpload; // If the user provides a timeout to the method, that timeout value will be used // to override the backoff settings. @@ -297,6 +307,9 @@ export class CallSettings { if ('retryRequestOptions' in options) { retryRequestOptions = options.retryRequestOptions; } + if ('resumableUpload' in options) { + resumableUpload = options.resumableUpload; + } return new CallSettings({ timeout, @@ -309,6 +322,7 @@ export class CallSettings { isBundling, apiName, retryRequestOptions, + resumableUpload, }); } } diff --git a/core/packages/gax/src/index.ts b/core/packages/gax/src/index.ts index d9c82f34530e..fe1e563a5b8a 100644 --- a/core/packages/gax/src/index.ts +++ b/core/packages/gax/src/index.ts @@ -36,6 +36,17 @@ export { PageDescriptor, StreamDescriptor, } from './descriptor'; +export {ResumableUploadDescriptor} from './resumableUpload'; +export { + ResumableUpload, + resumableUploadStub, + ResumableUploadState, +} from './resumableUpload'; +export type { + ResumableUploadContext, + ResumableUploadProgress, + ResumableUploadStartParams, +} from './resumableUpload'; export { CallOptions, CallSettings, diff --git a/core/packages/gax/src/resumableUpload.ts b/core/packages/gax/src/resumableUpload.ts new file mode 100644 index 000000000000..a93211325f9e --- /dev/null +++ b/core/packages/gax/src/resumableUpload.ts @@ -0,0 +1,1258 @@ +/** + * Copyright 2026 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Resumable upload protocol support. + * + * This module implements the client-side state machine for the resumable + * upload protocol used by Google APIs to transfer large payloads over + * HTTP(S). The upload session is managed by a {@link ResumableUpload} + * object, which is returned by GAPIC-generated client methods for resumable + * upload RPCs. + * + * The protocol commands are sent through the `X-Goog-Upload-Command` header + * and the payload is transferred in discrete chunks. Transient errors + * (Category 1) are retried with exponential backoff, state mismatches + * (Category 2) trigger a recovery phase that queries the server for the + * committed byte offset, and everything else (Category 3) is fatal. + */ + +import type {AuthClient, GoogleAuth} from 'google-auth-library'; +import * as protobuf from 'protobufjs'; +import * as serializer from 'proto3-json-serializer'; +import type {Readable} from 'stream'; + +import {APICaller} from './apiCaller'; +import {APICallback, GRPCCall, SimpleCallbackFunction} from './apitypes'; +import {OngoingCall, OngoingCallPromise} from './call'; +import {Descriptor} from './descriptor'; +import {decodeResponse} from './fallbackRest'; +import {CallSettings, createDefaultBackoffSettings, RetryOptions} from './gax'; +import type {GoogleError} from './googleError'; +import {Status, rpcCodeFromHttpStatusCode} from './status'; +import {transcode} from './transcoding'; + +export const DEFAULT_CHUNK_SIZE = 8 * 1024 * 1024; +export const DEFAULT_GLOBAL_DEADLINE_MS = 10 * 60 * 1000; +export const MAX_GLOBAL_DEADLINE_MS = 24 * 60 * 60 * 1000; +export const DEFAULT_MAX_INNER_RETRIES = 5; +export const DEFAULT_PER_REQUEST_TIMEOUT_MS = 60 * 1000; +// Assumed sustained upload throughput, in bytes per millisecond, used to +// scale the global deadline when `uploadSize` is provided (~5 MB/s). +const DEFAULT_UPLOAD_RATE_BYTES_PER_MS = 5 * 1024 * 1024; + +// Resumable upload protocol headers. +const UPLOAD_PROTOCOL_HEADER = 'x-goog-upload-protocol'; +const UPLOAD_PROTOCOL_RESUMABLE = 'resumable'; +const UPLOAD_COMMAND_HEADER = 'x-goog-upload-command'; +const UPLOAD_OFFSET_HEADER = 'x-goog-upload-offset'; +const UPLOAD_URL_HEADER = 'x-goog-upload-url'; +const UPLOAD_STATUS_HEADER = 'x-goog-upload-status'; +const UPLOAD_SIZE_RECEIVED_HEADER = 'x-goog-upload-size-received'; +const UPLOAD_CHUNK_GRANULARITY_HEADER = 'x-goog-upload-chunk-granularity'; + +// Resumable upload protocol commands. +const COMMAND_START = 'start'; +const COMMAND_UPLOAD = 'upload'; +const COMMAND_QUERY = 'query'; +const COMMAND_FINALIZE = 'finalize'; +const COMMAND_CANCEL = 'cancel'; +const COMMAND_UPLOAD_FINALIZE = 'upload, finalize'; + +// Category 1 errors are transient and can be retried without modification. +const CATEGORY_1_RETRY_CODES = new Set([408, 429, 500, 502, 503, 504]); +// Category 2 errors are state mismatches; recovery must query the server for +// the committed byte offset before retrying. +const CATEGORY_2_RETRY_CODES = new Set([400, 412, 416]); + +/** The possible states of a resumable upload session. */ +export enum ResumableUploadState { + /** The upload has not yet begun transmitting. */ + STARTING = 'STARTING', + /** The stream transfer is in progress. */ + TRANSMISSION = 'TRANSMISSION', + /** The transfer is complete, but we are waiting for confirmation. */ + FINALIZING = 'FINALIZING', + /** Recovery from an existing upload session URL. */ + RECOVERY = 'RECOVERY', +} + +/** Progress reported to the `onProgress` callback. */ +export interface ResumableUploadProgress { + /** The number of bytes committed by the server so far. */ + bytesUploaded: number; + /** The session URL, which can be saved and reused to resume the upload. */ + uploadUrl: string; +} + +/** + * Parameters accepted by {@link ResumableUpload.start}. + */ +export interface ResumableUploadStartParams { + /** + * The stream to read the upload payload from. The current implementation + * requires a seekable stream (for example, a file stream). + */ + uploadStream: NodeJS.ReadableStream; + /** + * Desired chunk size in bytes. The effective chunk size is rounded down to + * a multiple of the server-provided chunk granularity. + */ + chunkSize?: number; + /** Called after each committed chunk and after recovery queries. */ + onProgress?: (status: ResumableUploadProgress) => void; + /** + * Session URL of a previous (possibly interrupted) upload session. When + * provided, the `start` command is skipped and the upload enters the + * recovery phase to determine the server-committed byte offset. + */ + resumeUrl?: string; + /** + * Total size of the payload in bytes, if known. Used to scale the global + * deadline for large payloads. + */ + uploadSize?: number; + /** Override for the global deadline, in milliseconds. */ + globalDeadlineMs?: number; + /** + * Headers that must only be sent with the initial `start` request (for + * example, `developer-token`). + */ + startHeaders?: {[name: string]: string}; + /** Per-request timeout in milliseconds. Defaults to 60000. */ + timeout?: number; + /** + * Retry configuration for the inner (Category 1) retry loop. Pass `null` + * to disable inner retries. + */ + retry?: Partial | null; +} + +/** + * Internal context used to construct a {@link ResumableUpload} helper. This + * is populated by GAPIC-generated client methods. + */ +export interface ResumableUploadContext { + /** Authenticated client used for all HTTP requests. */ + auth: GoogleAuth | AuthClient; + /** The hostname of the API service endpoint. */ + servicePath: string; + /** The port of the API service endpoint. */ + servicePort: number; + /** The protocol (usually `https`). */ + protocol: string; + /** The protobuf method descriptor for the resumable upload RPC. */ + rpc: protobuf.Method; + /** The initial metadata request for the `start` command. */ + request: {}; + /** The upload prefix to use for the `start` command endpoint. */ + uploadPrefix?: string; + numericEnums?: boolean; + minifyJson?: boolean; +} + +interface ResumableUploadResponse { + status: number; + headers: {get(name: string): string | null}; + body: Buffer; +} + +/** Transient error that should be retried (Category 1). */ +class TransientError extends Error {} + +/** State mismatch error that triggers the recovery phase (Category 2). */ +class Category2Error extends Error { + constructor( + message: string, + public httpStatusCode?: number, + ) { + super(message); + this.code = Status.FAILED_PRECONDITION; + } + code: Status; +} + +/** Fatal error that cannot be recovered from (Category 3). */ +class Category3Error extends Error { + constructor(message: string, httpStatusCode?: number) { + super(message); + if (httpStatusCode !== undefined) { + this.code = rpcCodeFromHttpStatusCode(httpStatusCode); + } + } + code?: Status; +} + +/** + * Constructs a {@link GoogleError} lazily. `googleError.ts` imports the + * fallback module, which transitively imports this module; a top-level + * import would create a module-load cycle. + */ +function createGoogleError(message: string, code?: Status): GoogleError { + // eslint-disable-next-line @typescript-eslint/no-var-requires + const {GoogleError: GoogleErrorClass} = + require('./googleError') as typeof import('./googleError'); + const err = new GoogleErrorClass(message); + if (code !== undefined) { + err.code = code; + } + return err; +} + +interface ReadChunkResult { + chunk: Buffer | null; + eof: boolean; + remainder: Buffer; +} + +interface TransmitResult { + finalized: boolean; + response: {} | null; + /** The local offset after the server-committed bytes. */ + newOffset: number; + /** Bytes the stream must skip when the server committed more than expected. */ + skipAhead: number; +} + +/** + * A no-op RPC stub used by GAPIC-generated resumable upload methods. + * Resumable uploads perform their own HTTP requests through the + * {@link ResumableUpload} helper, so the stub passed to `createApiCall` is + * never invoked. + */ +export const resumableUploadStub = (() => { + return {cancel() {}}; +}) as unknown as GRPCCall; + +function sleep(ms: number): Promise { + return new Promise(resolve => setTimeout(resolve, ms)); +} + +function asBuffer(chunk: unknown): Buffer { + if (Buffer.isBuffer(chunk)) { + return chunk; + } + if (chunk instanceof Uint8Array) { + return Buffer.from(chunk); + } + return Buffer.from(String(chunk)); +} + +function parseHeaderInt(value: string | null): number | null { + if (value === null || value === '') { + return null; + } + const parsed = parseInt(value, 10); + return Number.isNaN(parsed) ? null : parsed; +} + +/** + * Descriptor that identifies a method as a resumable upload method and + * provides the caller that constructs the {@link ResumableUpload} helper. + */ +export class ResumableUploadDescriptor implements Descriptor { + constructor(public uploadPrefix: string = '/resumable/upload') {} + + getApiCaller(): APICaller { + return new ResumableUploadApiCaller(this); + } +} + +/** + * API caller for resumable upload methods. The GAPIC method call resolves + * with a {@link ResumableUpload} helper; the actual upload state machine is + * driven by {@link ResumableUpload.start}. + */ +export class ResumableUploadApiCaller implements APICaller { + constructor(private descriptor: ResumableUploadDescriptor) {} + + init(callback?: APICallback): OngoingCallPromise | OngoingCall { + if (callback) { + return new OngoingCall(callback); + } + return new OngoingCallPromise(); + } + + // The regular API call function is never invoked for resumable uploads; + // the helper performs its own HTTP requests. + // eslint-disable-next-line @typescript-eslint/no-unused-vars + wrap(func: GRPCCall): GRPCCall { + return func; + } + + call( + // eslint-disable-next-line @typescript-eslint/no-unused-vars + apiCall: SimpleCallbackFunction, + // eslint-disable-next-line @typescript-eslint/no-unused-vars + argument: {}, + settings: CallSettings, + canceller: OngoingCallPromise, + ): void { + const context = settings.resumableUpload; + if (!context) { + canceller.callback!( + createGoogleError( + 'The resumable upload transport context was not provided. ' + + 'This is a bug in the generated client library.', + ), + ); + return; + } + const helper = new ResumableUpload({ + ...context, + uploadPrefix: + context.uploadPrefix ?? + this.descriptor.uploadPrefix ?? + '/resumable/upload', + }); + canceller.completed = true; + canceller.callback!(null, helper); + } + + fail(canceller: OngoingCallPromise, err: GoogleError): void { + canceller.callback!(err); + } + + result(canceller: OngoingCallPromise) { + return canceller.promise; + } +} + +/** + * Client-side state machine for the resumable upload protocol. + * + * A `ResumableUpload` object is returned by a GAPIC-generated client method + * for a resumable upload RPC. The user calls {@link ResumableUpload.start} + * with a stream and upload parameters, optionally supplies a `resumeUrl` from + * a previous session, and awaits {@link ResumableUpload.finished} for the + * final RPC response. + */ +export class ResumableUpload { + private context: ResumableUploadContext; + private params: ResumableUploadStartParams | null = null; + private state_: ResumableUploadState = ResumableUploadState.STARTING; + private uploadUrl_: string | null = null; + private response_: {} | null = null; + private committedBytes_ = 0; + private startTimeMs = 0; + private globalDeadlineMs = DEFAULT_GLOBAL_DEADLINE_MS; + private effectiveChunkSize_ = DEFAULT_CHUNK_SIZE; + private activeAbortController: AbortController | null = null; + private canceled_ = false; + private started_ = false; + private done_ = false; + private finishedPromise_: Promise<{}>; + private resolveFinished_!: (response: {}) => void; + private rejectFinished_!: (err: Error) => void; + + constructor(context: ResumableUploadContext) { + this.context = context; + this.finishedPromise_ = new Promise<{}>((resolve, reject) => { + this.resolveFinished_ = resolve; + this.rejectFinished_ = reject; + }); + } + + /** The session URL, available once the upload session has been started. */ + get uploadUrl(): string | null { + return this.uploadUrl_; + } + + /** The current state of the upload session. */ + get state(): ResumableUploadState { + return this.state_; + } + + /** The number of bytes the server has committed so far. */ + get committedBytes(): number { + return this.committedBytes_; + } + + /** + * Cancels the upload session, aborts any in-flight HTTP request, and + * rejects the promise returned by {@link ResumableUpload.finished}. + */ + cancel(): void { + if (this.canceled_ || this.done_) { + return; + } + this.canceled_ = true; + if (this.uploadUrl_) { + // Best-effort server-side cancellation of the session. + const controller = new AbortController(); + this.context.auth + .request({ + url: this.uploadUrl_, + method: 'POST', + headers: { + [UPLOAD_PROTOCOL_HEADER]: UPLOAD_PROTOCOL_RESUMABLE, + [UPLOAD_COMMAND_HEADER]: COMMAND_CANCEL, + }, + signal: controller.signal, + responseType: 'stream', + timeout: this.params?.timeout ?? DEFAULT_PER_REQUEST_TIMEOUT_MS, + validateStatus: () => true, + }) + .catch(() => {}); + } + this.activeAbortController?.abort(); + const err = createGoogleError( + 'The resumable upload was cancelled.', + Status.CANCELLED, + ); + this.rejectFinished_(err); + } + + /** + * Starts the upload session and begins transmitting the stream. + * + * The returned promise resolves once the upload session has been + * established (either via the `start` command or via recovery from a + * `resumeUrl`) and the transmission loop is running. Await + * {@link ResumableUpload.finished} for the final response. + */ + async start(params: ResumableUploadStartParams): Promise { + if (this.started_) { + throw createGoogleError('The resumable upload has already been started.'); + } + if (this.canceled_) { + throw createGoogleError('The resumable upload was cancelled.'); + } + if (!params.uploadStream) { + throw createGoogleError( + 'uploadStream must be provided to start a resumable upload.', + ); + } + this.params = params; + this.started_ = true; + this.startTimeMs = Date.now(); + this.globalDeadlineMs = this.computeGlobalDeadlineMs(params); + + let sessionUrl: string; + let granularity: number | null = null; + // A single async iterator is used for both fast-forwarding (when resuming) + // and the transmission loop. + const stream = params.uploadStream as Readable; + const iterator = stream[Symbol.asyncIterator](); + + try { + if (params.resumeUrl) { + this.state_ = ResumableUploadState.RECOVERY; + const committedOffset = await this.queryOffset(params.resumeUrl); + this.uploadUrl_ = params.resumeUrl; + this.committedBytes_ = committedOffset; + this.reportProgress(); + await this.fastForward(iterator, committedOffset); + sessionUrl = params.resumeUrl; + } else { + this.state_ = ResumableUploadState.STARTING; + const started = await this.sendStart(); + sessionUrl = started.uploadUrl; + granularity = started.granularity; + this.uploadUrl_ = sessionUrl; + } + } catch (err) { + // Session setup failed before transmission began; make sure awaiting + // `finished()` does not hang forever. + this.done_ = true; + this.rejectFinished_(err as Error); + throw err; + } + + this.effectiveChunkSize_ = this.computeEffectiveChunkSize( + params.chunkSize, + granularity, + ); + this.state_ = ResumableUploadState.TRANSMISSION; + + // The transmission loop runs in the background; `start()` resolves once + // the session is established so the user can inspect `uploadUrl`. + void this.runTransmission(sessionUrl, iterator); + } + + /** + * Returns a promise that resolves with the final RPC response when the + * upload completes, or rejects if the upload fails or is cancelled. + */ + finished(): Promise<{}> { + return this.finishedPromise_; + } + + private computeGlobalDeadlineMs(params: ResumableUploadStartParams): number { + if (params.globalDeadlineMs !== undefined && params.globalDeadlineMs > 0) { + return params.globalDeadlineMs; + } + let deadline = DEFAULT_GLOBAL_DEADLINE_MS; + if (params.uploadSize !== undefined && params.uploadSize > 0) { + const scaled = Math.ceil( + params.uploadSize / DEFAULT_UPLOAD_RATE_BYTES_PER_MS, + ); + deadline = Math.max(deadline, scaled); + } + return Math.min(deadline, MAX_GLOBAL_DEADLINE_MS); + } + + private computeEffectiveChunkSize( + chunkSize: number | undefined, + granularity: number | null, + ): number { + const requested = chunkSize ?? DEFAULT_CHUNK_SIZE; + if (!granularity || granularity <= 0) { + return requested; + } + const effective = Math.floor(requested / granularity) * granularity; + // Non-final chunks must be a multiple of the server granularity. If the + // user's requested chunk size rounds down to zero, fall back to the + // smallest legal chunk size. + return effective > 0 ? effective : granularity; + } + + private async sendStart(): Promise<{ + uploadUrl: string; + granularity: number | null; + }> { + const rpc = this.context.rpc; + if (!rpc.resolvedRequestType) { + throw new Category3Error( + `Cannot start resumable upload for method ${rpc.name}: ` + + 'the resolved request type is unavailable.', + ); + } + const message = rpc.resolvedRequestType.fromObject(this.context.request); + const json = serializer.toProto3JSON(message, { + numericEnums: this.context.numericEnums ?? false, + }); + if (!json || typeof json !== 'object' || Array.isArray(json)) { + throw new Category3Error( + `Cannot serialize the request for resumable upload method ${rpc.name}.`, + ); + } + + let queryString = ''; + try { + const transcoded = transcode(json, rpc.parsedOptions); + queryString = transcoded?.queryString ?? ''; + } catch { + // The method may not have a google.api.http rule; the request body is + // still sent as proto JSON to the upload endpoint. + } + if (this.context.numericEnums) { + queryString = `${queryString ? `${queryString}&` : ''}$alt=json%3Benum-encoding=int`; + } + if (this.context.minifyJson) { + queryString = `${queryString ? `${queryString}&` : ''}$prettyPrint=0`; + } + + const uploadPrefix = this.context.uploadPrefix ?? '/resumable/upload'; + const url = `${this.getEndpointBase()}${uploadPrefix}${ + queryString ? `?${queryString}` : '' + }`; + const body = JSON.stringify(json); + const startHeaders: {[name: string]: string} = { + 'content-type': 'application/json', + ...(this.params?.startHeaders ?? {}), + }; + + const response = await this.sendCommandWithRetry( + url, + COMMAND_START, + body, + -1, + startHeaders, + ); + if (response.status < 200 || response.status >= 300) { + throw new Category3Error( + `Failed to start resumable upload: HTTP ${response.status}.`, + response.status, + ); + } + const uploadUrl = response.headers.get(UPLOAD_URL_HEADER); + if (!uploadUrl) { + throw new Category3Error( + 'The resumable upload start response did not include a ' + + `${UPLOAD_URL_HEADER} header.`, + ); + } + const granularity = parseHeaderInt( + response.headers.get(UPLOAD_CHUNK_GRANULARITY_HEADER), + ); + return {uploadUrl, granularity}; + } + + /** + * Builds the protocol/host/port prefix for upload endpoints, parsing a + * `host:port` form from `servicePath` when present (matching the fallback + * transport behavior). + */ + private getEndpointBase(): string { + let servicePath = this.context.servicePath; + let servicePort = this.context.servicePort; + const match = servicePath.match(/^(.*):(\d+)$/); + if (match) { + servicePath = match[1]; + servicePort = parseInt(match[2], 10); + } + return `${this.context.protocol}://${servicePath}:${servicePort}`; + } + + private async queryOffset(sessionUrl: string): Promise { + this.state_ = ResumableUploadState.RECOVERY; + try { + const response = await this.sendCommandWithRetry( + sessionUrl, + COMMAND_QUERY, + null, + -1, + undefined, + ); + if (response.status < 200 || response.status >= 300) { + throw new Category3Error( + `Resumable upload recovery query failed: HTTP ${response.status}.`, + response.status, + ); + } + const size = parseHeaderInt( + response.headers.get(UPLOAD_SIZE_RECEIVED_HEADER), + ); + if (size === null) { + throw new Category3Error( + 'The resumable upload recovery query did not include a ' + + `${UPLOAD_SIZE_RECEIVED_HEADER} header.`, + ); + } + return size; + } finally { + this.state_ = ResumableUploadState.TRANSMISSION; + } + } + + private async runTransmission( + sessionUrl: string, + iterator: AsyncIterator, + ): Promise { + try { + let buffer: Buffer = Buffer.alloc(0); + let offset = this.committedBytes_; + let previousChunk: Buffer | null = null; + let response: {} | null = null; + + // eslint-disable-next-line no-constant-condition + while (true) { + this.assertActive(); + this.assertDeadline(); + const read = await this.readNextChunk(iterator, buffer); + buffer = read.remainder; + + if (read.chunk === null) { + // EOF with no pending bytes: either the stream was empty or the + // payload ended exactly on a chunk boundary. Send the finalize + // command on its own. + this.state_ = ResumableUploadState.FINALIZING; + response = await this.transmitFinalize( + sessionUrl, + null, + offset, + previousChunk, + ); + break; + } + + const transmit = await this.transmitChunk( + sessionUrl, + read.chunk, + offset, + previousChunk, + read.eof, + ); + previousChunk = read.chunk; + offset = transmit.newOffset; + this.committedBytes_ = offset; + this.reportProgress(); + + if (transmit.skipAhead > 0) { + await this.skipBytes(iterator, transmit.skipAhead); + } + if (transmit.finalized) { + response = transmit.response; + break; + } + } + + if (this.state_ !== ResumableUploadState.FINALIZING) { + this.state_ = ResumableUploadState.FINALIZING; + } + if (response === null) { + throw new Category3Error( + 'The resumable upload completed without a final response.', + ); + } + this.response_ = response; + this.done_ = true; + this.resolveFinished_(response); + } catch (err) { + if (!this.canceled_) { + this.done_ = true; + this.rejectFinished_(err as Error); + } + } + } + + /** + * Reads the next chunk of the requested size from the stream, aggregating + * stream data events until the chunk is full or the stream ends. + */ + private async readNextChunk( + iterator: AsyncIterator, + buffer: Buffer, + ): Promise { + const chunkSize = this.effectiveChunkSize_; + while (buffer.length < chunkSize) { + const next = await iterator.next(); + if (next.done) { + if (buffer.length === 0) { + return {chunk: null, eof: true, remainder: Buffer.alloc(0)}; + } + return {chunk: buffer, eof: true, remainder: Buffer.alloc(0)}; + } + buffer = Buffer.concat([buffer, asBuffer(next.value)]); + } + const chunk = buffer.subarray(0, chunkSize); + return {chunk, eof: false, remainder: buffer.subarray(chunkSize)}; + } + + /** + * Transmits a chunk, applying the outer recovery loop when the server + * reports a state mismatch (Category 2 error). + */ + private async transmitChunk( + sessionUrl: string, + chunk: Buffer, + offset: number, + previousChunk: Buffer | null, + isFinal: boolean, + ): Promise { + let currentChunk = chunk; + let currentOffset = offset; + let currentPrevious = previousChunk; + + // eslint-disable-next-line no-constant-condition + while (true) { + this.assertActive(); + this.assertDeadline(); + const command = isFinal ? COMMAND_UPLOAD_FINALIZE : COMMAND_UPLOAD; + try { + const response = await this.sendCommandWithRetry( + sessionUrl, + command, + currentChunk, + currentOffset, + undefined, + ); + if (isFinal) { + return { + finalized: true, + response: this.decodeFinalResponse(response), + newOffset: currentOffset + currentChunk.length, + skipAhead: 0, + }; + } + return { + finalized: false, + response: null, + newOffset: currentOffset + currentChunk.length, + skipAhead: 0, + }; + } catch (err) { + if (!(err instanceof Category2Error)) { + throw err; + } + + // Outer recovery: query the server for the exact committed offset, + // align the local state, and re-enter the transmission phase. + this.state_ = ResumableUploadState.RECOVERY; + const serverOffset = await this.queryOffset(sessionUrl); + this.state_ = ResumableUploadState.TRANSMISSION; + this.reportProgress(); + + if (serverOffset === currentOffset) { + // Nothing was committed; retry the same chunk. + continue; + } + if (serverOffset > currentOffset) { + if (serverOffset === currentOffset + currentChunk.length) { + // The chunk was committed but the response was lost. + if (isFinal) { + const finalResponse = await this.transmitFinalize( + sessionUrl, + null, + serverOffset, + null, + ); + return { + finalized: true, + response: finalResponse, + newOffset: serverOffset, + skipAhead: 0, + }; + } + return { + finalized: false, + response: null, + newOffset: serverOffset, + skipAhead: 0, + }; + } + if (serverOffset > currentOffset + currentChunk.length) { + // The server is ahead of the local state; skip the stream forward + // by the number of bytes already committed. + if (isFinal) { + // The final chunk was already committed; retrieve the response + // by sending the finalize command on its own. + const finalResponse = await this.transmitFinalize( + sessionUrl, + null, + serverOffset, + null, + ); + return { + finalized: true, + response: finalResponse, + newOffset: serverOffset, + skipAhead: 0, + }; + } + return { + finalized: false, + response: null, + newOffset: serverOffset, + skipAhead: serverOffset - (currentOffset + currentChunk.length), + }; + } + // The server committed part of this chunk; retransmit the tail. + currentChunk = currentChunk.subarray(serverOffset - currentOffset); + currentOffset = serverOffset; + continue; + } + + // The server is behind the local state: data from the previous chunk + // must be re-transmitted from the in-memory buffer. + const bufferedStart = currentPrevious + ? currentOffset - currentPrevious.length + : currentOffset; + if (currentPrevious && serverOffset >= bufferedStart) { + const rebuilt = Buffer.concat([currentPrevious, currentChunk]); + currentChunk = rebuilt.subarray(serverOffset - bufferedStart); + currentOffset = serverOffset; + currentPrevious = null; + continue; + } + throw new Category3Error( + 'Unrecoverable offset mismatch: the server expects byte ' + + `${serverOffset}, but the local buffer only covers bytes ` + + `[${bufferedStart}, ${currentOffset + currentChunk.length}). ` + + 'Start a new upload session or resume from the saved session URL.', + ); + } + } + } + + /** + * Sends the `finalize` command (optionally preceded by the final chunk), + * recovering from state mismatches by re-querying the committed offset and + * re-aligning the in-memory buffer. + */ + private async transmitFinalize( + sessionUrl: string, + finalChunk: Buffer | null, + offset: number, + previousChunk: Buffer | null, + ): Promise<{}> { + let chunk = finalChunk; + let currentOffset = offset; + let previous = previousChunk; + + // eslint-disable-next-line no-constant-condition + while (true) { + this.assertActive(); + this.assertDeadline(); + const command = chunk ? COMMAND_UPLOAD_FINALIZE : COMMAND_FINALIZE; + try { + const response = await this.sendCommandWithRetry( + sessionUrl, + command, + chunk, + currentOffset, + undefined, + ); + return this.decodeFinalResponse(response); + } catch (err) { + if (!(err instanceof Category2Error)) { + throw err; + } + const serverOffset = await this.queryOffset(sessionUrl); + if (chunk) { + if (serverOffset === currentOffset) { + // Nothing was committed; retry the same final chunk. + continue; + } + if (serverOffset === currentOffset + chunk.length) { + // The final chunk was committed; finalize on its own. + chunk = null; + currentOffset = serverOffset; + continue; + } + if ( + serverOffset > currentOffset && + serverOffset < currentOffset + chunk.length + ) { + chunk = chunk.subarray(serverOffset - currentOffset); + currentOffset = serverOffset; + continue; + } + if (serverOffset > currentOffset + chunk.length) { + chunk = null; + currentOffset = serverOffset; + continue; + } + } else { + if (serverOffset >= currentOffset) { + currentOffset = serverOffset; + continue; + } + } + + // The server is behind the local state: re-send from the buffer. + const bufferedStart = previous + ? currentOffset - previous.length + : currentOffset; + if (previous && serverOffset >= bufferedStart) { + const rebuilt = Buffer.concat([previous, chunk ?? Buffer.alloc(0)]); + chunk = rebuilt.subarray(serverOffset - bufferedStart); + currentOffset = serverOffset; + previous = null; + continue; + } + throw new Category3Error( + 'Unrecoverable offset mismatch while finalizing: the server ' + + `expects byte ${serverOffset}, but the local buffer only covers ` + + `bytes [${bufferedStart}, ${currentOffset + (chunk?.length ?? 0)}). ` + + 'Start a new upload session or resume from the saved session URL.', + ); + } + } + } + + private decodeFinalResponse(response: ResumableUploadResponse): {} { + try { + return decodeResponse(this.context.rpc, true, response.body); + } catch (err) { + throw new Category3Error( + `Failed to decode the resumable upload final response: ${ + (err as Error).message + }`, + ); + } + } + + /** Fast-forwards the stream by discarding `bytes` bytes. */ + private async fastForward( + iterator: AsyncIterator, + bytes: number, + ): Promise { + let remaining = bytes; + while (remaining > 0) { + const next = await iterator.next(); + if (next.done) { + throw new Category3Error( + 'The provided stream ended before reaching the committed upload ' + + `offset of ${bytes} bytes. Provide a stream with the full payload.`, + ); + } + remaining -= asBuffer(next.value).length; + } + } + + /** Skips (discards) `bytes` bytes from the stream. */ + private async skipBytes( + iterator: AsyncIterator, + bytes: number, + ): Promise { + let remaining = bytes; + while (remaining > 0) { + const next = await iterator.next(); + if (next.done) { + throw new Category3Error( + `The server committed ${bytes} bytes beyond the end of the ` + + 'provided stream; the payload appears shorter than expected.', + ); + } + remaining -= asBuffer(next.value).length; + } + } + + /** + * Sends a single protocol command, retrying transient (Category 1) errors + * with exponential backoff. + */ + private async sendCommandWithRetry( + url: string, + command: string, + body: Buffer | string | null, + offset: number, + extraHeaders: {[name: string]: string} | undefined, + ): Promise { + const retry = this.getRetrySettings(); + let attempt = 0; + let delay = retry.initialDelayMs; + + // eslint-disable-next-line no-constant-condition + while (true) { + try { + return await this.fetchCommand( + url, + command, + body, + offset, + extraHeaders, + ); + } catch (err) { + if (this.canceled_) { + throw createGoogleError( + 'The resumable upload was cancelled.', + Status.CANCELLED, + ); + } + if (err instanceof Category2Error || err instanceof Category3Error) { + throw err; + } + if (!(err instanceof TransientError)) { + throw err; + } + if (attempt >= retry.maxRetries) { + throw createGoogleError( + `Exceeded the maximum number of retries (${retry.maxRetries}) ` + + `while sending the resumable upload command "${command}".`, + Status.DEADLINE_EXCEEDED, + ); + } + this.assertDeadline(); + await sleep(delay); + delay = Math.min(delay * retry.delayMultiplier, retry.maxDelayMs); + attempt += 1; + } + } + } + + private async fetchCommand( + url: string, + command: string, + body: Buffer | string | null, + offset: number, + extraHeaders: {[name: string]: string} | undefined, + ): Promise { + const headers: {[name: string]: string} = { + [UPLOAD_PROTOCOL_HEADER]: UPLOAD_PROTOCOL_RESUMABLE, + [UPLOAD_COMMAND_HEADER]: command, + }; + const requiresOffset = + body !== null || + command === COMMAND_UPLOAD || + command === COMMAND_UPLOAD_FINALIZE || + command === COMMAND_FINALIZE; + if (requiresOffset && offset >= 0) { + headers[UPLOAD_OFFSET_HEADER] = String(offset); + } + if (command === COMMAND_START) { + headers['content-type'] = 'application/json'; + } else if (body !== null) { + headers['content-type'] = 'application/octet-stream'; + } + if (extraHeaders) { + for (const [name, value] of Object.entries(extraHeaders)) { + headers[name.toLowerCase()] = value; + } + } + + const controller = new AbortController(); + this.activeAbortController = controller; + try { + // Mirror the fetch behavior used by the REST fallback transport: + // `responseType: 'stream'` returns a Response-like object with access + // to status, headers, and the body. `validateStatus` is disabled so + // error statuses can be classified as Category 1/2/3 by the state + // machine instead of being rejected by gaxios. + const response = (await this.context.auth.request({ + url, + method: 'POST', + headers, + body: + body === null || body === undefined + ? undefined + : typeof body === 'string' + ? body + : Buffer.from(body), + signal: controller.signal, + responseType: 'stream', + timeout: this.params?.timeout ?? DEFAULT_PER_REQUEST_TIMEOUT_MS, + validateStatus: () => true, + })) as unknown as Response; + const responseBody = Buffer.from(await response.arrayBuffer()); + const uploadResponse: ResumableUploadResponse = { + status: response.status, + headers: this.normalizeHeaders(response.headers), + body: responseBody, + }; + this.throwOnNonTransientStatus(uploadResponse, command); + return uploadResponse; + } catch (err) { + if (this.canceled_) { + throw createGoogleError( + 'The resumable upload was cancelled.', + Status.CANCELLED, + ); + } + if (err instanceof Category2Error || err instanceof Category3Error) { + throw err; + } + throw new TransientError( + 'Transient failure while sending the resumable upload command ' + + `"${command}": ${(err as Error).message}`, + ); + } finally { + if (this.activeAbortController === controller) { + this.activeAbortController = null; + } + } + } + + /** + * Classifies the HTTP response status. Transient errors are thrown as + * {@link TransientError}, state mismatches as {@link Category2Error}, and + * everything else as {@link Category3Error}. + */ + private throwOnNonTransientStatus( + response: ResumableUploadResponse, + command: string, + ): void { + if (response.status >= 200 && response.status < 300) { + const uploadStatus = response.headers.get(UPLOAD_STATUS_HEADER); + if (uploadStatus === null) { + if (command !== COMMAND_START && command !== COMMAND_QUERY) { + // A missing status header on a transmission/finalizing response is + // a recoverable state mismatch. + throw new Category2Error( + 'The resumable upload response did not include a ' + + `${UPLOAD_STATUS_HEADER} header.`, + ); + } + throw new Category3Error( + `The resumable upload ${command} response did not include a ` + + `${UPLOAD_STATUS_HEADER} header.`, + ); + } + return; + } + if (CATEGORY_2_RETRY_CODES.has(response.status)) { + throw new Category2Error( + `Resumable upload state mismatch: HTTP ${response.status}.`, + response.status, + ); + } + if (CATEGORY_1_RETRY_CODES.has(response.status)) { + throw new TransientError( + `Resumable upload transient error: HTTP ${response.status}.`, + ); + } + throw new Category3Error( + `Resumable upload failed: HTTP ${response.status}.`, + response.status, + ); + } + + private normalizeHeaders(headers: unknown): { + get(name: string): string | null; + } { + if (headers && typeof (headers as {get?: unknown}).get === 'function') { + return headers as {get(name: string): string | null}; + } + const map = new Map(); + if (headers && typeof headers === 'object') { + for (const [name, value] of Object.entries( + headers as {[name: string]: unknown}, + )) { + map.set(name.toLowerCase(), String(value)); + } + } + return { + get(name: string): string | null { + return map.get(name.toLowerCase()) ?? null; + }, + }; + } + + private getRetrySettings(): { + maxRetries: number; + initialDelayMs: number; + delayMultiplier: number; + maxDelayMs: number; + } { + const retry = this.params?.retry; + if (retry === null) { + return { + maxRetries: 0, + initialDelayMs: 100, + delayMultiplier: 1.3, + maxDelayMs: 60000, + }; + } + const backoffSettings = + retry?.backoffSettings ?? createDefaultBackoffSettings(); + return { + maxRetries: backoffSettings.maxRetries ?? DEFAULT_MAX_INNER_RETRIES, + initialDelayMs: backoffSettings.initialRetryDelayMillis ?? 100, + delayMultiplier: backoffSettings.retryDelayMultiplier ?? 1.3, + maxDelayMs: backoffSettings.maxRetryDelayMillis ?? 60000, + }; + } + + private reportProgress(): void { + if (this.params?.onProgress && this.uploadUrl_) { + this.params.onProgress({ + bytesUploaded: this.committedBytes_, + uploadUrl: this.uploadUrl_, + }); + } + } + + private assertActive(): void { + if (this.canceled_) { + throw createGoogleError( + 'The resumable upload was cancelled.', + Status.CANCELLED, + ); + } + } + + private assertDeadline(): void { + if (Date.now() - this.startTimeMs >= this.globalDeadlineMs) { + throw createGoogleError( + 'The resumable upload exceeded its global deadline of ' + + `${this.globalDeadlineMs} ms.`, + Status.DEADLINE_EXCEEDED, + ); + } + } +} diff --git a/core/packages/gax/test/system-test/resumableUpload.ts b/core/packages/gax/test/system-test/resumableUpload.ts new file mode 100644 index 000000000000..38254e57ca1e --- /dev/null +++ b/core/packages/gax/test/system-test/resumableUpload.ts @@ -0,0 +1,277 @@ +/** + * Copyright 2026 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Hermetic end-to-end test for the resumable upload protocol: a real HTTP +// server (no credentials required) exercises the full state machine, +// including a simulated crash and cross-helper session resume. + +/* eslint-disable @typescript-eslint/no-explicit-any */ + +import assert from 'assert'; +import * as crypto from 'crypto'; +import * as fs from 'fs'; +import * as http from 'http'; +import {AddressInfo} from 'net'; +import * as os from 'os'; +import * as path from 'path'; +import * as protobuf from 'protobufjs'; +import {Readable} from 'stream'; +import {after, before, describe, it} from 'mocha'; + +import * as gax from '../../src'; +import {ResumableUploadContext} from '../../src/resumableUpload'; + +const GRANULARITY = 1024 * 1024; +const CHUNK_SIZE = 2 * 1024 * 1024; + +const PROTO = ` +syntax = "proto3"; +package test.v1; +message UploadRequest { string name = 1; } +message UploadResponse { string status = 1; } +service UploadService { + rpc CreateUpload(UploadRequest) returns (UploadResponse); +} +`; + +class MockResumableUploadServer { + server: http.Server; + port = 0; + sessionUrl = ''; + received = Buffer.alloc(0); + commands: Array<{command: string; offset: number; bodyLength: number}> = []; + + constructor() { + this.server = http.createServer((req, res) => { + void this.handle(req, res); + }); + } + + private async handle(req: http.IncomingMessage, res: http.ServerResponse) { + const chunks: Buffer[] = []; + for await (const chunk of req) { + chunks.push(chunk as Buffer); + } + const body = Buffer.concat(chunks); + const command = String(req.headers['x-goog-upload-command'] ?? ''); + const offset = parseInt( + String(req.headers['x-goog-upload-offset'] ?? '-1'), + 10, + ); + this.commands.push({command, offset, bodyLength: body.length}); + + const send = ( + status: number, + headers: {[name: string]: string}, + responseBody = '', + ) => { + res.writeHead(status, headers); + res.end(responseBody); + }; + const active = (extra: {[name: string]: string} = {}) => ({ + 'x-goog-upload-status': 'active', + 'x-goog-upload-size-received': String(this.received.length), + ...extra, + }); + + if (req.url === '/resumable/upload' && command === 'start') { + JSON.parse(body.toString()); + return send(200, { + 'x-goog-upload-status': 'active', + 'x-goog-upload-url': this.sessionUrl, + 'x-goog-upload-chunk-granularity': String(GRANULARITY), + }); + } + if (req.url !== '/upload/session-1') { + return send(404, active(), 'not found'); + } + if (command === 'query') { + return send(200, active()); + } + if (command === 'cancel') { + return send(200, {'x-goog-upload-status': 'cancelled'}); + } + if (command === 'upload' || command === 'upload, finalize') { + if (offset !== this.received.length) { + return send(416, active(), 'offset mismatch'); + } + this.received = Buffer.concat([this.received, body]); + if (command === 'upload, finalize') { + return send( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({status: 'done'}), + ); + } + return send(200, active()); + } + if (command === 'finalize') { + if (offset !== this.received.length) { + return send(416, active(), 'offset mismatch'); + } + return send( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({status: 'done'}), + ); + } + return send(400, active(), `unknown command ${command}`); + } + + listen(): Promise { + return new Promise(resolve => { + this.server.listen(0, '127.0.0.1', () => { + this.port = (this.server.address() as AddressInfo).port; + this.sessionUrl = `http://127.0.0.1:${this.port}/upload/session-1`; + resolve(); + }); + }); + } + + close(): Promise { + return new Promise(resolve => this.server.close(() => resolve())); + } +} + +class CrashingStream extends Readable { + private data: Buffer; + private pos = 0; + private limit: number; + + constructor(data: Buffer, limit: number) { + super(); + this.data = data; + this.limit = limit; + } + + _read(): void { + if (this.pos >= this.limit) { + this.destroy(new Error('simulated process crash')); + return; + } + const end = Math.min(this.pos + 65536, this.limit); + const chunk = this.data.subarray(this.pos, end); + this.pos = end; + this.push(chunk); + } +} + +// A minimal authenticated client that forwards requests to the local mock +// server through the real fetch implementation. +const fakeAuth = { + async request(opts: { + url?: string; + method?: string; + headers?: {[name: string]: string}; + body?: string | Buffer; + signal?: AbortSignal; + }) { + return fetch(opts.url!, { + method: opts.method, + headers: opts.headers, + body: opts.body, + signal: opts.signal, + }); + }, +}; + +describe('resumable upload (system)', () => { + let server: MockResumableUploadServer; + let context: ResumableUploadContext; + let data: Buffer; + let file: string; + + before(async () => { + server = new MockResumableUploadServer(); + await server.listen(); + const root = protobuf.parse(PROTO).root; + const service = root.lookupService('test.v1.UploadService'); + service.resolveAll(); + context = { + auth: fakeAuth as any, + servicePath: `127.0.0.1:${server.port}`, + servicePort: server.port, + protocol: 'http', + rpc: service.methods.CreateUpload, + request: {name: 'test'}, + uploadPrefix: '/resumable/upload', + }; + data = crypto.randomBytes(Math.floor(5.5 * GRANULARITY)); + file = path.join(os.tmpdir(), 'gax-resumable-upload-e2e.bin'); + fs.writeFileSync(file, data); + }); + + after(async () => { + try { + fs.unlinkSync(file); + } catch { + // ignore + } + await server.close(); + }); + + it('uploads a payload over HTTP and completes the session', async () => { + const helper = new gax.ResumableUpload(context); + const progress: Array<{bytesUploaded: number}> = []; + await helper.start({ + uploadStream: fs.createReadStream(file), + chunkSize: CHUNK_SIZE, + onProgress: status => progress.push(status), + }); + const response = (await helper.finished()) as {status: string}; + + assert.strictEqual(response.status, 'done'); + assert.ok(server.received.equals(data)); + assert.deepStrictEqual( + server.commands.map(c => c.command), + ['start', 'upload', 'upload', 'upload, finalize'], + ); + assert.deepStrictEqual( + server.commands.slice(1).map(c => c.offset), + [0, 2 * GRANULARITY, 4 * GRANULARITY], + ); + assert.ok(progress.length >= 2); + }); + + it('recovers from a simulated crash using a saved session URL', async () => { + server.received = Buffer.alloc(0); + server.commands = []; + + const crashed = new gax.ResumableUpload(context); + await crashed.start({ + uploadStream: new CrashingStream(data, 2 * CHUNK_SIZE), + chunkSize: CHUNK_SIZE, + }); + await assert.rejects(crashed.finished(), /simulated process crash/); + const committed = server.received.length; + assert.strictEqual(committed, 2 * CHUNK_SIZE); + const sessionUrl = crashed.uploadUrl!; + + const resumed = new gax.ResumableUpload(context); + const resumedProgress: Array<{bytesUploaded: number}> = []; + await resumed.start({ + uploadStream: fs.createReadStream(file), + resumeUrl: sessionUrl, + chunkSize: CHUNK_SIZE, + onProgress: status => resumedProgress.push(status), + }); + const response = (await resumed.finished()) as {status: string}; + + assert.strictEqual(response.status, 'done'); + assert.ok(server.received.equals(data)); + assert.strictEqual(resumedProgress[0].bytesUploaded, committed); + }); +}); diff --git a/core/packages/gax/test/unit/resumableUpload.ts b/core/packages/gax/test/unit/resumableUpload.ts new file mode 100644 index 000000000000..a03270d96031 --- /dev/null +++ b/core/packages/gax/test/unit/resumableUpload.ts @@ -0,0 +1,792 @@ +/** + * Copyright 2026 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* eslint-disable @typescript-eslint/no-explicit-any */ + +import assert from 'assert'; +import {afterEach, describe, it} from 'mocha'; +import * as protobuf from 'protobufjs'; +import {Readable} from 'stream'; +import * as sinon from 'sinon'; + +import * as gax from '../../src'; +import {createApiCall} from '../../src/createApiCall'; +import {ResumableUploadContext} from '../../src/resumableUpload'; +import {Status} from '../../src/status'; + +const GRANULARITY = 1024 * 1024; +const SESSION_URL = 'https://example.com/upload/session-123'; + +const PROTO = ` +syntax = "proto3"; +package test.v1; +message UploadRequest { string name = 1; } +message UploadResponse { string name = 1; } +service UploadService { + rpc CreateUpload(UploadRequest) returns (UploadResponse); +} +`; + +interface MockRequestOptions { + url?: string; + method?: string; + headers?: {[name: string]: string}; + body?: string | Buffer; + signal?: AbortSignal; + responseType?: string; + timeout?: number; + validateStatus?: (status: number) => boolean; +} + +interface MockResponse { + status: number; + headers: {get(name: string): string | null}; + arrayBuffer(): Promise; +} + +function resumableUploadResponse( + status: number, + headers: {[name: string]: string}, + body = '', +): MockResponse { + const normalized: {[name: string]: string} = {}; + for (const [name, value] of Object.entries(headers)) { + normalized[name.toLowerCase()] = value; + } + return { + status, + headers: { + get(name: string): string | null { + return normalized[name.toLowerCase()] ?? null; + }, + }, + async arrayBuffer(): Promise { + return Buffer.from(body) as unknown as ArrayBuffer; + }, + }; +} + +type RequestHandler = ( + opts: MockRequestOptions, +) => MockResponse | Promise; + +function mockAuth(handler: RequestHandler) { + return { + request: sinon.stub().callsFake(async (opts: MockRequestOptions) => { + return handler(opts); + }), + }; +} + +function commandOf(opts: MockRequestOptions): string { + return opts.headers?.['x-goog-upload-command'] ?? ''; +} + +function offsetOf(opts: MockRequestOptions): number { + const value = opts.headers?.['x-goog-upload-offset']; + return value === undefined ? -1 : parseInt(value, 10); +} + +function bodyLength(opts: MockRequestOptions): number { + return opts.body === undefined ? 0 : opts.body.length; +} + +function sleep(ms: number): Promise { + return new Promise(resolve => setTimeout(resolve, ms)); +} + +const root = protobuf.parse(PROTO).root; +const uploadService = root.lookupService('test.v1.UploadService'); +uploadService.resolveAll(); +const rpc = uploadService.methods.CreateUpload; + +function buildContext( + auth: any, + overrides: Partial = {}, +): ResumableUploadContext { + return { + auth, + servicePath: 'example.com', + servicePort: 443, + protocol: 'https', + rpc, + request: {name: 'test'}, + uploadPrefix: '/resumable/upload', + ...overrides, + }; +} + +describe('resumable upload', () => { + afterEach(() => { + sinon.restore(); + }); + + it('uploads a payload in chunks and resolves with the final response', async () => { + const requests: MockRequestOptions[] = []; + const auth = mockAuth(async opts => { + requests.push(opts); + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + 'x-goog-upload-chunk-granularity': String(GRANULARITY), + }); + } + if (command === 'upload') { + return resumableUploadResponse(200, {'x-goog-upload-status': 'active'}); + } + if (command === 'upload, finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + if (command === 'finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + const progress: Array<{bytesUploaded: number; uploadUrl: string}> = []; + const stream = Readable.from([ + Buffer.alloc(GRANULARITY), + Buffer.alloc(GRANULARITY), + Buffer.alloc(GRANULARITY), + ]); + + await helper.start({ + uploadStream: stream, + chunkSize: GRANULARITY, + onProgress: status => progress.push(status), + }); + const response = await helper.finished(); + + assert.deepStrictEqual(response, {name: 'complete'}); + assert.strictEqual(helper.uploadUrl, SESSION_URL); + assert.deepStrictEqual( + requests.map(r => commandOf(r)), + ['start', 'upload', 'upload', 'upload', 'finalize'], + ); + assert.deepStrictEqual( + requests.slice(1).map(r => offsetOf(r)), + [0, GRANULARITY, 2 * GRANULARITY, 3 * GRANULARITY], + ); + assert.deepStrictEqual( + requests.slice(1, 4).map(r => bodyLength(r)), + [GRANULARITY, GRANULARITY, GRANULARITY], + ); + assert.strictEqual(requests[0].body, JSON.stringify({name: 'test'})); + assert.strictEqual(requests[0].headers!['x-goog-upload-offset'], undefined); + assert.deepStrictEqual(progress, [ + {bytesUploaded: GRANULARITY, uploadUrl: SESSION_URL}, + {bytesUploaded: 2 * GRANULARITY, uploadUrl: SESSION_URL}, + {bytesUploaded: 3 * GRANULARITY, uploadUrl: SESSION_URL}, + ]); + }); + + it('combines the final partial chunk with the finalize command', async () => { + const requests: MockRequestOptions[] = []; + const auth = mockAuth(async opts => { + requests.push(opts); + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + }); + } + if (command === 'upload') { + return resumableUploadResponse(200, {'x-goog-upload-status': 'active'}); + } + if (command === 'upload, finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + if (command === 'finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + const payload = Buffer.concat([ + Buffer.alloc(GRANULARITY), + Buffer.alloc(GRANULARITY / 2), + ]); + await helper.start({ + uploadStream: Readable.from([payload]), + chunkSize: GRANULARITY, + }); + await helper.finished(); + + assert.deepStrictEqual( + requests.map(r => commandOf(r)), + ['start', 'upload', 'upload, finalize'], + ); + assert.deepStrictEqual( + requests.slice(1).map(r => offsetOf(r)), + [0, GRANULARITY], + ); + assert.strictEqual(bodyLength(requests[2]), GRANULARITY / 2); + }); + + it('parses host and port from the service path', async () => { + const requests: MockRequestOptions[] = []; + const auth = mockAuth(async opts => { + requests.push(opts); + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + }); + } + if (command === 'finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload( + buildContext(auth, {servicePath: 'example.com:8443'}), + ); + await helper.start({ + uploadStream: Readable.from([]), + chunkSize: GRANULARITY, + }); + await helper.finished(); + + assert.strictEqual( + requests[0].url, + 'https://example.com:8443/resumable/upload', + ); + }); + + it('rounds the chunk size down to the server granularity', async () => { + const requests: MockRequestOptions[] = []; + const auth = mockAuth(async opts => { + requests.push(opts); + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + 'x-goog-upload-chunk-granularity': String(GRANULARITY), + }); + } + if (command === 'upload') { + return resumableUploadResponse(200, {'x-goog-upload-status': 'active'}); + } + if (command === 'upload, finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + if (command === 'finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + const payload = Buffer.concat([ + Buffer.alloc(3 * GRANULARITY), + Buffer.alloc(1), + ]); + await helper.start({ + uploadStream: Readable.from([payload]), + chunkSize: 3.5 * GRANULARITY, + }); + await helper.finished(); + + assert.deepStrictEqual( + requests.slice(1).map(r => bodyLength(r)), + [3 * GRANULARITY, 1], + ); + }); + + it('retries transient (Category 1) errors with backoff', async () => { + let uploadAttempts = 0; + const requests: MockRequestOptions[] = []; + const auth = mockAuth(async opts => { + requests.push(opts); + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + }); + } + if (command === 'upload') { + uploadAttempts += 1; + if (uploadAttempts === 1) { + return resumableUploadResponse(503, {'x-goog-upload-status': 'active'}); + } + return resumableUploadResponse(200, {'x-goog-upload-status': 'active'}); + } + if (command === 'upload, finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + if (command === 'finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + await helper.start({ + uploadStream: Readable.from([Buffer.alloc(GRANULARITY)]), + chunkSize: GRANULARITY, + }); + await helper.finished(); + + assert.strictEqual(uploadAttempts, 2); + const uploads = requests.filter(r => commandOf(r) === 'upload'); + assert.ok( + Buffer.from(uploads[0].body as Buffer).equals( + Buffer.from(uploads[1].body as Buffer), + ), + ); + }); + + it('does not retry transient errors when retries are disabled', async () => { + let uploadAttempts = 0; + const auth = mockAuth(async opts => { + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + }); + } + if (command === 'upload') { + uploadAttempts += 1; + return resumableUploadResponse(503, {'x-goog-upload-status': 'active'}); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + await helper.start({ + uploadStream: Readable.from([Buffer.alloc(GRANULARITY)]), + chunkSize: GRANULARITY, + retry: null, + }); + await assert.rejects( + helper.finished(), + (err: gax.GoogleError) => err.code === Status.DEADLINE_EXCEEDED, + ); + assert.strictEqual(uploadAttempts, 1); + }); + + it('recovers from a 416 state mismatch by querying the offset', async () => { + const requests: MockRequestOptions[] = []; + let firstUpload = true; + const auth = mockAuth(async opts => { + requests.push(opts); + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + }); + } + if (command === 'query') { + return resumableUploadResponse(200, { + 'x-goog-upload-status': 'active', + 'x-goog-upload-size-received': '0', + }); + } + if (command === 'upload') { + if (firstUpload) { + firstUpload = false; + return resumableUploadResponse(416, {'x-goog-upload-status': 'active'}); + } + return resumableUploadResponse(200, {'x-goog-upload-status': 'active'}); + } + if (command === 'upload, finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + if (command === 'finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + await helper.start({ + uploadStream: Readable.from([Buffer.alloc(GRANULARITY)]), + chunkSize: GRANULARITY, + }); + await helper.finished(); + + assert.deepStrictEqual( + requests.map(r => commandOf(r)), + ['start', 'upload', 'query', 'upload', 'finalize'], + ); + const uploads = requests.filter(r => commandOf(r) === 'upload'); + assert.strictEqual(uploads.length, 2); + assert.ok( + Buffer.from(uploads[0].body as Buffer).equals( + Buffer.from(uploads[1].body as Buffer), + ), + ); + }); + + it('continues from the committed offset when the chunk was saved', async () => { + const requests: MockRequestOptions[] = []; + const auth = mockAuth(async opts => { + requests.push(opts); + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + }); + } + if (command === 'query') { + return resumableUploadResponse(200, { + 'x-goog-upload-status': 'active', + 'x-goog-upload-size-received': String(GRANULARITY), + }); + } + if (command === 'upload') { + if (offsetOf(opts) === 0) { + return resumableUploadResponse(416, {'x-goog-upload-status': 'active'}); + } + return resumableUploadResponse(200, {'x-goog-upload-status': 'active'}); + } + if (command === 'upload, finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + if (command === 'upload') { + return resumableUploadResponse(200, {'x-goog-upload-status': 'active'}); + } + if (command === 'finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + const stream = Readable.from([ + Buffer.alloc(GRANULARITY), + Buffer.alloc(GRANULARITY), + ]); + await helper.start({uploadStream: stream, chunkSize: GRANULARITY}); + await helper.finished(); + + const uploads = requests.filter(r => commandOf(r) === 'upload'); + assert.deepStrictEqual( + uploads.map(r => offsetOf(r)), + [0, GRANULARITY], + ); + }); + + it('treats a 200 response without X-Goog-Upload-Status as recoverable', async () => { + const requests: MockRequestOptions[] = []; + let firstUpload = true; + const auth = mockAuth(async opts => { + requests.push(opts); + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + }); + } + if (command === 'query') { + return resumableUploadResponse(200, { + 'x-goog-upload-status': 'active', + 'x-goog-upload-size-received': '0', + }); + } + if (command === 'upload') { + if (firstUpload) { + firstUpload = false; + return resumableUploadResponse(200, {}); + } + return resumableUploadResponse(200, {'x-goog-upload-status': 'active'}); + } + if (command === 'upload, finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + if (command === 'finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + await helper.start({ + uploadStream: Readable.from([Buffer.alloc(GRANULARITY)]), + chunkSize: GRANULARITY, + }); + await helper.finished(); + + assert.deepStrictEqual( + requests.map(r => commandOf(r)), + ['start', 'upload', 'query', 'upload', 'finalize'], + ); + }); + + it('throws fatal (Category 3) errors without retrying', async () => { + let uploadAttempts = 0; + const auth = mockAuth(async opts => { + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + }); + } + if (command === 'upload') { + uploadAttempts += 1; + return resumableUploadResponse(403, {'x-goog-upload-status': 'active'}); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + await helper.start({ + uploadStream: Readable.from([Buffer.alloc(GRANULARITY)]), + chunkSize: GRANULARITY, + }); + await assert.rejects( + helper.finished(), + (err: gax.GoogleError) => err.code === Status.PERMISSION_DENIED, + ); + assert.strictEqual(uploadAttempts, 1); + }); + + it('resumes from a session URL and fast-forwards the stream', async () => { + const requests: MockRequestOptions[] = []; + const auth = mockAuth(async opts => { + requests.push(opts); + const command = commandOf(opts); + if (command === 'query') { + return resumableUploadResponse(200, { + 'x-goog-upload-status': 'active', + 'x-goog-upload-size-received': String(2 * GRANULARITY), + }); + } + if (command === 'upload, finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + if (command === 'upload') { + return resumableUploadResponse(200, {'x-goog-upload-status': 'active'}); + } + if (command === 'finalize') { + return resumableUploadResponse( + 200, + {'x-goog-upload-status': 'final'}, + JSON.stringify({name: 'complete'}), + ); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + const stream = Readable.from([ + Buffer.alloc(GRANULARITY), + Buffer.alloc(GRANULARITY), + Buffer.alloc(GRANULARITY), + ]); + await helper.start({ + uploadStream: stream, + chunkSize: GRANULARITY, + resumeUrl: SESSION_URL, + }); + const response = await helper.finished(); + + assert.deepStrictEqual(response, {name: 'complete'}); + assert.deepStrictEqual( + requests.map(r => commandOf(r)), + ['query', 'upload', 'finalize'], + ); + assert.strictEqual(offsetOf(requests[1]), 2 * GRANULARITY); + assert.strictEqual(bodyLength(requests[1]), GRANULARITY); + assert.strictEqual(offsetOf(requests[2]), 3 * GRANULARITY); + assert.strictEqual(helper.uploadUrl, SESSION_URL); + }); + + it('aborts when the global deadline is exceeded', async () => { + const auth = mockAuth(async opts => { + const command = commandOf(opts); + if (command === 'start') { + await sleep(20); + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + }); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + await helper.start({ + uploadStream: Readable.from([Buffer.alloc(10)]), + globalDeadlineMs: 5, + uploadSize: 10 * 1024 * 1024 * 1024, + }); + await assert.rejects( + helper.finished(), + (err: gax.GoogleError) => err.code === Status.DEADLINE_EXCEEDED, + ); + }); + + it('cancels an in-flight upload and notifies the server', async () => { + const requests: MockRequestOptions[] = []; + const auth = mockAuth(opts => { + requests.push(opts); + const command = commandOf(opts); + if (command === 'start') { + return resumableUploadResponse(200, { + 'x-goog-upload-url': SESSION_URL, + 'x-goog-upload-status': 'active', + }); + } + if (command === 'upload') { + // Never resolves until the upload is cancelled. + return new Promise(() => {}); + } + if (command === 'cancel') { + return resumableUploadResponse(200, {'x-goog-upload-status': 'cancelled'}); + } + throw new Error(`Unexpected command: ${command}`); + }); + + const helper = new gax.ResumableUpload(buildContext(auth)); + const stream = new Readable({read() {}}); + stream.push(Buffer.alloc(GRANULARITY)); + await helper.start({uploadStream: stream, chunkSize: GRANULARITY}); + + helper.cancel(); + await assert.rejects( + helper.finished(), + (err: gax.GoogleError) => err.code === Status.CANCELLED, + ); + assert.ok( + requests.some(r => commandOf(r) === 'cancel'), + 'expected a cancel command to be sent', + ); + }); + + it('resolves the GAPIC method call with a ResumableUpload helper', async () => { + const auth = mockAuth(() => { + throw new Error('No request should be made before start()'); + }); + const descriptor = new gax.ResumableUploadDescriptor('/resumable/upload'); + const settings = new gax.CallSettings(); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const func = async () => ({cancel() {}}); + const apiCall = createApiCall( + // eslint-disable-next-line @typescript-eslint/no-explicit-any + Promise.resolve(func as any), + settings, + descriptor, + ); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const result = (await (apiCall( + {name: 'test'}, + {resumableUpload: buildContext(auth)}, + ) as Promise)) as any; + assert.ok(result[0] instanceof gax.ResumableUpload); + assert.strictEqual( + // eslint-disable-next-line @typescript-eslint/no-explicit-any + (result[0] as any).context.uploadPrefix, + '/resumable/upload', + ); + }); + + it('rejects the GAPIC method call when the transport context is missing', async () => { + const descriptor = new gax.ResumableUploadDescriptor(); + const settings = new gax.CallSettings(); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const func = async () => ({cancel() {}}); + const apiCall = createApiCall( + // eslint-disable-next-line @typescript-eslint/no-explicit-any + Promise.resolve(func as any), + settings, + descriptor, + ); + await assert.rejects( + // eslint-disable-next-line @typescript-eslint/no-explicit-any + apiCall({} as any, {} as any) as Promise, + /resumable upload transport context/, + ); + }); +});