Commit inicial

node_modules/.bin/proto-loader-gen-types

@@ -0,0 +1 @@
+../@grpc/proto-loader/build/bin/proto-loader-gen-types.js

node_modules/.package-lock.json

@@ -0,0 +1,307 @@
+{
+  "name": "grpc",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@grpc/grpc-js": {
+      "version": "1.10.8",
+      "resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.10.8.tgz",
+      "integrity": "sha512-vYVqYzHicDqyKB+NQhAc54I1QWCBLCrYG6unqOIcBTHx+7x8C9lcoLj3KVJXs2VB4lUbpWY+Kk9NipcbXYWmvg==",
+      "dependencies": {
+        "@grpc/proto-loader": "^0.7.13",
+        "@js-sdsl/ordered-map": "^4.4.2"
+      },
+      "engines": {
+        "node": ">=12.10.0"
+      }
+    },
+    "node_modules/@grpc/proto-loader": {
+      "version": "0.7.13",
+      "resolved": "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.7.13.tgz",
+      "integrity": "sha512-AiXO/bfe9bmxBjxxtYxFAXGZvMaN5s8kO+jBHAJCON8rJoB5YS/D6X7ZNc6XQkuHNmyl4CYaMI1fJ/Gn27RGGw==",
+      "dependencies": {
+        "lodash.camelcase": "^4.3.0",
+        "long": "^5.0.0",
+        "protobufjs": "^7.2.5",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/@js-sdsl/ordered-map": {
+      "version": "4.4.2",
+      "resolved": "https://registry.npmjs.org/@js-sdsl/ordered-map/-/ordered-map-4.4.2.tgz",
+      "integrity": "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw==",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/js-sdsl"
+      }
+    },
+    "node_modules/@protobufjs/aspromise": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ=="
+    },
+    "node_modules/@protobufjs/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg=="
+    },
+    "node_modules/@protobufjs/codegen": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz",
+      "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg=="
+    },
+    "node_modules/@protobufjs/eventemitter": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
+      "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q=="
+    },
+    "node_modules/@protobufjs/fetch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz",
+      "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.1",
+        "@protobufjs/inquire": "^1.1.0"
+      }
+    },
+    "node_modules/@protobufjs/float": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ=="
+    },
+    "node_modules/@protobufjs/inquire": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz",
+      "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q=="
+    },
+    "node_modules/@protobufjs/path": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA=="
+    },
+    "node_modules/@protobufjs/pool": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw=="
+    },
+    "node_modules/@protobufjs/utf8": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz",
+      "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw=="
+    },
+    "node_modules/@types/node": {
+      "version": "20.14.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.14.1.tgz",
+      "integrity": "sha512-T2MzSGEu+ysB/FkWfqmhV3PLyQlowdptmmgD20C6QxsS8Fmv5SjpZ1ayXaEC0S21/h5UJ9iA6W/5vSNU5l00OA==",
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
+    },
+    "node_modules/escalade": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz",
+      "integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/lodash.camelcase": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz",
+      "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA=="
+    },
+    "node_modules/long": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.2.3.tgz",
+      "integrity": "sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q=="
+    },
+    "node_modules/protobufjs": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.3.0.tgz",
+      "integrity": "sha512-YWD03n3shzV9ImZRX3ccbjqLxj7NokGN0V/ESiBV5xWqrommYHYiihuIyavq03pWSGqlyvYUFmfoMKd+1rPA/g==",
+      "hasInstallScript": true,
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.2",
+        "@protobufjs/base64": "^1.1.2",
+        "@protobufjs/codegen": "^2.0.4",
+        "@protobufjs/eventemitter": "^1.1.0",
+        "@protobufjs/fetch": "^1.1.0",
+        "@protobufjs/float": "^1.0.2",
+        "@protobufjs/inquire": "^1.1.0",
+        "@protobufjs/path": "^1.1.2",
+        "@protobufjs/pool": "^1.1.0",
+        "@protobufjs/utf8": "^1.1.0",
+        "@types/node": ">=13.7.0",
+        "long": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "5.26.5",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="
+    },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "engines": {
+        "node": ">=12"
+      }
+    }
+  }
+}

node_modules/@grpc/grpc-js/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   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.

node_modules/@grpc/grpc-js/README.md

@@ -0,0 +1,82 @@
+# Pure JavaScript gRPC Client
+
+## Installation
+
+Node 12 is recommended. The exact set of compatible Node versions can be found in the `engines` field of the `package.json` file.
+
+```sh
+npm install @grpc/grpc-js
+```
+
+## Documentation
+
+Documentation specifically for the `@grpc/grpc-js` package is currently not available. However, [documentation is available for the `grpc` package](https://grpc.github.io/grpc/node/grpc.html), and the two packages contain mostly the same interface. There are a few notable differences, however, and these differences are noted in the "Migrating from grpc" section below.
+
+## Features
+
+- Clients
+- Automatic reconnection
+- Servers
+- Streaming
+- Metadata
+- Partial compression support: clients can compress and decompress messages, and servers can decompress request messages
+- Pick first and round robin load balancing policies
+- Client Interceptors
+- Connection Keepalives
+- HTTP Connect support (proxies)
+
+If you need a feature from the `grpc` package that is not provided by the `@grpc/grpc-js`, please file a feature request with that information.
+
+This library does not directly handle `.proto` files. To use `.proto` files with this library we recommend using the `@grpc/proto-loader` package.
+
+## Migrating from [`grpc`](https://www.npmjs.com/package/grpc)
+
+`@grpc/grpc-js` is almost a drop-in replacement for `grpc`, but you may need to make a few code changes to use it:
+
+- If you are currently loading `.proto` files using `grpc.load`, that function is not available in this library. You should instead load your `.proto` files using `@grpc/proto-loader` and load the resulting package definition objects into `@grpc/grpc-js` using `grpc.loadPackageDefinition`.
+- If you are currently loading packages generated by `grpc-tools`, you should instead generate your files using the `generate_package_definition` option in `grpc-tools`, then load the object exported by the generated file into `@grpc/grpc-js` using `grpc.loadPackageDefinition`.
+- If you have a server and you are using `Server#bind` to bind ports, you will need to use `Server#bindAsync` instead.
+- If you are using any channel options supported in `grpc` but not supported in `@grpc/grpc-js`, you may need to adjust your code to handle the different behavior. Refer to [the list of supported options](#supported-channel-options) below.
+- Refer to the [detailed package comparison](https://github.com/grpc/grpc-node/blob/master/PACKAGE-COMPARISON.md) for more details on the differences between `grpc` and `@grpc/grpc-js`.
+
+## Supported Channel Options
+Many channel arguments supported in `grpc` are not supported in `@grpc/grpc-js`. The channel arguments supported by `@grpc/grpc-js` are:
+  - `grpc.ssl_target_name_override`
+  - `grpc.primary_user_agent`
+  - `grpc.secondary_user_agent`
+  - `grpc.default_authority`
+  - `grpc.keepalive_time_ms`
+  - `grpc.keepalive_timeout_ms`
+  - `grpc.keepalive_permit_without_calls`
+  - `grpc.service_config`
+  - `grpc.max_concurrent_streams`
+  - `grpc.initial_reconnect_backoff_ms`
+  - `grpc.max_reconnect_backoff_ms`
+  - `grpc.use_local_subchannel_pool`
+  - `grpc.max_send_message_length`
+  - `grpc.max_receive_message_length`
+  - `grpc.enable_http_proxy`
+  - `grpc.default_compression_algorithm`
+  - `grpc.enable_channelz`
+  - `grpc.dns_min_time_between_resolutions_ms`
+  - `grpc.enable_retries`
+  - `grpc.max_connection_age_ms`
+  - `grpc.max_connection_age_grace_ms`
+  - `grpc.max_connection_idle_ms`
+  - `grpc.per_rpc_retry_buffer_size`
+  - `grpc.retry_buffer_size`
+  - `grpc.service_config_disable_resolution`
+  - `grpc.client_idle_timeout_ms`
+  - `grpc-node.max_session_memory`
+  - `grpc-node.tls_enable_trace`
+  - `channelOverride`
+  - `channelFactoryOverride`
+
+## Some Notes on API Guarantees
+
+The public API of this library follows semantic versioning, with some caveats:
+
+- Some methods are prefixed with an underscore. These methods are internal and should not be considered part of the public API.
+- The class `Call` is only exposed due to limitations of TypeScript. It should not be considered part of the public API.
+- In general, any API that is exposed by this library but is not exposed by the `grpc` library is likely an error and should not be considered part of the public API.
+- The `grpc.experimental` namespace contains APIs that have not stabilized. Any API in that namespace may break in any minor version update.

node_modules/@grpc/grpc-js/build/src/admin.d.ts

@@ -0,0 +1,11 @@
+import { ServiceDefinition } from './make-client';
+import { Server, UntypedServiceImplementation } from './server';
+interface GetServiceDefinition {
+    (): ServiceDefinition;
+}
+interface GetHandlers {
+    (): UntypedServiceImplementation;
+}
+export declare function registerAdminService(getServiceDefinition: GetServiceDefinition, getHandlers: GetHandlers): void;
+export declare function addAdminServicesToServer(server: Server): void;
+export {};

node_modules/@grpc/grpc-js/build/src/admin.js

@@ -0,0 +1,31 @@
+"use strict";
+/*
+ * Copyright 2021 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAdminServicesToServer = exports.registerAdminService = void 0;
+const registeredAdminServices = [];
+function registerAdminService(getServiceDefinition, getHandlers) {
+    registeredAdminServices.push({ getServiceDefinition, getHandlers });
+}
+exports.registerAdminService = registerAdminService;
+function addAdminServicesToServer(server) {
+    for (const { getServiceDefinition, getHandlers } of registeredAdminServices) {
+        server.addService(getServiceDefinition(), getHandlers());
+    }
+}
+exports.addAdminServicesToServer = addAdminServicesToServer;
+//# sourceMappingURL=admin.js.map

node_modules/@grpc/grpc-js/build/src/admin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.js","sourceRoot":"","sources":["../../src/admin.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAaH,MAAM,uBAAuB,GAGvB,EAAE,CAAC;AAET,SAAgB,oBAAoB,CAClC,oBAA0C,EAC1C,WAAwB;IAExB,uBAAuB,CAAC,IAAI,CAAC,EAAE,oBAAoB,EAAE,WAAW,EAAE,CAAC,CAAC;AACtE,CAAC;AALD,oDAKC;AAED,SAAgB,wBAAwB,CAAC,MAAc;IACrD,KAAK,MAAM,EAAE,oBAAoB,EAAE,WAAW,EAAE,IAAI,uBAAuB,EAAE,CAAC;QAC5E,MAAM,CAAC,UAAU,CAAC,oBAAoB,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC;IAC3D,CAAC;AACH,CAAC;AAJD,4DAIC"}

node_modules/@grpc/grpc-js/build/src/backoff-timeout.d.ts

@@ -0,0 +1,90 @@
+export interface BackoffOptions {
+    initialDelay?: number;
+    multiplier?: number;
+    jitter?: number;
+    maxDelay?: number;
+}
+export declare class BackoffTimeout {
+    private callback;
+    /**
+     * The delay time at the start, and after each reset.
+     */
+    private readonly initialDelay;
+    /**
+     * The exponential backoff multiplier.
+     */
+    private readonly multiplier;
+    /**
+     * The maximum delay time
+     */
+    private readonly maxDelay;
+    /**
+     * The maximum fraction by which the delay time can randomly vary after
+     * applying the multiplier.
+     */
+    private readonly jitter;
+    /**
+     * The delay time for the next time the timer runs.
+     */
+    private nextDelay;
+    /**
+     * The handle of the underlying timer. If running is false, this value refers
+     * to an object representing a timer that has ended, but it can still be
+     * interacted with without error.
+     */
+    private timerId;
+    /**
+     * Indicates whether the timer is currently running.
+     */
+    private running;
+    /**
+     * Indicates whether the timer should keep the Node process running if no
+     * other async operation is doing so.
+     */
+    private hasRef;
+    /**
+     * The time that the currently running timer was started. Only valid if
+     * running is true.
+     */
+    private startTime;
+    /**
+     * The approximate time that the currently running timer will end. Only valid
+     * if running is true.
+     */
+    private endTime;
+    constructor(callback: () => void, options?: BackoffOptions);
+    private runTimer;
+    /**
+     * Call the callback after the current amount of delay time
+     */
+    runOnce(): void;
+    /**
+     * Stop the timer. The callback will not be called until `runOnce` is called
+     * again.
+     */
+    stop(): void;
+    /**
+     * Reset the delay time to its initial value. If the timer is still running,
+     * retroactively apply that reset to the current timer.
+     */
+    reset(): void;
+    /**
+     * Check whether the timer is currently running.
+     */
+    isRunning(): boolean;
+    /**
+     * Set that while the timer is running, it should keep the Node process
+     * running.
+     */
+    ref(): void;
+    /**
+     * Set that while the timer is running, it should not keep the Node process
+     * running.
+     */
+    unref(): void;
+    /**
+     * Get the approximate timestamp of when the timer will fire. Only valid if
+     * this.isRunning() is true.
+     */
+    getEndTime(): Date;
+}

node_modules/@grpc/grpc-js/build/src/backoff-timeout.js

@@ -0,0 +1,174 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackoffTimeout = void 0;
+const INITIAL_BACKOFF_MS = 1000;
+const BACKOFF_MULTIPLIER = 1.6;
+const MAX_BACKOFF_MS = 120000;
+const BACKOFF_JITTER = 0.2;
+/**
+ * Get a number uniformly at random in the range [min, max)
+ * @param min
+ * @param max
+ */
+function uniformRandom(min, max) {
+    return Math.random() * (max - min) + min;
+}
+class BackoffTimeout {
+    constructor(callback, options) {
+        this.callback = callback;
+        /**
+         * The delay time at the start, and after each reset.
+         */
+        this.initialDelay = INITIAL_BACKOFF_MS;
+        /**
+         * The exponential backoff multiplier.
+         */
+        this.multiplier = BACKOFF_MULTIPLIER;
+        /**
+         * The maximum delay time
+         */
+        this.maxDelay = MAX_BACKOFF_MS;
+        /**
+         * The maximum fraction by which the delay time can randomly vary after
+         * applying the multiplier.
+         */
+        this.jitter = BACKOFF_JITTER;
+        /**
+         * Indicates whether the timer is currently running.
+         */
+        this.running = false;
+        /**
+         * Indicates whether the timer should keep the Node process running if no
+         * other async operation is doing so.
+         */
+        this.hasRef = true;
+        /**
+         * The time that the currently running timer was started. Only valid if
+         * running is true.
+         */
+        this.startTime = new Date();
+        /**
+         * The approximate time that the currently running timer will end. Only valid
+         * if running is true.
+         */
+        this.endTime = new Date();
+        if (options) {
+            if (options.initialDelay) {
+                this.initialDelay = options.initialDelay;
+            }
+            if (options.multiplier) {
+                this.multiplier = options.multiplier;
+            }
+            if (options.jitter) {
+                this.jitter = options.jitter;
+            }
+            if (options.maxDelay) {
+                this.maxDelay = options.maxDelay;
+            }
+        }
+        this.nextDelay = this.initialDelay;
+        this.timerId = setTimeout(() => { }, 0);
+        clearTimeout(this.timerId);
+    }
+    runTimer(delay) {
+        var _a, _b;
+        this.endTime = this.startTime;
+        this.endTime.setMilliseconds(this.endTime.getMilliseconds() + this.nextDelay);
+        clearTimeout(this.timerId);
+        this.timerId = setTimeout(() => {
+            this.callback();
+            this.running = false;
+        }, delay);
+        if (!this.hasRef) {
+            (_b = (_a = this.timerId).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        }
+    }
+    /**
+     * Call the callback after the current amount of delay time
+     */
+    runOnce() {
+        this.running = true;
+        this.startTime = new Date();
+        this.runTimer(this.nextDelay);
+        const nextBackoff = Math.min(this.nextDelay * this.multiplier, this.maxDelay);
+        const jitterMagnitude = nextBackoff * this.jitter;
+        this.nextDelay =
+            nextBackoff + uniformRandom(-jitterMagnitude, jitterMagnitude);
+    }
+    /**
+     * Stop the timer. The callback will not be called until `runOnce` is called
+     * again.
+     */
+    stop() {
+        clearTimeout(this.timerId);
+        this.running = false;
+    }
+    /**
+     * Reset the delay time to its initial value. If the timer is still running,
+     * retroactively apply that reset to the current timer.
+     */
+    reset() {
+        this.nextDelay = this.initialDelay;
+        if (this.running) {
+            const now = new Date();
+            const newEndTime = this.startTime;
+            newEndTime.setMilliseconds(newEndTime.getMilliseconds() + this.nextDelay);
+            clearTimeout(this.timerId);
+            if (now < newEndTime) {
+                this.runTimer(newEndTime.getTime() - now.getTime());
+            }
+            else {
+                this.running = false;
+            }
+        }
+    }
+    /**
+     * Check whether the timer is currently running.
+     */
+    isRunning() {
+        return this.running;
+    }
+    /**
+     * Set that while the timer is running, it should keep the Node process
+     * running.
+     */
+    ref() {
+        var _a, _b;
+        this.hasRef = true;
+        (_b = (_a = this.timerId).ref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /**
+     * Set that while the timer is running, it should not keep the Node process
+     * running.
+     */
+    unref() {
+        var _a, _b;
+        this.hasRef = false;
+        (_b = (_a = this.timerId).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /**
+     * Get the approximate timestamp of when the timer will fire. Only valid if
+     * this.isRunning() is true.
+     */
+    getEndTime() {
+        return this.endTime;
+    }
+}
+exports.BackoffTimeout = BackoffTimeout;
+//# sourceMappingURL=backoff-timeout.js.map

node_modules/@grpc/grpc-js/build/src/backoff-timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff-timeout.js","sourceRoot":"","sources":["../../src/backoff-timeout.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,MAAM,kBAAkB,GAAG,IAAI,CAAC;AAChC,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAC/B,MAAM,cAAc,GAAG,MAAM,CAAC;AAC9B,MAAM,cAAc,GAAG,GAAG,CAAC;AAE3B;;;;GAIG;AACH,SAAS,aAAa,CAAC,GAAW,EAAE,GAAW;IAC7C,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AAC3C,CAAC;AASD,MAAa,cAAc;IAgDzB,YAAoB,QAAoB,EAAE,OAAwB;QAA9C,aAAQ,GAAR,QAAQ,CAAY;QA/CxC;;WAEG;QACc,iBAAY,GAAW,kBAAkB,CAAC;QAC3D;;WAEG;QACc,eAAU,GAAW,kBAAkB,CAAC;QACzD;;WAEG;QACc,aAAQ,GAAW,cAAc,CAAC;QACnD;;;WAGG;QACc,WAAM,GAAW,cAAc,CAAC;QAWjD;;WAEG;QACK,YAAO,GAAG,KAAK,CAAC;QACxB;;;WAGG;QACK,WAAM,GAAG,IAAI,CAAC;QACtB;;;WAGG;QACK,cAAS,GAAS,IAAI,IAAI,EAAE,CAAC;QACrC;;;WAGG;QACK,YAAO,GAAS,IAAI,IAAI,EAAE,CAAC;QAGjC,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;gBACzB,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;YAC3C,CAAC;YACD,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;gBACvB,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;YACvC,CAAC;YACD,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;gBACnB,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;YAC/B,CAAC;YACD,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACrB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;YACnC,CAAC;QACH,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC;QACnC,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,GAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACvC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAEO,QAAQ,CAAC,KAAa;;QAC5B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC;QAC9B,IAAI,CAAC,OAAO,CAAC,eAAe,CAC1B,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,GAAG,IAAI,CAAC,SAAS,CAChD,CAAC;QACF,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;YAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,CAAC,EAAE,KAAK,CAAC,CAAC;QACV,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAA,MAAA,IAAI,CAAC,OAAO,EAAC,KAAK,kDAAI,CAAC;QACzB,CAAC;IACH,CAAC;IAED;;OAEG;IACH,OAAO;QACL,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;QAC5B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC9B,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAC1B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,UAAU,EAChC,IAAI,CAAC,QAAQ,CACd,CAAC;QACF,MAAM,eAAe,GAAG,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC;QAClD,IAAI,CAAC,SAAS;YACZ,WAAW,GAAG,aAAa,CAAC,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;IACnE,CAAC;IAED;;;OAGG;IACH,IAAI;QACF,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC;QACnC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC;YAClC,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,eAAe,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;YAC1E,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC3B,IAAI,GAAG,GAAG,UAAU,EAAE,CAAC;gBACrB,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YACtD,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,GAAG;;QACD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,MAAA,MAAA,IAAI,CAAC,OAAO,EAAC,GAAG,kDAAI,CAAC;IACvB,CAAC;IAED;;;OAGG;IACH,KAAK;;QACH,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,MAAA,MAAA,IAAI,CAAC,OAAO,EAAC,KAAK,kDAAI,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,UAAU;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF;AA/JD,wCA+JC"}

node_modules/@grpc/grpc-js/build/src/call-credentials.d.ts

@@ -0,0 +1,56 @@
+import { Metadata } from './metadata';
+export interface CallMetadataOptions {
+    service_url: string;
+}
+export type CallMetadataGenerator = (options: CallMetadataOptions, cb: (err: Error | null, metadata?: Metadata) => void) => void;
+export interface OldOAuth2Client {
+    getRequestMetadata: (url: string, callback: (err: Error | null, headers?: {
+        [index: string]: string;
+    }) => void) => void;
+}
+export interface CurrentOAuth2Client {
+    getRequestHeaders: (url?: string) => Promise<{
+        [index: string]: string;
+    }>;
+}
+export type OAuth2Client = OldOAuth2Client | CurrentOAuth2Client;
+/**
+ * A class that represents a generic method of adding authentication-related
+ * metadata on a per-request basis.
+ */
+export declare abstract class CallCredentials {
+    /**
+     * Asynchronously generates a new Metadata object.
+     * @param options Options used in generating the Metadata object.
+     */
+    abstract generateMetadata(options: CallMetadataOptions): Promise<Metadata>;
+    /**
+     * Creates a new CallCredentials object from properties of both this and
+     * another CallCredentials object. This object's metadata generator will be
+     * called first.
+     * @param callCredentials The other CallCredentials object.
+     */
+    abstract compose(callCredentials: CallCredentials): CallCredentials;
+    /**
+     * Check whether two call credentials objects are equal. Separate
+     * SingleCallCredentials with identical metadata generator functions are
+     * equal.
+     * @param other The other CallCredentials object to compare with.
+     */
+    abstract _equals(other: CallCredentials): boolean;
+    /**
+     * Creates a new CallCredentials object from a given function that generates
+     * Metadata objects.
+     * @param metadataGenerator A function that accepts a set of options, and
+     * generates a Metadata object based on these options, which is passed back
+     * to the caller via a supplied (err, metadata) callback.
+     */
+    static createFromMetadataGenerator(metadataGenerator: CallMetadataGenerator): CallCredentials;
+    /**
+     * Create a gRPC credential from a Google credential object.
+     * @param googleCredentials The authentication client to use.
+     * @return The resulting CallCredentials object.
+     */
+    static createFromGoogleCredential(googleCredentials: OAuth2Client): CallCredentials;
+    static createEmpty(): CallCredentials;
+}

node_modules/@grpc/grpc-js/build/src/call-credentials.js

@@ -0,0 +1,153 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallCredentials = void 0;
+const metadata_1 = require("./metadata");
+function isCurrentOauth2Client(client) {
+    return ('getRequestHeaders' in client &&
+        typeof client.getRequestHeaders === 'function');
+}
+/**
+ * A class that represents a generic method of adding authentication-related
+ * metadata on a per-request basis.
+ */
+class CallCredentials {
+    /**
+     * Creates a new CallCredentials object from a given function that generates
+     * Metadata objects.
+     * @param metadataGenerator A function that accepts a set of options, and
+     * generates a Metadata object based on these options, which is passed back
+     * to the caller via a supplied (err, metadata) callback.
+     */
+    static createFromMetadataGenerator(metadataGenerator) {
+        return new SingleCallCredentials(metadataGenerator);
+    }
+    /**
+     * Create a gRPC credential from a Google credential object.
+     * @param googleCredentials The authentication client to use.
+     * @return The resulting CallCredentials object.
+     */
+    static createFromGoogleCredential(googleCredentials) {
+        return CallCredentials.createFromMetadataGenerator((options, callback) => {
+            let getHeaders;
+            if (isCurrentOauth2Client(googleCredentials)) {
+                getHeaders = googleCredentials.getRequestHeaders(options.service_url);
+            }
+            else {
+                getHeaders = new Promise((resolve, reject) => {
+                    googleCredentials.getRequestMetadata(options.service_url, (err, headers) => {
+                        if (err) {
+                            reject(err);
+                            return;
+                        }
+                        if (!headers) {
+                            reject(new Error('Headers not set by metadata plugin'));
+                            return;
+                        }
+                        resolve(headers);
+                    });
+                });
+            }
+            getHeaders.then(headers => {
+                const metadata = new metadata_1.Metadata();
+                for (const key of Object.keys(headers)) {
+                    metadata.add(key, headers[key]);
+                }
+                callback(null, metadata);
+            }, err => {
+                callback(err);
+            });
+        });
+    }
+    static createEmpty() {
+        return new EmptyCallCredentials();
+    }
+}
+exports.CallCredentials = CallCredentials;
+class ComposedCallCredentials extends CallCredentials {
+    constructor(creds) {
+        super();
+        this.creds = creds;
+    }
+    async generateMetadata(options) {
+        const base = new metadata_1.Metadata();
+        const generated = await Promise.all(this.creds.map(cred => cred.generateMetadata(options)));
+        for (const gen of generated) {
+            base.merge(gen);
+        }
+        return base;
+    }
+    compose(other) {
+        return new ComposedCallCredentials(this.creds.concat([other]));
+    }
+    _equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (other instanceof ComposedCallCredentials) {
+            return this.creds.every((value, index) => value._equals(other.creds[index]));
+        }
+        else {
+            return false;
+        }
+    }
+}
+class SingleCallCredentials extends CallCredentials {
+    constructor(metadataGenerator) {
+        super();
+        this.metadataGenerator = metadataGenerator;
+    }
+    generateMetadata(options) {
+        return new Promise((resolve, reject) => {
+            this.metadataGenerator(options, (err, metadata) => {
+                if (metadata !== undefined) {
+                    resolve(metadata);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    compose(other) {
+        return new ComposedCallCredentials([this, other]);
+    }
+    _equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (other instanceof SingleCallCredentials) {
+            return this.metadataGenerator === other.metadataGenerator;
+        }
+        else {
+            return false;
+        }
+    }
+}
+class EmptyCallCredentials extends CallCredentials {
+    generateMetadata(options) {
+        return Promise.resolve(new metadata_1.Metadata());
+    }
+    compose(other) {
+        return other;
+    }
+    _equals(other) {
+        return other instanceof EmptyCallCredentials;
+    }
+}
+//# sourceMappingURL=call-credentials.js.map

node_modules/@grpc/grpc-js/build/src/call-credentials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-credentials.js","sourceRoot":"","sources":["../../src/call-credentials.ts"],"names":[],"mappings":"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"}

node_modules/@grpc/grpc-js/build/src/call-interface.d.ts

@@ -0,0 +1,89 @@
+/// <reference types="node" />
+import { CallCredentials } from './call-credentials';
+import { Status } from './constants';
+import { Deadline } from './deadline';
+import { Metadata } from './metadata';
+import { ServerSurfaceCall } from './server-call';
+export interface CallStreamOptions {
+    deadline: Deadline;
+    flags: number;
+    host: string;
+    parentCall: ServerSurfaceCall | null;
+}
+export type PartialCallStreamOptions = Partial<CallStreamOptions>;
+export interface StatusObject {
+    code: Status;
+    details: string;
+    metadata: Metadata;
+}
+export type PartialStatusObject = Pick<StatusObject, 'code' | 'details'> & {
+    metadata?: Metadata | null | undefined;
+};
+export declare const enum WriteFlags {
+    BufferHint = 1,
+    NoCompress = 2,
+    WriteThrough = 4
+}
+export interface WriteObject {
+    message: Buffer;
+    flags?: number;
+}
+export interface MetadataListener {
+    (metadata: Metadata, next: (metadata: Metadata) => void): void;
+}
+export interface MessageListener {
+    (message: any, next: (message: any) => void): void;
+}
+export interface StatusListener {
+    (status: StatusObject, next: (status: StatusObject) => void): void;
+}
+export interface FullListener {
+    onReceiveMetadata: MetadataListener;
+    onReceiveMessage: MessageListener;
+    onReceiveStatus: StatusListener;
+}
+export type Listener = Partial<FullListener>;
+/**
+ * An object with methods for handling the responses to a call.
+ */
+export interface InterceptingListener {
+    onReceiveMetadata(metadata: Metadata): void;
+    onReceiveMessage(message: any): void;
+    onReceiveStatus(status: StatusObject): void;
+}
+export declare function isInterceptingListener(listener: Listener | InterceptingListener): listener is InterceptingListener;
+export declare class InterceptingListenerImpl implements InterceptingListener {
+    private listener;
+    private nextListener;
+    private processingMetadata;
+    private hasPendingMessage;
+    private pendingMessage;
+    private processingMessage;
+    private pendingStatus;
+    constructor(listener: FullListener, nextListener: InterceptingListener);
+    private processPendingMessage;
+    private processPendingStatus;
+    onReceiveMetadata(metadata: Metadata): void;
+    onReceiveMessage(message: any): void;
+    onReceiveStatus(status: StatusObject): void;
+}
+export interface WriteCallback {
+    (error?: Error | null): void;
+}
+export interface MessageContext {
+    callback?: WriteCallback;
+    flags?: number;
+}
+export interface Call {
+    cancelWithStatus(status: Status, details: string): void;
+    getPeer(): string;
+    start(metadata: Metadata, listener: InterceptingListener): void;
+    sendMessageWithContext(context: MessageContext, message: Buffer): void;
+    startRead(): void;
+    halfClose(): void;
+    getCallNumber(): number;
+    setCredentials(credentials: CallCredentials): void;
+}
+export interface DeadlineInfoProvider {
+    getDeadlineInfo(): string[];
+}

node_modules/@grpc/grpc-js/build/src/call-interface.js

@@ -0,0 +1,84 @@
+"use strict";
+/*
+ * Copyright 2022 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterceptingListenerImpl = exports.isInterceptingListener = void 0;
+function isInterceptingListener(listener) {
+    return (listener.onReceiveMetadata !== undefined &&
+        listener.onReceiveMetadata.length === 1);
+}
+exports.isInterceptingListener = isInterceptingListener;
+class InterceptingListenerImpl {
+    constructor(listener, nextListener) {
+        this.listener = listener;
+        this.nextListener = nextListener;
+        this.processingMetadata = false;
+        this.hasPendingMessage = false;
+        this.processingMessage = false;
+        this.pendingStatus = null;
+    }
+    processPendingMessage() {
+        if (this.hasPendingMessage) {
+            this.nextListener.onReceiveMessage(this.pendingMessage);
+            this.pendingMessage = null;
+            this.hasPendingMessage = false;
+        }
+    }
+    processPendingStatus() {
+        if (this.pendingStatus) {
+            this.nextListener.onReceiveStatus(this.pendingStatus);
+        }
+    }
+    onReceiveMetadata(metadata) {
+        this.processingMetadata = true;
+        this.listener.onReceiveMetadata(metadata, metadata => {
+            this.processingMetadata = false;
+            this.nextListener.onReceiveMetadata(metadata);
+            this.processPendingMessage();
+            this.processPendingStatus();
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    onReceiveMessage(message) {
+        /* If this listener processes messages asynchronously, the last message may
+         * be reordered with respect to the status */
+        this.processingMessage = true;
+        this.listener.onReceiveMessage(message, msg => {
+            this.processingMessage = false;
+            if (this.processingMetadata) {
+                this.pendingMessage = msg;
+                this.hasPendingMessage = true;
+            }
+            else {
+                this.nextListener.onReceiveMessage(msg);
+                this.processPendingStatus();
+            }
+        });
+    }
+    onReceiveStatus(status) {
+        this.listener.onReceiveStatus(status, processedStatus => {
+            if (this.processingMetadata || this.processingMessage) {
+                this.pendingStatus = processedStatus;
+            }
+            else {
+                this.nextListener.onReceiveStatus(processedStatus);
+            }
+        });
+    }
+}
+exports.InterceptingListenerImpl = InterceptingListenerImpl;
+//# sourceMappingURL=call-interface.js.map

node_modules/@grpc/grpc-js/build/src/call-interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-interface.js","sourceRoot":"","sources":["../../src/call-interface.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAqEH,SAAgB,sBAAsB,CACpC,QAAyC;IAEzC,OAAO,CACL,QAAQ,CAAC,iBAAiB,KAAK,SAAS;QACxC,QAAQ,CAAC,iBAAiB,CAAC,MAAM,KAAK,CAAC,CACxC,CAAC;AACJ,CAAC;AAPD,wDAOC;AAED,MAAa,wBAAwB;IAMnC,YACU,QAAsB,EACtB,YAAkC;QADlC,aAAQ,GAAR,QAAQ,CAAc;QACtB,iBAAY,GAAZ,YAAY,CAAsB;QAPpC,uBAAkB,GAAG,KAAK,CAAC;QAC3B,sBAAiB,GAAG,KAAK,CAAC;QAE1B,sBAAiB,GAAG,KAAK,CAAC;QAC1B,kBAAa,GAAwB,IAAI,CAAC;IAI/C,CAAC;IAEI,qBAAqB;QAC3B,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACxD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;QACjC,CAAC;IACH,CAAC;IAEO,oBAAoB;QAC1B,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED,iBAAiB,CAAC,QAAkB;QAClC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC/B,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE;YACnD,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;YAChC,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;YAC9C,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC7B,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC9B,CAAC,CAAC,CAAC;IACL,CAAC;IACD,8DAA8D;IAC9D,gBAAgB,CAAC,OAAY;QAC3B;qDAC6C;QAC7C,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC9B,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE;YAC5C,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;YAC/B,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC5B,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC;gBAC1B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;YAChC,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;gBACxC,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC9B,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACD,eAAe,CAAC,MAAoB;QAClC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,MAAM,EAAE,eAAe,CAAC,EAAE;YACtD,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACtD,IAAI,CAAC,aAAa,GAAG,eAAe,CAAC;YACvC,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC;YACrD,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AA3DD,4DA2DC"}

node_modules/@grpc/grpc-js/build/src/call-number.d.ts

@@ -0,0 +1 @@
+export declare function getNextCallNumber(): number;

node_modules/@grpc/grpc-js/build/src/call-number.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Copyright 2022 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextCallNumber = void 0;
+let nextCallNumber = 0;
+function getNextCallNumber() {
+    return nextCallNumber++;
+}
+exports.getNextCallNumber = getNextCallNumber;
+//# sourceMappingURL=call-number.js.map

node_modules/@grpc/grpc-js/build/src/call-number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-number.js","sourceRoot":"","sources":["../../src/call-number.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,IAAI,cAAc,GAAG,CAAC,CAAC;AAEvB,SAAgB,iBAAiB;IAC/B,OAAO,cAAc,EAAE,CAAC;AAC1B,CAAC;AAFD,8CAEC"}

node_modules/@grpc/grpc-js/build/src/call.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Duplex, Readable, Writable } from 'stream';
+import { StatusObject } from './call-interface';
+import { EmitterAugmentation1 } from './events';
+import { Metadata } from './metadata';
+import { ObjectReadable, ObjectWritable, WriteCallback } from './object-stream';
+import { InterceptingCallInterface } from './client-interceptors';
+/**
+ * A type extending the built-in Error object with additional fields.
+ */
+export type ServiceError = StatusObject & Error;
+/**
+ * A base type for all user-facing values returned by client-side method calls.
+ */
+export type SurfaceCall = {
+    call?: InterceptingCallInterface;
+    cancel(): void;
+    getPeer(): string;
+} & EmitterAugmentation1<'metadata', Metadata> & EmitterAugmentation1<'status', StatusObject> & EventEmitter;
+/**
+ * A type representing the return value of a unary method call.
+ */
+export type ClientUnaryCall = SurfaceCall;
+/**
+ * A type representing the return value of a server stream method call.
+ */
+export type ClientReadableStream<ResponseType> = {
+    deserialize: (chunk: Buffer) => ResponseType;
+} & SurfaceCall & ObjectReadable<ResponseType>;
+/**
+ * A type representing the return value of a client stream method call.
+ */
+export type ClientWritableStream<RequestType> = {
+    serialize: (value: RequestType) => Buffer;
+} & SurfaceCall & ObjectWritable<RequestType>;
+/**
+ * A type representing the return value of a bidirectional stream method call.
+ */
+export type ClientDuplexStream<RequestType, ResponseType> = ClientWritableStream<RequestType> & ClientReadableStream<ResponseType>;
+/**
+ * Construct a ServiceError from a StatusObject. This function exists primarily
+ * as an attempt to make the error stack trace clearly communicate that the
+ * error is not necessarily a problem in gRPC itself.
+ * @param status
+ */
+export declare function callErrorFromStatus(status: StatusObject, callerStack: string): ServiceError;
+export declare class ClientUnaryCallImpl extends EventEmitter implements ClientUnaryCall {
+    call?: InterceptingCallInterface;
+    constructor();
+    cancel(): void;
+    getPeer(): string;
+}
+export declare class ClientReadableStreamImpl<ResponseType> extends Readable implements ClientReadableStream<ResponseType> {
+    readonly deserialize: (chunk: Buffer) => ResponseType;
+    call?: InterceptingCallInterface;
+    constructor(deserialize: (chunk: Buffer) => ResponseType);
+    cancel(): void;
+    getPeer(): string;
+    _read(_size: number): void;
+}
+export declare class ClientWritableStreamImpl<RequestType> extends Writable implements ClientWritableStream<RequestType> {
+    readonly serialize: (value: RequestType) => Buffer;
+    call?: InterceptingCallInterface;
+    constructor(serialize: (value: RequestType) => Buffer);
+    cancel(): void;
+    getPeer(): string;
+    _write(chunk: RequestType, encoding: string, cb: WriteCallback): void;
+    _final(cb: Function): void;
+}
+export declare class ClientDuplexStreamImpl<RequestType, ResponseType> extends Duplex implements ClientDuplexStream<RequestType, ResponseType> {
+    readonly serialize: (value: RequestType) => Buffer;
+    readonly deserialize: (chunk: Buffer) => ResponseType;
+    call?: InterceptingCallInterface;
+    constructor(serialize: (value: RequestType) => Buffer, deserialize: (chunk: Buffer) => ResponseType);
+    cancel(): void;
+    getPeer(): string;
+    _read(_size: number): void;
+    _write(chunk: RequestType, encoding: string, cb: WriteCallback): void;
+    _final(cb: Function): void;
+}

node_modules/@grpc/grpc-js/build/src/call.js

@@ -0,0 +1,136 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientDuplexStreamImpl = exports.ClientWritableStreamImpl = exports.ClientReadableStreamImpl = exports.ClientUnaryCallImpl = exports.callErrorFromStatus = void 0;
+const events_1 = require("events");
+const stream_1 = require("stream");
+const constants_1 = require("./constants");
+/**
+ * Construct a ServiceError from a StatusObject. This function exists primarily
+ * as an attempt to make the error stack trace clearly communicate that the
+ * error is not necessarily a problem in gRPC itself.
+ * @param status
+ */
+function callErrorFromStatus(status, callerStack) {
+    const message = `${status.code} ${constants_1.Status[status.code]}: ${status.details}`;
+    const error = new Error(message);
+    const stack = `${error.stack}\nfor call at\n${callerStack}`;
+    return Object.assign(new Error(message), status, { stack });
+}
+exports.callErrorFromStatus = callErrorFromStatus;
+class ClientUnaryCallImpl extends events_1.EventEmitter {
+    constructor() {
+        super();
+    }
+    cancel() {
+        var _a;
+        (_a = this.call) === null || _a === void 0 ? void 0 : _a.cancelWithStatus(constants_1.Status.CANCELLED, 'Cancelled on client');
+    }
+    getPeer() {
+        var _a, _b;
+        return (_b = (_a = this.call) === null || _a === void 0 ? void 0 : _a.getPeer()) !== null && _b !== void 0 ? _b : 'unknown';
+    }
+}
+exports.ClientUnaryCallImpl = ClientUnaryCallImpl;
+class ClientReadableStreamImpl extends stream_1.Readable {
+    constructor(deserialize) {
+        super({ objectMode: true });
+        this.deserialize = deserialize;
+    }
+    cancel() {
+        var _a;
+        (_a = this.call) === null || _a === void 0 ? void 0 : _a.cancelWithStatus(constants_1.Status.CANCELLED, 'Cancelled on client');
+    }
+    getPeer() {
+        var _a, _b;
+        return (_b = (_a = this.call) === null || _a === void 0 ? void 0 : _a.getPeer()) !== null && _b !== void 0 ? _b : 'unknown';
+    }
+    _read(_size) {
+        var _a;
+        (_a = this.call) === null || _a === void 0 ? void 0 : _a.startRead();
+    }
+}
+exports.ClientReadableStreamImpl = ClientReadableStreamImpl;
+class ClientWritableStreamImpl extends stream_1.Writable {
+    constructor(serialize) {
+        super({ objectMode: true });
+        this.serialize = serialize;
+    }
+    cancel() {
+        var _a;
+        (_a = this.call) === null || _a === void 0 ? void 0 : _a.cancelWithStatus(constants_1.Status.CANCELLED, 'Cancelled on client');
+    }
+    getPeer() {
+        var _a, _b;
+        return (_b = (_a = this.call) === null || _a === void 0 ? void 0 : _a.getPeer()) !== null && _b !== void 0 ? _b : 'unknown';
+    }
+    _write(chunk, encoding, cb) {
+        var _a;
+        const context = {
+            callback: cb,
+        };
+        const flags = Number(encoding);
+        if (!Number.isNaN(flags)) {
+            context.flags = flags;
+        }
+        (_a = this.call) === null || _a === void 0 ? void 0 : _a.sendMessageWithContext(context, chunk);
+    }
+    _final(cb) {
+        var _a;
+        (_a = this.call) === null || _a === void 0 ? void 0 : _a.halfClose();
+        cb();
+    }
+}
+exports.ClientWritableStreamImpl = ClientWritableStreamImpl;
+class ClientDuplexStreamImpl extends stream_1.Duplex {
+    constructor(serialize, deserialize) {
+        super({ objectMode: true });
+        this.serialize = serialize;
+        this.deserialize = deserialize;
+    }
+    cancel() {
+        var _a;
+        (_a = this.call) === null || _a === void 0 ? void 0 : _a.cancelWithStatus(constants_1.Status.CANCELLED, 'Cancelled on client');
+    }
+    getPeer() {
+        var _a, _b;
+        return (_b = (_a = this.call) === null || _a === void 0 ? void 0 : _a.getPeer()) !== null && _b !== void 0 ? _b : 'unknown';
+    }
+    _read(_size) {
+        var _a;
+        (_a = this.call) === null || _a === void 0 ? void 0 : _a.startRead();
+    }
+    _write(chunk, encoding, cb) {
+        var _a;
+        const context = {
+            callback: cb,
+        };
+        const flags = Number(encoding);
+        if (!Number.isNaN(flags)) {
+            context.flags = flags;
+        }
+        (_a = this.call) === null || _a === void 0 ? void 0 : _a.sendMessageWithContext(context, chunk);
+    }
+    _final(cb) {
+        var _a;
+        (_a = this.call) === null || _a === void 0 ? void 0 : _a.halfClose();
+        cb();
+    }
+}
+exports.ClientDuplexStreamImpl = ClientDuplexStreamImpl;
+//# sourceMappingURL=call.js.map

node_modules/@grpc/grpc-js/build/src/call.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call.js","sourceRoot":"","sources":["../../src/call.ts"],"names":[],"mappings":"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"}

node_modules/@grpc/grpc-js/build/src/channel-credentials.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ConnectionOptions, PeerCertificate, SecureContext } from 'tls';
+import { CallCredentials } from './call-credentials';
+/**
+ * A callback that will receive the expected hostname and presented peer
+ * certificate as parameters. The callback should return an error to
+ * indicate that the presented certificate is considered invalid and
+ * otherwise returned undefined.
+ */
+export type CheckServerIdentityCallback = (hostname: string, cert: PeerCertificate) => Error | undefined;
+/**
+ * Additional peer verification options that can be set when creating
+ * SSL credentials.
+ */
+export interface VerifyOptions {
+    /**
+     * If set, this callback will be invoked after the usual hostname verification
+     * has been performed on the peer certificate.
+     */
+    checkServerIdentity?: CheckServerIdentityCallback;
+}
+/**
+ * A class that contains credentials for communicating over a channel, as well
+ * as a set of per-call credentials, which are applied to every method call made
+ * over a channel initialized with an instance of this class.
+ */
+export declare abstract class ChannelCredentials {
+    protected callCredentials: CallCredentials;
+    protected constructor(callCredentials?: CallCredentials);
+    /**
+     * Returns a copy of this object with the included set of per-call credentials
+     * expanded to include callCredentials.
+     * @param callCredentials A CallCredentials object to associate with this
+     * instance.
+     */
+    abstract compose(callCredentials: CallCredentials): ChannelCredentials;
+    /**
+     * Gets the set of per-call credentials associated with this instance.
+     */
+    _getCallCredentials(): CallCredentials;
+    /**
+     * Gets a SecureContext object generated from input parameters if this
+     * instance was created with createSsl, or null if this instance was created
+     * with createInsecure.
+     */
+    abstract _getConnectionOptions(): ConnectionOptions | null;
+    /**
+     * Indicates whether this credentials object creates a secure channel.
+     */
+    abstract _isSecure(): boolean;
+    /**
+     * Check whether two channel credentials objects are equal. Two secure
+     * credentials are equal if they were constructed with the same parameters.
+     * @param other The other ChannelCredentials Object
+     */
+    abstract _equals(other: ChannelCredentials): boolean;
+    /**
+     * Return a new ChannelCredentials instance with a given set of credentials.
+     * The resulting instance can be used to construct a Channel that communicates
+     * over TLS.
+     * @param rootCerts The root certificate data.
+     * @param privateKey The client certificate private key, if available.
+     * @param certChain The client certificate key chain, if available.
+     * @param verifyOptions Additional options to modify certificate verification
+     */
+    static createSsl(rootCerts?: Buffer | null, privateKey?: Buffer | null, certChain?: Buffer | null, verifyOptions?: VerifyOptions): ChannelCredentials;
+    /**
+     * Return a new ChannelCredentials instance with credentials created using
+     * the provided secureContext. The resulting instances can be used to
+     * construct a Channel that communicates over TLS. gRPC will not override
+     * anything in the provided secureContext, so the environment variables
+     * GRPC_SSL_CIPHER_SUITES and GRPC_DEFAULT_SSL_ROOTS_FILE_PATH will
+     * not be applied.
+     * @param secureContext The return value of tls.createSecureContext()
+     * @param verifyOptions Additional options to modify certificate verification
+     */
+    static createFromSecureContext(secureContext: SecureContext, verifyOptions?: VerifyOptions): ChannelCredentials;
+    /**
+     * Return a new ChannelCredentials instance with no credentials.
+     */
+    static createInsecure(): ChannelCredentials;
+}

node_modules/@grpc/grpc-js/build/src/channel-credentials.js

@@ -0,0 +1,177 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelCredentials = void 0;
+const tls_1 = require("tls");
+const call_credentials_1 = require("./call-credentials");
+const tls_helpers_1 = require("./tls-helpers");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function verifyIsBufferOrNull(obj, friendlyName) {
+    if (obj && !(obj instanceof Buffer)) {
+        throw new TypeError(`${friendlyName}, if provided, must be a Buffer.`);
+    }
+}
+/**
+ * A class that contains credentials for communicating over a channel, as well
+ * as a set of per-call credentials, which are applied to every method call made
+ * over a channel initialized with an instance of this class.
+ */
+class ChannelCredentials {
+    constructor(callCredentials) {
+        this.callCredentials = callCredentials || call_credentials_1.CallCredentials.createEmpty();
+    }
+    /**
+     * Gets the set of per-call credentials associated with this instance.
+     */
+    _getCallCredentials() {
+        return this.callCredentials;
+    }
+    /**
+     * Return a new ChannelCredentials instance with a given set of credentials.
+     * The resulting instance can be used to construct a Channel that communicates
+     * over TLS.
+     * @param rootCerts The root certificate data.
+     * @param privateKey The client certificate private key, if available.
+     * @param certChain The client certificate key chain, if available.
+     * @param verifyOptions Additional options to modify certificate verification
+     */
+    static createSsl(rootCerts, privateKey, certChain, verifyOptions) {
+        var _a;
+        verifyIsBufferOrNull(rootCerts, 'Root certificate');
+        verifyIsBufferOrNull(privateKey, 'Private key');
+        verifyIsBufferOrNull(certChain, 'Certificate chain');
+        if (privateKey && !certChain) {
+            throw new Error('Private key must be given with accompanying certificate chain');
+        }
+        if (!privateKey && certChain) {
+            throw new Error('Certificate chain must be given with accompanying private key');
+        }
+        const secureContext = (0, tls_1.createSecureContext)({
+            ca: (_a = rootCerts !== null && rootCerts !== void 0 ? rootCerts : (0, tls_helpers_1.getDefaultRootsData)()) !== null && _a !== void 0 ? _a : undefined,
+            key: privateKey !== null && privateKey !== void 0 ? privateKey : undefined,
+            cert: certChain !== null && certChain !== void 0 ? certChain : undefined,
+            ciphers: tls_helpers_1.CIPHER_SUITES,
+        });
+        return new SecureChannelCredentialsImpl(secureContext, verifyOptions !== null && verifyOptions !== void 0 ? verifyOptions : {});
+    }
+    /**
+     * Return a new ChannelCredentials instance with credentials created using
+     * the provided secureContext. The resulting instances can be used to
+     * construct a Channel that communicates over TLS. gRPC will not override
+     * anything in the provided secureContext, so the environment variables
+     * GRPC_SSL_CIPHER_SUITES and GRPC_DEFAULT_SSL_ROOTS_FILE_PATH will
+     * not be applied.
+     * @param secureContext The return value of tls.createSecureContext()
+     * @param verifyOptions Additional options to modify certificate verification
+     */
+    static createFromSecureContext(secureContext, verifyOptions) {
+        return new SecureChannelCredentialsImpl(secureContext, verifyOptions !== null && verifyOptions !== void 0 ? verifyOptions : {});
+    }
+    /**
+     * Return a new ChannelCredentials instance with no credentials.
+     */
+    static createInsecure() {
+        return new InsecureChannelCredentialsImpl();
+    }
+}
+exports.ChannelCredentials = ChannelCredentials;
+class InsecureChannelCredentialsImpl extends ChannelCredentials {
+    constructor() {
+        super();
+    }
+    compose(callCredentials) {
+        throw new Error('Cannot compose insecure credentials');
+    }
+    _getConnectionOptions() {
+        return null;
+    }
+    _isSecure() {
+        return false;
+    }
+    _equals(other) {
+        return other instanceof InsecureChannelCredentialsImpl;
+    }
+}
+class SecureChannelCredentialsImpl extends ChannelCredentials {
+    constructor(secureContext, verifyOptions) {
+        super();
+        this.secureContext = secureContext;
+        this.verifyOptions = verifyOptions;
+        this.connectionOptions = {
+            secureContext,
+        };
+        // Node asserts that this option is a function, so we cannot pass undefined
+        if (verifyOptions === null || verifyOptions === void 0 ? void 0 : verifyOptions.checkServerIdentity) {
+            this.connectionOptions.checkServerIdentity =
+                verifyOptions.checkServerIdentity;
+        }
+    }
+    compose(callCredentials) {
+        const combinedCallCredentials = this.callCredentials.compose(callCredentials);
+        return new ComposedChannelCredentialsImpl(this, combinedCallCredentials);
+    }
+    _getConnectionOptions() {
+        // Copy to prevent callers from mutating this.connectionOptions
+        return Object.assign({}, this.connectionOptions);
+    }
+    _isSecure() {
+        return true;
+    }
+    _equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (other instanceof SecureChannelCredentialsImpl) {
+            return (this.secureContext === other.secureContext &&
+                this.verifyOptions.checkServerIdentity ===
+                    other.verifyOptions.checkServerIdentity);
+        }
+        else {
+            return false;
+        }
+    }
+}
+class ComposedChannelCredentialsImpl extends ChannelCredentials {
+    constructor(channelCredentials, callCreds) {
+        super(callCreds);
+        this.channelCredentials = channelCredentials;
+    }
+    compose(callCredentials) {
+        const combinedCallCredentials = this.callCredentials.compose(callCredentials);
+        return new ComposedChannelCredentialsImpl(this.channelCredentials, combinedCallCredentials);
+    }
+    _getConnectionOptions() {
+        return this.channelCredentials._getConnectionOptions();
+    }
+    _isSecure() {
+        return true;
+    }
+    _equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (other instanceof ComposedChannelCredentialsImpl) {
+            return (this.channelCredentials._equals(other.channelCredentials) &&
+                this.callCredentials._equals(other.callCredentials));
+        }
+        else {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=channel-credentials.js.map

node_modules/@grpc/grpc-js/build/src/channel-credentials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-credentials.js","sourceRoot":"","sources":["../../src/channel-credentials.ts"],"names":[],"mappings":"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"}

node_modules/@grpc/grpc-js/build/src/channel-options.d.ts

@@ -0,0 +1,75 @@
+import { CompressionAlgorithms } from './compression-algorithms';
+/**
+ * An interface that contains options used when initializing a Channel instance.
+ */
+export interface ChannelOptions {
+    'grpc.ssl_target_name_override'?: string;
+    'grpc.primary_user_agent'?: string;
+    'grpc.secondary_user_agent'?: string;
+    'grpc.default_authority'?: string;
+    'grpc.keepalive_time_ms'?: number;
+    'grpc.keepalive_timeout_ms'?: number;
+    'grpc.keepalive_permit_without_calls'?: number;
+    'grpc.service_config'?: string;
+    'grpc.max_concurrent_streams'?: number;
+    'grpc.initial_reconnect_backoff_ms'?: number;
+    'grpc.max_reconnect_backoff_ms'?: number;
+    'grpc.use_local_subchannel_pool'?: number;
+    'grpc.max_send_message_length'?: number;
+    'grpc.max_receive_message_length'?: number;
+    'grpc.enable_http_proxy'?: number;
+    'grpc.http_connect_target'?: string;
+    'grpc.http_connect_creds'?: string;
+    'grpc.default_compression_algorithm'?: CompressionAlgorithms;
+    'grpc.enable_channelz'?: number;
+    'grpc.dns_min_time_between_resolutions_ms'?: number;
+    'grpc.enable_retries'?: number;
+    'grpc.per_rpc_retry_buffer_size'?: number;
+    'grpc.retry_buffer_size'?: number;
+    'grpc.max_connection_age_ms'?: number;
+    'grpc.max_connection_age_grace_ms'?: number;
+    'grpc.max_connection_idle_ms'?: number;
+    'grpc-node.max_session_memory'?: number;
+    'grpc.service_config_disable_resolution'?: number;
+    'grpc.client_idle_timeout_ms'?: number;
+    /**
+     * Set the enableTrace option in TLS clients and servers
+     */
+    'grpc-node.tls_enable_trace'?: number;
+    'grpc.lb.ring_hash.ring_size_cap'?: number;
+    [key: string]: any;
+}
+/**
+ * This is for checking provided options at runtime. This is an object for
+ * easier membership checking.
+ */
+export declare const recognizedOptions: {
+    'grpc.ssl_target_name_override': boolean;
+    'grpc.primary_user_agent': boolean;
+    'grpc.secondary_user_agent': boolean;
+    'grpc.default_authority': boolean;
+    'grpc.keepalive_time_ms': boolean;
+    'grpc.keepalive_timeout_ms': boolean;
+    'grpc.keepalive_permit_without_calls': boolean;
+    'grpc.service_config': boolean;
+    'grpc.max_concurrent_streams': boolean;
+    'grpc.initial_reconnect_backoff_ms': boolean;
+    'grpc.max_reconnect_backoff_ms': boolean;
+    'grpc.use_local_subchannel_pool': boolean;
+    'grpc.max_send_message_length': boolean;
+    'grpc.max_receive_message_length': boolean;
+    'grpc.enable_http_proxy': boolean;
+    'grpc.enable_channelz': boolean;
+    'grpc.dns_min_time_between_resolutions_ms': boolean;
+    'grpc.enable_retries': boolean;
+    'grpc.per_rpc_retry_buffer_size': boolean;
+    'grpc.retry_buffer_size': boolean;
+    'grpc.max_connection_age_ms': boolean;
+    'grpc.max_connection_age_grace_ms': boolean;
+    'grpc-node.max_session_memory': boolean;
+    'grpc.service_config_disable_resolution': boolean;
+    'grpc.client_idle_timeout_ms': boolean;
+    'grpc-node.tls_enable_trace': boolean;
+    'grpc.lb.ring_hash.ring_size_cap': boolean;
+};
+export declare function channelOptionsEqual(options1: ChannelOptions, options2: ChannelOptions): boolean;

node_modules/@grpc/grpc-js/build/src/channel-options.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelOptionsEqual = exports.recognizedOptions = void 0;
+/**
+ * This is for checking provided options at runtime. This is an object for
+ * easier membership checking.
+ */
+exports.recognizedOptions = {
+    'grpc.ssl_target_name_override': true,
+    'grpc.primary_user_agent': true,
+    'grpc.secondary_user_agent': true,
+    'grpc.default_authority': true,
+    'grpc.keepalive_time_ms': true,
+    'grpc.keepalive_timeout_ms': true,
+    'grpc.keepalive_permit_without_calls': true,
+    'grpc.service_config': true,
+    'grpc.max_concurrent_streams': true,
+    'grpc.initial_reconnect_backoff_ms': true,
+    'grpc.max_reconnect_backoff_ms': true,
+    'grpc.use_local_subchannel_pool': true,
+    'grpc.max_send_message_length': true,
+    'grpc.max_receive_message_length': true,
+    'grpc.enable_http_proxy': true,
+    'grpc.enable_channelz': true,
+    'grpc.dns_min_time_between_resolutions_ms': true,
+    'grpc.enable_retries': true,
+    'grpc.per_rpc_retry_buffer_size': true,
+    'grpc.retry_buffer_size': true,
+    'grpc.max_connection_age_ms': true,
+    'grpc.max_connection_age_grace_ms': true,
+    'grpc-node.max_session_memory': true,
+    'grpc.service_config_disable_resolution': true,
+    'grpc.client_idle_timeout_ms': true,
+    'grpc-node.tls_enable_trace': true,
+    'grpc.lb.ring_hash.ring_size_cap': true,
+};
+function channelOptionsEqual(options1, options2) {
+    const keys1 = Object.keys(options1).sort();
+    const keys2 = Object.keys(options2).sort();
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (let i = 0; i < keys1.length; i += 1) {
+        if (keys1[i] !== keys2[i]) {
+            return false;
+        }
+        if (options1[keys1[i]] !== options2[keys2[i]]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.channelOptionsEqual = channelOptionsEqual;
+//# sourceMappingURL=channel-options.js.map

node_modules/@grpc/grpc-js/build/src/channel-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-options.js","sourceRoot":"","sources":["../../src/channel-options.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAsDH;;;GAGG;AACU,QAAA,iBAAiB,GAAG;IAC/B,+BAA+B,EAAE,IAAI;IACrC,yBAAyB,EAAE,IAAI;IAC/B,2BAA2B,EAAE,IAAI;IACjC,wBAAwB,EAAE,IAAI;IAC9B,wBAAwB,EAAE,IAAI;IAC9B,2BAA2B,EAAE,IAAI;IACjC,qCAAqC,EAAE,IAAI;IAC3C,qBAAqB,EAAE,IAAI;IAC3B,6BAA6B,EAAE,IAAI;IACnC,mCAAmC,EAAE,IAAI;IACzC,+BAA+B,EAAE,IAAI;IACrC,gCAAgC,EAAE,IAAI;IACtC,8BAA8B,EAAE,IAAI;IACpC,iCAAiC,EAAE,IAAI;IACvC,wBAAwB,EAAE,IAAI;IAC9B,sBAAsB,EAAE,IAAI;IAC5B,0CAA0C,EAAE,IAAI;IAChD,qBAAqB,EAAE,IAAI;IAC3B,gCAAgC,EAAE,IAAI;IACtC,wBAAwB,EAAE,IAAI;IAC9B,4BAA4B,EAAE,IAAI;IAClC,kCAAkC,EAAE,IAAI;IACxC,8BAA8B,EAAE,IAAI;IACpC,wCAAwC,EAAE,IAAI;IAC9C,6BAA6B,EAAE,IAAI;IACnC,4BAA4B,EAAE,IAAI;IAClC,iCAAiC,EAAE,IAAI;CACxC,CAAC;AAEF,SAAgB,mBAAmB,CACjC,QAAwB,EACxB,QAAwB;IAExB,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3C,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3C,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;QAClC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACzC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1B,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9C,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAlBD,kDAkBC"}

node_modules/@grpc/grpc-js/build/src/channel.d.ts

@@ -0,0 +1,76 @@
+import { ChannelCredentials } from './channel-credentials';
+import { ChannelOptions } from './channel-options';
+import { ServerSurfaceCall } from './server-call';
+import { ConnectivityState } from './connectivity-state';
+import type { ChannelRef } from './channelz';
+import { Call } from './call-interface';
+import { Deadline } from './deadline';
+/**
+ * An interface that represents a communication channel to a server specified
+ * by a given address.
+ */
+export interface Channel {
+    /**
+     * Close the channel. This has the same functionality as the existing
+     * grpc.Client.prototype.close
+     */
+    close(): void;
+    /**
+     * Return the target that this channel connects to
+     */
+    getTarget(): string;
+    /**
+     * Get the channel's current connectivity state. This method is here mainly
+     * because it is in the existing internal Channel class, and there isn't
+     * another good place to put it.
+     * @param tryToConnect If true, the channel will start connecting if it is
+     *     idle. Otherwise, idle channels will only start connecting when a
+     *     call starts.
+     */
+    getConnectivityState(tryToConnect: boolean): ConnectivityState;
+    /**
+     * Watch for connectivity state changes. This is also here mainly because
+     * it is in the existing external Channel class.
+     * @param currentState The state to watch for transitions from. This should
+     *     always be populated by calling getConnectivityState immediately
+     *     before.
+     * @param deadline A deadline for waiting for a state change
+     * @param callback Called with no error when a state change, or with an
+     *     error if the deadline passes without a state change.
+     */
+    watchConnectivityState(currentState: ConnectivityState, deadline: Date | number, callback: (error?: Error) => void): void;
+    /**
+     * Get the channelz reference object for this channel. A request to the
+     * channelz service for the id in this object will provide information
+     * about this channel.
+     */
+    getChannelzRef(): ChannelRef;
+    /**
+     * Create a call object. Call is an opaque type that is used by the Client
+     * class. This function is called by the gRPC library when starting a
+     * request. Implementers should return an instance of Call that is returned
+     * from calling createCall on an instance of the provided Channel class.
+     * @param method The full method string to request.
+     * @param deadline The call deadline
+     * @param host A host string override for making the request
+     * @param parentCall A server call to propagate some information from
+     * @param propagateFlags A bitwise combination of elements of grpc.propagate
+     *     that indicates what information to propagate from parentCall.
+     */
+    createCall(method: string, deadline: Deadline, host: string | null | undefined, parentCall: ServerSurfaceCall | null, propagateFlags: number | null | undefined): Call;
+}
+export declare class ChannelImplementation implements Channel {
+    private internalChannel;
+    constructor(target: string, credentials: ChannelCredentials, options: ChannelOptions);
+    close(): void;
+    getTarget(): string;
+    getConnectivityState(tryToConnect: boolean): ConnectivityState;
+    watchConnectivityState(currentState: ConnectivityState, deadline: Date | number, callback: (error?: Error) => void): void;
+    /**
+     * Get the channelz reference object for this channel. The returned value is
+     * garbage if channelz is disabled for this channel.
+     * @returns
+     */
+    getChannelzRef(): ChannelRef;
+    createCall(method: string, deadline: Deadline, host: string | null | undefined, parentCall: ServerSurfaceCall | null, propagateFlags: number | null | undefined): Call;
+}

node_modules/@grpc/grpc-js/build/src/channel.js

@@ -0,0 +1,68 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelImplementation = void 0;
+const channel_credentials_1 = require("./channel-credentials");
+const internal_channel_1 = require("./internal-channel");
+class ChannelImplementation {
+    constructor(target, credentials, options) {
+        if (typeof target !== 'string') {
+            throw new TypeError('Channel target must be a string');
+        }
+        if (!(credentials instanceof channel_credentials_1.ChannelCredentials)) {
+            throw new TypeError('Channel credentials must be a ChannelCredentials object');
+        }
+        if (options) {
+            if (typeof options !== 'object') {
+                throw new TypeError('Channel options must be an object');
+            }
+        }
+        this.internalChannel = new internal_channel_1.InternalChannel(target, credentials, options);
+    }
+    close() {
+        this.internalChannel.close();
+    }
+    getTarget() {
+        return this.internalChannel.getTarget();
+    }
+    getConnectivityState(tryToConnect) {
+        return this.internalChannel.getConnectivityState(tryToConnect);
+    }
+    watchConnectivityState(currentState, deadline, callback) {
+        this.internalChannel.watchConnectivityState(currentState, deadline, callback);
+    }
+    /**
+     * Get the channelz reference object for this channel. The returned value is
+     * garbage if channelz is disabled for this channel.
+     * @returns
+     */
+    getChannelzRef() {
+        return this.internalChannel.getChannelzRef();
+    }
+    createCall(method, deadline, host, parentCall, propagateFlags) {
+        if (typeof method !== 'string') {
+            throw new TypeError('Channel#createCall: method must be a string');
+        }
+        if (!(typeof deadline === 'number' || deadline instanceof Date)) {
+            throw new TypeError('Channel#createCall: deadline must be a number or Date');
+        }
+        return this.internalChannel.createCall(method, deadline, host, parentCall, propagateFlags);
+    }
+}
+exports.ChannelImplementation = ChannelImplementation;
+//# sourceMappingURL=channel.js.map

node_modules/@grpc/grpc-js/build/src/channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.js","sourceRoot":"","sources":["../../src/channel.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,+DAA2D;AAO3D,yDAAqD;AAoErD,MAAa,qBAAqB;IAGhC,YACE,MAAc,EACd,WAA+B,EAC/B,OAAuB;QAEvB,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC/B,MAAM,IAAI,SAAS,CAAC,iCAAiC,CAAC,CAAC;QACzD,CAAC;QACD,IAAI,CAAC,CAAC,WAAW,YAAY,wCAAkB,CAAC,EAAE,CAAC;YACjD,MAAM,IAAI,SAAS,CACjB,yDAAyD,CAC1D,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAChC,MAAM,IAAI,SAAS,CAAC,mCAAmC,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC;QAED,IAAI,CAAC,eAAe,GAAG,IAAI,kCAAe,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;IAC3E,CAAC;IAED,KAAK;QACH,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC;IAC1C,CAAC;IAED,oBAAoB,CAAC,YAAqB;QACxC,OAAO,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,YAAY,CAAC,CAAC;IACjE,CAAC;IAED,sBAAsB,CACpB,YAA+B,EAC/B,QAAuB,EACvB,QAAiC;QAEjC,IAAI,CAAC,eAAe,CAAC,sBAAsB,CACzC,YAAY,EACZ,QAAQ,EACR,QAAQ,CACT,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,eAAe,CAAC,cAAc,EAAE,CAAC;IAC/C,CAAC;IAED,UAAU,CACR,MAAc,EACd,QAAkB,EAClB,IAA+B,EAC/B,UAAoC,EACpC,cAAyC;QAEzC,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC/B,MAAM,IAAI,SAAS,CAAC,6CAA6C,CAAC,CAAC;QACrE,CAAC;QACD,IAAI,CAAC,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,YAAY,IAAI,CAAC,EAAE,CAAC;YAChE,MAAM,IAAI,SAAS,CACjB,uDAAuD,CACxD,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,eAAe,CAAC,UAAU,CACpC,MAAM,EACN,QAAQ,EACR,IAAI,EACJ,UAAU,EACV,cAAc,CACf,CAAC;IACJ,CAAC;CACF;AAjFD,sDAiFC"}

node_modules/@grpc/grpc-js/build/src/channelz.d.ts

@@ -0,0 +1,159 @@
+/// <reference types="node" />
+import { OrderedMap } from '@js-sdsl/ordered-map';
+import { ConnectivityState } from './connectivity-state';
+import { ChannelTrace } from './generated/grpc/channelz/v1/ChannelTrace';
+import { SubchannelAddress } from './subchannel-address';
+import { ChannelzDefinition, ChannelzHandlers } from './generated/grpc/channelz/v1/Channelz';
+export type TraceSeverity = 'CT_UNKNOWN' | 'CT_INFO' | 'CT_WARNING' | 'CT_ERROR';
+interface Ref {
+    kind: EntityTypes;
+    id: number;
+    name: string;
+}
+export interface ChannelRef extends Ref {
+    kind: EntityTypes.channel;
+}
+export interface SubchannelRef extends Ref {
+    kind: EntityTypes.subchannel;
+}
+export interface ServerRef extends Ref {
+    kind: EntityTypes.server;
+}
+export interface SocketRef extends Ref {
+    kind: EntityTypes.socket;
+}
+interface TraceEvent {
+    description: string;
+    severity: TraceSeverity;
+    timestamp: Date;
+    childChannel?: ChannelRef;
+    childSubchannel?: SubchannelRef;
+}
+export declare class ChannelzTraceStub {
+    readonly events: TraceEvent[];
+    readonly creationTimestamp: Date;
+    readonly eventsLogged = 0;
+    addTrace(): void;
+    getTraceMessage(): ChannelTrace;
+}
+export declare class ChannelzTrace {
+    events: TraceEvent[];
+    creationTimestamp: Date;
+    eventsLogged: number;
+    constructor();
+    addTrace(severity: TraceSeverity, description: string, child?: ChannelRef | SubchannelRef): void;
+    getTraceMessage(): ChannelTrace;
+}
+export declare class ChannelzChildrenTracker {
+    private channelChildren;
+    private subchannelChildren;
+    private socketChildren;
+    private trackerMap;
+    refChild(child: ChannelRef | SubchannelRef | SocketRef): void;
+    unrefChild(child: ChannelRef | SubchannelRef | SocketRef): void;
+    getChildLists(): ChannelzChildren;
+}
+export declare class ChannelzChildrenTrackerStub extends ChannelzChildrenTracker {
+    refChild(): void;
+    unrefChild(): void;
+}
+export declare class ChannelzCallTracker {
+    callsStarted: number;
+    callsSucceeded: number;
+    callsFailed: number;
+    lastCallStartedTimestamp: Date | null;
+    addCallStarted(): void;
+    addCallSucceeded(): void;
+    addCallFailed(): void;
+}
+export declare class ChannelzCallTrackerStub extends ChannelzCallTracker {
+    addCallStarted(): void;
+    addCallSucceeded(): void;
+    addCallFailed(): void;
+}
+export interface ChannelzChildren {
+    channels: OrderedMap<number, {
+        ref: ChannelRef;
+        count: number;
+    }>;
+    subchannels: OrderedMap<number, {
+        ref: SubchannelRef;
+        count: number;
+    }>;
+    sockets: OrderedMap<number, {
+        ref: SocketRef;
+        count: number;
+    }>;
+}
+export interface ChannelInfo {
+    target: string;
+    state: ConnectivityState;
+    trace: ChannelzTrace | ChannelzTraceStub;
+    callTracker: ChannelzCallTracker | ChannelzCallTrackerStub;
+    children: ChannelzChildren;
+}
+export type SubchannelInfo = ChannelInfo;
+export interface ServerInfo {
+    trace: ChannelzTrace;
+    callTracker: ChannelzCallTracker;
+    listenerChildren: ChannelzChildren;
+    sessionChildren: ChannelzChildren;
+}
+export interface TlsInfo {
+    cipherSuiteStandardName: string | null;
+    cipherSuiteOtherName: string | null;
+    localCertificate: Buffer | null;
+    remoteCertificate: Buffer | null;
+}
+export interface SocketInfo {
+    localAddress: SubchannelAddress | null;
+    remoteAddress: SubchannelAddress | null;
+    security: TlsInfo | null;
+    remoteName: string | null;
+    streamsStarted: number;
+    streamsSucceeded: number;
+    streamsFailed: number;
+    messagesSent: number;
+    messagesReceived: number;
+    keepAlivesSent: number;
+    lastLocalStreamCreatedTimestamp: Date | null;
+    lastRemoteStreamCreatedTimestamp: Date | null;
+    lastMessageSentTimestamp: Date | null;
+    lastMessageReceivedTimestamp: Date | null;
+    localFlowControlWindow: number | null;
+    remoteFlowControlWindow: number | null;
+}
+interface ChannelEntry {
+    ref: ChannelRef;
+    getInfo(): ChannelInfo;
+}
+interface SubchannelEntry {
+    ref: SubchannelRef;
+    getInfo(): SubchannelInfo;
+}
+interface ServerEntry {
+    ref: ServerRef;
+    getInfo(): ServerInfo;
+}
+interface SocketEntry {
+    ref: SocketRef;
+    getInfo(): SocketInfo;
+}
+export declare const enum EntityTypes {
+    channel = "channel",
+    subchannel = "subchannel",
+    server = "server",
+    socket = "socket"
+}
+export type RefByType<T extends EntityTypes> = T extends EntityTypes.channel ? ChannelRef : T extends EntityTypes.server ? ServerRef : T extends EntityTypes.socket ? SocketRef : T extends EntityTypes.subchannel ? SubchannelRef : never;
+export type EntryByType<T extends EntityTypes> = T extends EntityTypes.channel ? ChannelEntry : T extends EntityTypes.server ? ServerEntry : T extends EntityTypes.socket ? SocketEntry : T extends EntityTypes.subchannel ? SubchannelEntry : never;
+export type InfoByType<T extends EntityTypes> = T extends EntityTypes.channel ? ChannelInfo : T extends EntityTypes.subchannel ? SubchannelInfo : T extends EntityTypes.server ? ServerInfo : T extends EntityTypes.socket ? SocketInfo : never;
+export declare const registerChannelzChannel: (name: string, getInfo: () => ChannelInfo, channelzEnabled: boolean) => ChannelRef;
+export declare const registerChannelzSubchannel: (name: string, getInfo: () => ChannelInfo, channelzEnabled: boolean) => SubchannelRef;
+export declare const registerChannelzServer: (name: string, getInfo: () => ServerInfo, channelzEnabled: boolean) => ServerRef;
+export declare const registerChannelzSocket: (name: string, getInfo: () => SocketInfo, channelzEnabled: boolean) => SocketRef;
+export declare function unregisterChannelzRef(ref: ChannelRef | SubchannelRef | ServerRef | SocketRef): void;
+export declare function getChannelzHandlers(): ChannelzHandlers;
+export declare function getChannelzServiceDefinition(): ChannelzDefinition;
+export declare function setup(): void;
+export {};

node_modules/@grpc/grpc-js/build/src/channelz.js

@@ -0,0 +1,584 @@
+"use strict";
+/*
+ * Copyright 2021 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = exports.getChannelzServiceDefinition = exports.getChannelzHandlers = exports.unregisterChannelzRef = exports.registerChannelzSocket = exports.registerChannelzServer = exports.registerChannelzSubchannel = exports.registerChannelzChannel = exports.ChannelzCallTrackerStub = exports.ChannelzCallTracker = exports.ChannelzChildrenTrackerStub = exports.ChannelzChildrenTracker = exports.ChannelzTrace = exports.ChannelzTraceStub = void 0;
+const net_1 = require("net");
+const ordered_map_1 = require("@js-sdsl/ordered-map");
+const connectivity_state_1 = require("./connectivity-state");
+const constants_1 = require("./constants");
+const subchannel_address_1 = require("./subchannel-address");
+const admin_1 = require("./admin");
+const make_client_1 = require("./make-client");
+function channelRefToMessage(ref) {
+    return {
+        channel_id: ref.id,
+        name: ref.name,
+    };
+}
+function subchannelRefToMessage(ref) {
+    return {
+        subchannel_id: ref.id,
+        name: ref.name,
+    };
+}
+function serverRefToMessage(ref) {
+    return {
+        server_id: ref.id,
+    };
+}
+function socketRefToMessage(ref) {
+    return {
+        socket_id: ref.id,
+        name: ref.name,
+    };
+}
+/**
+ * The loose upper bound on the number of events that should be retained in a
+ * trace. This may be exceeded by up to a factor of 2. Arbitrarily chosen as a
+ * number that should be large enough to contain the recent relevant
+ * information, but small enough to not use excessive memory.
+ */
+const TARGET_RETAINED_TRACES = 32;
+/**
+ * Default number of sockets/servers/channels/subchannels to return
+ */
+const DEFAULT_MAX_RESULTS = 100;
+class ChannelzTraceStub {
+    constructor() {
+        this.events = [];
+        this.creationTimestamp = new Date();
+        this.eventsLogged = 0;
+    }
+    addTrace() { }
+    getTraceMessage() {
+        return {
+            creation_timestamp: dateToProtoTimestamp(this.creationTimestamp),
+            num_events_logged: this.eventsLogged,
+            events: [],
+        };
+    }
+}
+exports.ChannelzTraceStub = ChannelzTraceStub;
+class ChannelzTrace {
+    constructor() {
+        this.events = [];
+        this.eventsLogged = 0;
+        this.creationTimestamp = new Date();
+    }
+    addTrace(severity, description, child) {
+        const timestamp = new Date();
+        this.events.push({
+            description: description,
+            severity: severity,
+            timestamp: timestamp,
+            childChannel: (child === null || child === void 0 ? void 0 : child.kind) === 'channel' ? child : undefined,
+            childSubchannel: (child === null || child === void 0 ? void 0 : child.kind) === 'subchannel' ? child : undefined,
+        });
+        // Whenever the trace array gets too large, discard the first half
+        if (this.events.length >= TARGET_RETAINED_TRACES * 2) {
+            this.events = this.events.slice(TARGET_RETAINED_TRACES);
+        }
+        this.eventsLogged += 1;
+    }
+    getTraceMessage() {
+        return {
+            creation_timestamp: dateToProtoTimestamp(this.creationTimestamp),
+            num_events_logged: this.eventsLogged,
+            events: this.events.map(event => {
+                return {
+                    description: event.description,
+                    severity: event.severity,
+                    timestamp: dateToProtoTimestamp(event.timestamp),
+                    channel_ref: event.childChannel
+                        ? channelRefToMessage(event.childChannel)
+                        : null,
+                    subchannel_ref: event.childSubchannel
+                        ? subchannelRefToMessage(event.childSubchannel)
+                        : null,
+                };
+            }),
+        };
+    }
+}
+exports.ChannelzTrace = ChannelzTrace;
+class ChannelzChildrenTracker {
+    constructor() {
+        this.channelChildren = new ordered_map_1.OrderedMap();
+        this.subchannelChildren = new ordered_map_1.OrderedMap();
+        this.socketChildren = new ordered_map_1.OrderedMap();
+        this.trackerMap = {
+            ["channel" /* EntityTypes.channel */]: this.channelChildren,
+            ["subchannel" /* EntityTypes.subchannel */]: this.subchannelChildren,
+            ["socket" /* EntityTypes.socket */]: this.socketChildren,
+        };
+    }
+    refChild(child) {
+        const tracker = this.trackerMap[child.kind];
+        const trackedChild = tracker.find(child.id);
+        if (trackedChild.equals(tracker.end())) {
+            tracker.setElement(child.id, {
+                ref: child,
+                count: 1,
+            }, trackedChild);
+        }
+        else {
+            trackedChild.pointer[1].count += 1;
+        }
+    }
+    unrefChild(child) {
+        const tracker = this.trackerMap[child.kind];
+        const trackedChild = tracker.getElementByKey(child.id);
+        if (trackedChild !== undefined) {
+            trackedChild.count -= 1;
+            if (trackedChild.count === 0) {
+                tracker.eraseElementByKey(child.id);
+            }
+        }
+    }
+    getChildLists() {
+        return {
+            channels: this.channelChildren,
+            subchannels: this.subchannelChildren,
+            sockets: this.socketChildren,
+        };
+    }
+}
+exports.ChannelzChildrenTracker = ChannelzChildrenTracker;
+class ChannelzChildrenTrackerStub extends ChannelzChildrenTracker {
+    refChild() { }
+    unrefChild() { }
+}
+exports.ChannelzChildrenTrackerStub = ChannelzChildrenTrackerStub;
+class ChannelzCallTracker {
+    constructor() {
+        this.callsStarted = 0;
+        this.callsSucceeded = 0;
+        this.callsFailed = 0;
+        this.lastCallStartedTimestamp = null;
+    }
+    addCallStarted() {
+        this.callsStarted += 1;
+        this.lastCallStartedTimestamp = new Date();
+    }
+    addCallSucceeded() {
+        this.callsSucceeded += 1;
+    }
+    addCallFailed() {
+        this.callsFailed += 1;
+    }
+}
+exports.ChannelzCallTracker = ChannelzCallTracker;
+class ChannelzCallTrackerStub extends ChannelzCallTracker {
+    addCallStarted() { }
+    addCallSucceeded() { }
+    addCallFailed() { }
+}
+exports.ChannelzCallTrackerStub = ChannelzCallTrackerStub;
+const entityMaps = {
+    ["channel" /* EntityTypes.channel */]: new ordered_map_1.OrderedMap(),
+    ["subchannel" /* EntityTypes.subchannel */]: new ordered_map_1.OrderedMap(),
+    ["server" /* EntityTypes.server */]: new ordered_map_1.OrderedMap(),
+    ["socket" /* EntityTypes.socket */]: new ordered_map_1.OrderedMap(),
+};
+const generateRegisterFn = (kind) => {
+    let nextId = 1;
+    function getNextId() {
+        return nextId++;
+    }
+    const entityMap = entityMaps[kind];
+    return (name, getInfo, channelzEnabled) => {
+        const id = getNextId();
+        const ref = { id, name, kind };
+        if (channelzEnabled) {
+            entityMap.setElement(id, { ref, getInfo });
+        }
+        return ref;
+    };
+};
+exports.registerChannelzChannel = generateRegisterFn("channel" /* EntityTypes.channel */);
+exports.registerChannelzSubchannel = generateRegisterFn("subchannel" /* EntityTypes.subchannel */);
+exports.registerChannelzServer = generateRegisterFn("server" /* EntityTypes.server */);
+exports.registerChannelzSocket = generateRegisterFn("socket" /* EntityTypes.socket */);
+function unregisterChannelzRef(ref) {
+    entityMaps[ref.kind].eraseElementByKey(ref.id);
+}
+exports.unregisterChannelzRef = unregisterChannelzRef;
+/**
+ * Parse a single section of an IPv6 address as two bytes
+ * @param addressSection A hexadecimal string of length up to 4
+ * @returns The pair of bytes representing this address section
+ */
+function parseIPv6Section(addressSection) {
+    const numberValue = Number.parseInt(addressSection, 16);
+    return [(numberValue / 256) | 0, numberValue % 256];
+}
+/**
+ * Parse a chunk of an IPv6 address string to some number of bytes
+ * @param addressChunk Some number of segments of up to 4 hexadecimal
+ *   characters each, joined by colons.
+ * @returns The list of bytes representing this address chunk
+ */
+function parseIPv6Chunk(addressChunk) {
+    if (addressChunk === '') {
+        return [];
+    }
+    const bytePairs = addressChunk
+        .split(':')
+        .map(section => parseIPv6Section(section));
+    const result = [];
+    return result.concat(...bytePairs);
+}
+/**
+ * Converts an IPv4 or IPv6 address from string representation to binary
+ * representation
+ * @param ipAddress an IP address in standard IPv4 or IPv6 text format
+ * @returns
+ */
+function ipAddressStringToBuffer(ipAddress) {
+    if ((0, net_1.isIPv4)(ipAddress)) {
+        return Buffer.from(Uint8Array.from(ipAddress.split('.').map(segment => Number.parseInt(segment))));
+    }
+    else if ((0, net_1.isIPv6)(ipAddress)) {
+        let leftSection;
+        let rightSection;
+        const doubleColonIndex = ipAddress.indexOf('::');
+        if (doubleColonIndex === -1) {
+            leftSection = ipAddress;
+            rightSection = '';
+        }
+        else {
+            leftSection = ipAddress.substring(0, doubleColonIndex);
+            rightSection = ipAddress.substring(doubleColonIndex + 2);
+        }
+        const leftBuffer = Buffer.from(parseIPv6Chunk(leftSection));
+        const rightBuffer = Buffer.from(parseIPv6Chunk(rightSection));
+        const middleBuffer = Buffer.alloc(16 - leftBuffer.length - rightBuffer.length, 0);
+        return Buffer.concat([leftBuffer, middleBuffer, rightBuffer]);
+    }
+    else {
+        return null;
+    }
+}
+function connectivityStateToMessage(state) {
+    switch (state) {
+        case connectivity_state_1.ConnectivityState.CONNECTING:
+            return {
+                state: 'CONNECTING',
+            };
+        case connectivity_state_1.ConnectivityState.IDLE:
+            return {
+                state: 'IDLE',
+            };
+        case connectivity_state_1.ConnectivityState.READY:
+            return {
+                state: 'READY',
+            };
+        case connectivity_state_1.ConnectivityState.SHUTDOWN:
+            return {
+                state: 'SHUTDOWN',
+            };
+        case connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE:
+            return {
+                state: 'TRANSIENT_FAILURE',
+            };
+        default:
+            return {
+                state: 'UNKNOWN',
+            };
+    }
+}
+function dateToProtoTimestamp(date) {
+    if (!date) {
+        return null;
+    }
+    const millisSinceEpoch = date.getTime();
+    return {
+        seconds: (millisSinceEpoch / 1000) | 0,
+        nanos: (millisSinceEpoch % 1000) * 1000000,
+    };
+}
+function getChannelMessage(channelEntry) {
+    const resolvedInfo = channelEntry.getInfo();
+    const channelRef = [];
+    const subchannelRef = [];
+    resolvedInfo.children.channels.forEach(el => {
+        channelRef.push(channelRefToMessage(el[1].ref));
+    });
+    resolvedInfo.children.subchannels.forEach(el => {
+        subchannelRef.push(subchannelRefToMessage(el[1].ref));
+    });
+    return {
+        ref: channelRefToMessage(channelEntry.ref),
+        data: {
+            target: resolvedInfo.target,
+            state: connectivityStateToMessage(resolvedInfo.state),
+            calls_started: resolvedInfo.callTracker.callsStarted,
+            calls_succeeded: resolvedInfo.callTracker.callsSucceeded,
+            calls_failed: resolvedInfo.callTracker.callsFailed,
+            last_call_started_timestamp: dateToProtoTimestamp(resolvedInfo.callTracker.lastCallStartedTimestamp),
+            trace: resolvedInfo.trace.getTraceMessage(),
+        },
+        channel_ref: channelRef,
+        subchannel_ref: subchannelRef,
+    };
+}
+function GetChannel(call, callback) {
+    const channelId = parseInt(call.request.channel_id, 10);
+    const channelEntry = entityMaps["channel" /* EntityTypes.channel */].getElementByKey(channelId);
+    if (channelEntry === undefined) {
+        callback({
+            code: constants_1.Status.NOT_FOUND,
+            details: 'No channel data found for id ' + channelId,
+        });
+        return;
+    }
+    callback(null, { channel: getChannelMessage(channelEntry) });
+}
+function GetTopChannels(call, callback) {
+    const maxResults = parseInt(call.request.max_results, 10) || DEFAULT_MAX_RESULTS;
+    const resultList = [];
+    const startId = parseInt(call.request.start_channel_id, 10);
+    const channelEntries = entityMaps["channel" /* EntityTypes.channel */];
+    let i;
+    for (i = channelEntries.lowerBound(startId); !i.equals(channelEntries.end()) && resultList.length < maxResults; i = i.next()) {
+        resultList.push(getChannelMessage(i.pointer[1]));
+    }
+    callback(null, {
+        channel: resultList,
+        end: i.equals(channelEntries.end()),
+    });
+}
+function getServerMessage(serverEntry) {
+    const resolvedInfo = serverEntry.getInfo();
+    const listenSocket = [];
+    resolvedInfo.listenerChildren.sockets.forEach(el => {
+        listenSocket.push(socketRefToMessage(el[1].ref));
+    });
+    return {
+        ref: serverRefToMessage(serverEntry.ref),
+        data: {
+            calls_started: resolvedInfo.callTracker.callsStarted,
+            calls_succeeded: resolvedInfo.callTracker.callsSucceeded,
+            calls_failed: resolvedInfo.callTracker.callsFailed,
+            last_call_started_timestamp: dateToProtoTimestamp(resolvedInfo.callTracker.lastCallStartedTimestamp),
+            trace: resolvedInfo.trace.getTraceMessage(),
+        },
+        listen_socket: listenSocket,
+    };
+}
+function GetServer(call, callback) {
+    const serverId = parseInt(call.request.server_id, 10);
+    const serverEntries = entityMaps["server" /* EntityTypes.server */];
+    const serverEntry = serverEntries.getElementByKey(serverId);
+    if (serverEntry === undefined) {
+        callback({
+            code: constants_1.Status.NOT_FOUND,
+            details: 'No server data found for id ' + serverId,
+        });
+        return;
+    }
+    callback(null, { server: getServerMessage(serverEntry) });
+}
+function GetServers(call, callback) {
+    const maxResults = parseInt(call.request.max_results, 10) || DEFAULT_MAX_RESULTS;
+    const startId = parseInt(call.request.start_server_id, 10);
+    const serverEntries = entityMaps["server" /* EntityTypes.server */];
+    const resultList = [];
+    let i;
+    for (i = serverEntries.lowerBound(startId); !i.equals(serverEntries.end()) && resultList.length < maxResults; i = i.next()) {
+        resultList.push(getServerMessage(i.pointer[1]));
+    }
+    callback(null, {
+        server: resultList,
+        end: i.equals(serverEntries.end()),
+    });
+}
+function GetSubchannel(call, callback) {
+    const subchannelId = parseInt(call.request.subchannel_id, 10);
+    const subchannelEntry = entityMaps["subchannel" /* EntityTypes.subchannel */].getElementByKey(subchannelId);
+    if (subchannelEntry === undefined) {
+        callback({
+            code: constants_1.Status.NOT_FOUND,
+            details: 'No subchannel data found for id ' + subchannelId,
+        });
+        return;
+    }
+    const resolvedInfo = subchannelEntry.getInfo();
+    const listenSocket = [];
+    resolvedInfo.children.sockets.forEach(el => {
+        listenSocket.push(socketRefToMessage(el[1].ref));
+    });
+    const subchannelMessage = {
+        ref: subchannelRefToMessage(subchannelEntry.ref),
+        data: {
+            target: resolvedInfo.target,
+            state: connectivityStateToMessage(resolvedInfo.state),
+            calls_started: resolvedInfo.callTracker.callsStarted,
+            calls_succeeded: resolvedInfo.callTracker.callsSucceeded,
+            calls_failed: resolvedInfo.callTracker.callsFailed,
+            last_call_started_timestamp: dateToProtoTimestamp(resolvedInfo.callTracker.lastCallStartedTimestamp),
+            trace: resolvedInfo.trace.getTraceMessage(),
+        },
+        socket_ref: listenSocket,
+    };
+    callback(null, { subchannel: subchannelMessage });
+}
+function subchannelAddressToAddressMessage(subchannelAddress) {
+    var _a;
+    if ((0, subchannel_address_1.isTcpSubchannelAddress)(subchannelAddress)) {
+        return {
+            address: 'tcpip_address',
+            tcpip_address: {
+                ip_address: (_a = ipAddressStringToBuffer(subchannelAddress.host)) !== null && _a !== void 0 ? _a : undefined,
+                port: subchannelAddress.port,
+            },
+        };
+    }
+    else {
+        return {
+            address: 'uds_address',
+            uds_address: {
+                filename: subchannelAddress.path,
+            },
+        };
+    }
+}
+function GetSocket(call, callback) {
+    var _a, _b, _c, _d, _e;
+    const socketId = parseInt(call.request.socket_id, 10);
+    const socketEntry = entityMaps["socket" /* EntityTypes.socket */].getElementByKey(socketId);
+    if (socketEntry === undefined) {
+        callback({
+            code: constants_1.Status.NOT_FOUND,
+            details: 'No socket data found for id ' + socketId,
+        });
+        return;
+    }
+    const resolvedInfo = socketEntry.getInfo();
+    const securityMessage = resolvedInfo.security
+        ? {
+            model: 'tls',
+            tls: {
+                cipher_suite: resolvedInfo.security.cipherSuiteStandardName
+                    ? 'standard_name'
+                    : 'other_name',
+                standard_name: (_a = resolvedInfo.security.cipherSuiteStandardName) !== null && _a !== void 0 ? _a : undefined,
+                other_name: (_b = resolvedInfo.security.cipherSuiteOtherName) !== null && _b !== void 0 ? _b : undefined,
+                local_certificate: (_c = resolvedInfo.security.localCertificate) !== null && _c !== void 0 ? _c : undefined,
+                remote_certificate: (_d = resolvedInfo.security.remoteCertificate) !== null && _d !== void 0 ? _d : undefined,
+            },
+        }
+        : null;
+    const socketMessage = {
+        ref: socketRefToMessage(socketEntry.ref),
+        local: resolvedInfo.localAddress
+            ? subchannelAddressToAddressMessage(resolvedInfo.localAddress)
+            : null,
+        remote: resolvedInfo.remoteAddress
+            ? subchannelAddressToAddressMessage(resolvedInfo.remoteAddress)
+            : null,
+        remote_name: (_e = resolvedInfo.remoteName) !== null && _e !== void 0 ? _e : undefined,
+        security: securityMessage,
+        data: {
+            keep_alives_sent: resolvedInfo.keepAlivesSent,
+            streams_started: resolvedInfo.streamsStarted,
+            streams_succeeded: resolvedInfo.streamsSucceeded,
+            streams_failed: resolvedInfo.streamsFailed,
+            last_local_stream_created_timestamp: dateToProtoTimestamp(resolvedInfo.lastLocalStreamCreatedTimestamp),
+            last_remote_stream_created_timestamp: dateToProtoTimestamp(resolvedInfo.lastRemoteStreamCreatedTimestamp),
+            messages_received: resolvedInfo.messagesReceived,
+            messages_sent: resolvedInfo.messagesSent,
+            last_message_received_timestamp: dateToProtoTimestamp(resolvedInfo.lastMessageReceivedTimestamp),
+            last_message_sent_timestamp: dateToProtoTimestamp(resolvedInfo.lastMessageSentTimestamp),
+            local_flow_control_window: resolvedInfo.localFlowControlWindow
+                ? { value: resolvedInfo.localFlowControlWindow }
+                : null,
+            remote_flow_control_window: resolvedInfo.remoteFlowControlWindow
+                ? { value: resolvedInfo.remoteFlowControlWindow }
+                : null,
+        },
+    };
+    callback(null, { socket: socketMessage });
+}
+function GetServerSockets(call, callback) {
+    const serverId = parseInt(call.request.server_id, 10);
+    const serverEntry = entityMaps["server" /* EntityTypes.server */].getElementByKey(serverId);
+    if (serverEntry === undefined) {
+        callback({
+            code: constants_1.Status.NOT_FOUND,
+            details: 'No server data found for id ' + serverId,
+        });
+        return;
+    }
+    const startId = parseInt(call.request.start_socket_id, 10);
+    const maxResults = parseInt(call.request.max_results, 10) || DEFAULT_MAX_RESULTS;
+    const resolvedInfo = serverEntry.getInfo();
+    // If we wanted to include listener sockets in the result, this line would
+    // instead say
+    // const allSockets = resolvedInfo.listenerChildren.sockets.concat(resolvedInfo.sessionChildren.sockets).sort((ref1, ref2) => ref1.id - ref2.id);
+    const allSockets = resolvedInfo.sessionChildren.sockets;
+    const resultList = [];
+    let i;
+    for (i = allSockets.lowerBound(startId); !i.equals(allSockets.end()) && resultList.length < maxResults; i = i.next()) {
+        resultList.push(socketRefToMessage(i.pointer[1].ref));
+    }
+    callback(null, {
+        socket_ref: resultList,
+        end: i.equals(allSockets.end()),
+    });
+}
+function getChannelzHandlers() {
+    return {
+        GetChannel,
+        GetTopChannels,
+        GetServer,
+        GetServers,
+        GetSubchannel,
+        GetSocket,
+        GetServerSockets,
+    };
+}
+exports.getChannelzHandlers = getChannelzHandlers;
+let loadedChannelzDefinition = null;
+function getChannelzServiceDefinition() {
+    if (loadedChannelzDefinition) {
+        return loadedChannelzDefinition;
+    }
+    /* The purpose of this complexity is to avoid loading @grpc/proto-loader at
+     * runtime for users who will not use/enable channelz. */
+    const loaderLoadSync = require('@grpc/proto-loader')
+        .loadSync;
+    const loadedProto = loaderLoadSync('channelz.proto', {
+        keepCase: true,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true,
+        includeDirs: [`${__dirname}/../../proto`],
+    });
+    const channelzGrpcObject = (0, make_client_1.loadPackageDefinition)(loadedProto);
+    loadedChannelzDefinition =
+        channelzGrpcObject.grpc.channelz.v1.Channelz.service;
+    return loadedChannelzDefinition;
+}
+exports.getChannelzServiceDefinition = getChannelzServiceDefinition;
+function setup() {
+    (0, admin_1.registerAdminService)(getChannelzServiceDefinition, getChannelzHandlers);
+}
+exports.setup = setup;
+//# sourceMappingURL=channelz.js.map

node_modules/@grpc/grpc-js/build/src/client-interceptors.d.ts

@@ -0,0 +1,120 @@
+import { Metadata } from './metadata';
+import { Listener, MetadataListener, MessageListener, StatusListener, InterceptingListener, MessageContext } from './call-interface';
+import { Status } from './constants';
+import { Channel } from './channel';
+import { CallOptions } from './client';
+import { ClientMethodDefinition } from './make-client';
+/**
+ * Error class associated with passing both interceptors and interceptor
+ * providers to a client constructor or as call options.
+ */
+export declare class InterceptorConfigurationError extends Error {
+    constructor(message: string);
+}
+export interface MetadataRequester {
+    (metadata: Metadata, listener: InterceptingListener, next: (metadata: Metadata, listener: InterceptingListener | Listener) => void): void;
+}
+export interface MessageRequester {
+    (message: any, next: (message: any) => void): void;
+}
+export interface CloseRequester {
+    (next: () => void): void;
+}
+export interface CancelRequester {
+    (next: () => void): void;
+}
+/**
+ * An object with methods for intercepting and modifying outgoing call operations.
+ */
+export interface FullRequester {
+    start: MetadataRequester;
+    sendMessage: MessageRequester;
+    halfClose: CloseRequester;
+    cancel: CancelRequester;
+}
+export type Requester = Partial<FullRequester>;
+export declare class ListenerBuilder {
+    private metadata;
+    private message;
+    private status;
+    withOnReceiveMetadata(onReceiveMetadata: MetadataListener): this;
+    withOnReceiveMessage(onReceiveMessage: MessageListener): this;
+    withOnReceiveStatus(onReceiveStatus: StatusListener): this;
+    build(): Listener;
+}
+export declare class RequesterBuilder {
+    private start;
+    private message;
+    private halfClose;
+    private cancel;
+    withStart(start: MetadataRequester): this;
+    withSendMessage(sendMessage: MessageRequester): this;
+    withHalfClose(halfClose: CloseRequester): this;
+    withCancel(cancel: CancelRequester): this;
+    build(): Requester;
+}
+export interface InterceptorOptions extends CallOptions {
+    method_definition: ClientMethodDefinition<any, any>;
+}
+export interface InterceptingCallInterface {
+    cancelWithStatus(status: Status, details: string): void;
+    getPeer(): string;
+    start(metadata: Metadata, listener?: Partial<InterceptingListener>): void;
+    sendMessageWithContext(context: MessageContext, message: any): void;
+    sendMessage(message: any): void;
+    startRead(): void;
+    halfClose(): void;
+}
+export declare class InterceptingCall implements InterceptingCallInterface {
+    private nextCall;
+    /**
+     * The requester that this InterceptingCall uses to modify outgoing operations
+     */
+    private requester;
+    /**
+     * Indicates that metadata has been passed to the requester's start
+     * method but it has not been passed to the corresponding next callback
+     */
+    private processingMetadata;
+    /**
+     * Message context for a pending message that is waiting for
+     */
+    private pendingMessageContext;
+    private pendingMessage;
+    /**
+     * Indicates that a message has been passed to the requester's sendMessage
+     * method but it has not been passed to the corresponding next callback
+     */
+    private processingMessage;
+    /**
+     * Indicates that a status was received but could not be propagated because
+     * a message was still being processed.
+     */
+    private pendingHalfClose;
+    constructor(nextCall: InterceptingCallInterface, requester?: Requester);
+    cancelWithStatus(status: Status, details: string): void;
+    getPeer(): string;
+    private processPendingMessage;
+    private processPendingHalfClose;
+    start(metadata: Metadata, interceptingListener?: Partial<InterceptingListener>): void;
+    sendMessageWithContext(context: MessageContext, message: any): void;
+    sendMessage(message: any): void;
+    startRead(): void;
+    halfClose(): void;
+}
+export interface NextCall {
+    (options: InterceptorOptions): InterceptingCallInterface;
+}
+export interface Interceptor {
+    (options: InterceptorOptions, nextCall: NextCall): InterceptingCall;
+}
+export interface InterceptorProvider {
+    (methodDefinition: ClientMethodDefinition<any, any>): Interceptor;
+}
+export interface InterceptorArguments {
+    clientInterceptors: Interceptor[];
+    clientInterceptorProviders: InterceptorProvider[];
+    callInterceptors: Interceptor[];
+    callInterceptorProviders: InterceptorProvider[];
+}
+export declare function getInterceptingCall(interceptorArgs: InterceptorArguments, methodDefinition: ClientMethodDefinition<any, any>, options: CallOptions, channel: Channel): InterceptingCallInterface;

node_modules/@grpc/grpc-js/build/src/client-interceptors.js

@@ -0,0 +1,428 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInterceptingCall = exports.InterceptingCall = exports.RequesterBuilder = exports.ListenerBuilder = exports.InterceptorConfigurationError = void 0;
+const metadata_1 = require("./metadata");
+const call_interface_1 = require("./call-interface");
+const constants_1 = require("./constants");
+const error_1 = require("./error");
+/**
+ * Error class associated with passing both interceptors and interceptor
+ * providers to a client constructor or as call options.
+ */
+class InterceptorConfigurationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InterceptorConfigurationError';
+        Error.captureStackTrace(this, InterceptorConfigurationError);
+    }
+}
+exports.InterceptorConfigurationError = InterceptorConfigurationError;
+class ListenerBuilder {
+    constructor() {
+        this.metadata = undefined;
+        this.message = undefined;
+        this.status = undefined;
+    }
+    withOnReceiveMetadata(onReceiveMetadata) {
+        this.metadata = onReceiveMetadata;
+        return this;
+    }
+    withOnReceiveMessage(onReceiveMessage) {
+        this.message = onReceiveMessage;
+        return this;
+    }
+    withOnReceiveStatus(onReceiveStatus) {
+        this.status = onReceiveStatus;
+        return this;
+    }
+    build() {
+        return {
+            onReceiveMetadata: this.metadata,
+            onReceiveMessage: this.message,
+            onReceiveStatus: this.status,
+        };
+    }
+}
+exports.ListenerBuilder = ListenerBuilder;
+class RequesterBuilder {
+    constructor() {
+        this.start = undefined;
+        this.message = undefined;
+        this.halfClose = undefined;
+        this.cancel = undefined;
+    }
+    withStart(start) {
+        this.start = start;
+        return this;
+    }
+    withSendMessage(sendMessage) {
+        this.message = sendMessage;
+        return this;
+    }
+    withHalfClose(halfClose) {
+        this.halfClose = halfClose;
+        return this;
+    }
+    withCancel(cancel) {
+        this.cancel = cancel;
+        return this;
+    }
+    build() {
+        return {
+            start: this.start,
+            sendMessage: this.message,
+            halfClose: this.halfClose,
+            cancel: this.cancel,
+        };
+    }
+}
+exports.RequesterBuilder = RequesterBuilder;
+/**
+ * A Listener with a default pass-through implementation of each method. Used
+ * for filling out Listeners with some methods omitted.
+ */
+const defaultListener = {
+    onReceiveMetadata: (metadata, next) => {
+        next(metadata);
+    },
+    onReceiveMessage: (message, next) => {
+        next(message);
+    },
+    onReceiveStatus: (status, next) => {
+        next(status);
+    },
+};
+/**
+ * A Requester with a default pass-through implementation of each method. Used
+ * for filling out Requesters with some methods omitted.
+ */
+const defaultRequester = {
+    start: (metadata, listener, next) => {
+        next(metadata, listener);
+    },
+    sendMessage: (message, next) => {
+        next(message);
+    },
+    halfClose: next => {
+        next();
+    },
+    cancel: next => {
+        next();
+    },
+};
+class InterceptingCall {
+    constructor(nextCall, requester) {
+        var _a, _b, _c, _d;
+        this.nextCall = nextCall;
+        /**
+         * Indicates that metadata has been passed to the requester's start
+         * method but it has not been passed to the corresponding next callback
+         */
+        this.processingMetadata = false;
+        /**
+         * Message context for a pending message that is waiting for
+         */
+        this.pendingMessageContext = null;
+        /**
+         * Indicates that a message has been passed to the requester's sendMessage
+         * method but it has not been passed to the corresponding next callback
+         */
+        this.processingMessage = false;
+        /**
+         * Indicates that a status was received but could not be propagated because
+         * a message was still being processed.
+         */
+        this.pendingHalfClose = false;
+        if (requester) {
+            this.requester = {
+                start: (_a = requester.start) !== null && _a !== void 0 ? _a : defaultRequester.start,
+                sendMessage: (_b = requester.sendMessage) !== null && _b !== void 0 ? _b : defaultRequester.sendMessage,
+                halfClose: (_c = requester.halfClose) !== null && _c !== void 0 ? _c : defaultRequester.halfClose,
+                cancel: (_d = requester.cancel) !== null && _d !== void 0 ? _d : defaultRequester.cancel,
+            };
+        }
+        else {
+            this.requester = defaultRequester;
+        }
+    }
+    cancelWithStatus(status, details) {
+        this.requester.cancel(() => {
+            this.nextCall.cancelWithStatus(status, details);
+        });
+    }
+    getPeer() {
+        return this.nextCall.getPeer();
+    }
+    processPendingMessage() {
+        if (this.pendingMessageContext) {
+            this.nextCall.sendMessageWithContext(this.pendingMessageContext, this.pendingMessage);
+            this.pendingMessageContext = null;
+            this.pendingMessage = null;
+        }
+    }
+    processPendingHalfClose() {
+        if (this.pendingHalfClose) {
+            this.nextCall.halfClose();
+        }
+    }
+    start(metadata, interceptingListener) {
+        var _a, _b, _c, _d, _e, _f;
+        const fullInterceptingListener = {
+            onReceiveMetadata: (_b = (_a = interceptingListener === null || interceptingListener === void 0 ? void 0 : interceptingListener.onReceiveMetadata) === null || _a === void 0 ? void 0 : _a.bind(interceptingListener)) !== null && _b !== void 0 ? _b : (metadata => { }),
+            onReceiveMessage: (_d = (_c = interceptingListener === null || interceptingListener === void 0 ? void 0 : interceptingListener.onReceiveMessage) === null || _c === void 0 ? void 0 : _c.bind(interceptingListener)) !== null && _d !== void 0 ? _d : (message => { }),
+            onReceiveStatus: (_f = (_e = interceptingListener === null || interceptingListener === void 0 ? void 0 : interceptingListener.onReceiveStatus) === null || _e === void 0 ? void 0 : _e.bind(interceptingListener)) !== null && _f !== void 0 ? _f : (status => { }),
+        };
+        this.processingMetadata = true;
+        this.requester.start(metadata, fullInterceptingListener, (md, listener) => {
+            var _a, _b, _c;
+            this.processingMetadata = false;
+            let finalInterceptingListener;
+            if ((0, call_interface_1.isInterceptingListener)(listener)) {
+                finalInterceptingListener = listener;
+            }
+            else {
+                const fullListener = {
+                    onReceiveMetadata: (_a = listener.onReceiveMetadata) !== null && _a !== void 0 ? _a : defaultListener.onReceiveMetadata,
+                    onReceiveMessage: (_b = listener.onReceiveMessage) !== null && _b !== void 0 ? _b : defaultListener.onReceiveMessage,
+                    onReceiveStatus: (_c = listener.onReceiveStatus) !== null && _c !== void 0 ? _c : defaultListener.onReceiveStatus,
+                };
+                finalInterceptingListener = new call_interface_1.InterceptingListenerImpl(fullListener, fullInterceptingListener);
+            }
+            this.nextCall.start(md, finalInterceptingListener);
+            this.processPendingMessage();
+            this.processPendingHalfClose();
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sendMessageWithContext(context, message) {
+        this.processingMessage = true;
+        this.requester.sendMessage(message, finalMessage => {
+            this.processingMessage = false;
+            if (this.processingMetadata) {
+                this.pendingMessageContext = context;
+                this.pendingMessage = message;
+            }
+            else {
+                this.nextCall.sendMessageWithContext(context, finalMessage);
+                this.processPendingHalfClose();
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sendMessage(message) {
+        this.sendMessageWithContext({}, message);
+    }
+    startRead() {
+        this.nextCall.startRead();
+    }
+    halfClose() {
+        this.requester.halfClose(() => {
+            if (this.processingMetadata || this.processingMessage) {
+                this.pendingHalfClose = true;
+            }
+            else {
+                this.nextCall.halfClose();
+            }
+        });
+    }
+}
+exports.InterceptingCall = InterceptingCall;
+function getCall(channel, path, options) {
+    var _a, _b;
+    const deadline = (_a = options.deadline) !== null && _a !== void 0 ? _a : Infinity;
+    const host = options.host;
+    const parent = (_b = options.parent) !== null && _b !== void 0 ? _b : null;
+    const propagateFlags = options.propagate_flags;
+    const credentials = options.credentials;
+    const call = channel.createCall(path, deadline, host, parent, propagateFlags);
+    if (credentials) {
+        call.setCredentials(credentials);
+    }
+    return call;
+}
+/**
+ * InterceptingCall implementation that directly owns the underlying Call
+ * object and handles serialization and deseraizliation.
+ */
+class BaseInterceptingCall {
+    constructor(call, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    methodDefinition) {
+        this.call = call;
+        this.methodDefinition = methodDefinition;
+    }
+    cancelWithStatus(status, details) {
+        this.call.cancelWithStatus(status, details);
+    }
+    getPeer() {
+        return this.call.getPeer();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sendMessageWithContext(context, message) {
+        let serialized;
+        try {
+            serialized = this.methodDefinition.requestSerialize(message);
+        }
+        catch (e) {
+            this.call.cancelWithStatus(constants_1.Status.INTERNAL, `Request message serialization failure: ${(0, error_1.getErrorMessage)(e)}`);
+            return;
+        }
+        this.call.sendMessageWithContext(context, serialized);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sendMessage(message) {
+        this.sendMessageWithContext({}, message);
+    }
+    start(metadata, interceptingListener) {
+        let readError = null;
+        this.call.start(metadata, {
+            onReceiveMetadata: metadata => {
+                var _a;
+                (_a = interceptingListener === null || interceptingListener === void 0 ? void 0 : interceptingListener.onReceiveMetadata) === null || _a === void 0 ? void 0 : _a.call(interceptingListener, metadata);
+            },
+            onReceiveMessage: message => {
+                var _a;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                let deserialized;
+                try {
+                    deserialized = this.methodDefinition.responseDeserialize(message);
+                }
+                catch (e) {
+                    readError = {
+                        code: constants_1.Status.INTERNAL,
+                        details: `Response message parsing error: ${(0, error_1.getErrorMessage)(e)}`,
+                        metadata: new metadata_1.Metadata(),
+                    };
+                    this.call.cancelWithStatus(readError.code, readError.details);
+                    return;
+                }
+                (_a = interceptingListener === null || interceptingListener === void 0 ? void 0 : interceptingListener.onReceiveMessage) === null || _a === void 0 ? void 0 : _a.call(interceptingListener, deserialized);
+            },
+            onReceiveStatus: status => {
+                var _a, _b;
+                if (readError) {
+                    (_a = interceptingListener === null || interceptingListener === void 0 ? void 0 : interceptingListener.onReceiveStatus) === null || _a === void 0 ? void 0 : _a.call(interceptingListener, readError);
+                }
+                else {
+                    (_b = interceptingListener === null || interceptingListener === void 0 ? void 0 : interceptingListener.onReceiveStatus) === null || _b === void 0 ? void 0 : _b.call(interceptingListener, status);
+                }
+            },
+        });
+    }
+    startRead() {
+        this.call.startRead();
+    }
+    halfClose() {
+        this.call.halfClose();
+    }
+}
+/**
+ * BaseInterceptingCall with special-cased behavior for methods with unary
+ * responses.
+ */
+class BaseUnaryInterceptingCall extends BaseInterceptingCall {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(call, methodDefinition) {
+        super(call, methodDefinition);
+    }
+    start(metadata, listener) {
+        var _a, _b;
+        let receivedMessage = false;
+        const wrapperListener = {
+            onReceiveMetadata: (_b = (_a = listener === null || listener === void 0 ? void 0 : listener.onReceiveMetadata) === null || _a === void 0 ? void 0 : _a.bind(listener)) !== null && _b !== void 0 ? _b : (metadata => { }),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onReceiveMessage: (message) => {
+                var _a;
+                receivedMessage = true;
+                (_a = listener === null || listener === void 0 ? void 0 : listener.onReceiveMessage) === null || _a === void 0 ? void 0 : _a.call(listener, message);
+            },
+            onReceiveStatus: (status) => {
+                var _a, _b;
+                if (!receivedMessage) {
+                    (_a = listener === null || listener === void 0 ? void 0 : listener.onReceiveMessage) === null || _a === void 0 ? void 0 : _a.call(listener, null);
+                }
+                (_b = listener === null || listener === void 0 ? void 0 : listener.onReceiveStatus) === null || _b === void 0 ? void 0 : _b.call(listener, status);
+            },
+        };
+        super.start(metadata, wrapperListener);
+        this.call.startRead();
+    }
+}
+/**
+ * BaseInterceptingCall with special-cased behavior for methods with streaming
+ * responses.
+ */
+class BaseStreamingInterceptingCall extends BaseInterceptingCall {
+}
+function getBottomInterceptingCall(channel, options, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+methodDefinition) {
+    const call = getCall(channel, methodDefinition.path, options);
+    if (methodDefinition.responseStream) {
+        return new BaseStreamingInterceptingCall(call, methodDefinition);
+    }
+    else {
+        return new BaseUnaryInterceptingCall(call, methodDefinition);
+    }
+}
+function getInterceptingCall(interceptorArgs, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+methodDefinition, options, channel) {
+    if (interceptorArgs.clientInterceptors.length > 0 &&
+        interceptorArgs.clientInterceptorProviders.length > 0) {
+        throw new InterceptorConfigurationError('Both interceptors and interceptor_providers were passed as options ' +
+            'to the client constructor. Only one of these is allowed.');
+    }
+    if (interceptorArgs.callInterceptors.length > 0 &&
+        interceptorArgs.callInterceptorProviders.length > 0) {
+        throw new InterceptorConfigurationError('Both interceptors and interceptor_providers were passed as call ' +
+            'options. Only one of these is allowed.');
+    }
+    let interceptors = [];
+    // Interceptors passed to the call override interceptors passed to the client constructor
+    if (interceptorArgs.callInterceptors.length > 0 ||
+        interceptorArgs.callInterceptorProviders.length > 0) {
+        interceptors = []
+            .concat(interceptorArgs.callInterceptors, interceptorArgs.callInterceptorProviders.map(provider => provider(methodDefinition)))
+            .filter(interceptor => interceptor);
+        // Filter out falsy values when providers return nothing
+    }
+    else {
+        interceptors = []
+            .concat(interceptorArgs.clientInterceptors, interceptorArgs.clientInterceptorProviders.map(provider => provider(methodDefinition)))
+            .filter(interceptor => interceptor);
+        // Filter out falsy values when providers return nothing
+    }
+    const interceptorOptions = Object.assign({}, options, {
+        method_definition: methodDefinition,
+    });
+    /* For each interceptor in the list, the nextCall function passed to it is
+     * based on the next interceptor in the list, using a nextCall function
+     * constructed with the following interceptor in the list, and so on. The
+     * initialValue, which is effectively at the end of the list, is a nextCall
+     * function that invokes getBottomInterceptingCall, the result of which
+     * handles (de)serialization and also gets the underlying call from the
+     * channel. */
+    const getCall = interceptors.reduceRight((nextCall, nextInterceptor) => {
+        return currentOptions => nextInterceptor(currentOptions, nextCall);
+    }, (finalOptions) => getBottomInterceptingCall(channel, finalOptions, methodDefinition));
+    return getCall(interceptorOptions);
+}
+exports.getInterceptingCall = getInterceptingCall;
+//# sourceMappingURL=client-interceptors.js.map

node_modules/@grpc/grpc-js/build/src/client.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import { ClientDuplexStream, ClientReadableStream, ClientUnaryCall, ClientWritableStream, ServiceError, SurfaceCall } from './call';
+import { CallCredentials } from './call-credentials';
+import { Channel } from './channel';
+import { ChannelCredentials } from './channel-credentials';
+import { ChannelOptions } from './channel-options';
+import { Metadata } from './metadata';
+import { ClientMethodDefinition } from './make-client';
+import { Interceptor, InterceptorProvider } from './client-interceptors';
+import { ServerUnaryCall, ServerReadableStream, ServerWritableStream, ServerDuplexStream } from './server-call';
+import { Deadline } from './deadline';
+declare const CHANNEL_SYMBOL: unique symbol;
+declare const INTERCEPTOR_SYMBOL: unique symbol;
+declare const INTERCEPTOR_PROVIDER_SYMBOL: unique symbol;
+declare const CALL_INVOCATION_TRANSFORMER_SYMBOL: unique symbol;
+export interface UnaryCallback<ResponseType> {
+    (err: ServiceError | null, value?: ResponseType): void;
+}
+export interface CallOptions {
+    deadline?: Deadline;
+    host?: string;
+    parent?: ServerUnaryCall<any, any> | ServerReadableStream<any, any> | ServerWritableStream<any, any> | ServerDuplexStream<any, any>;
+    propagate_flags?: number;
+    credentials?: CallCredentials;
+    interceptors?: Interceptor[];
+    interceptor_providers?: InterceptorProvider[];
+}
+export interface CallProperties<RequestType, ResponseType> {
+    argument?: RequestType;
+    metadata: Metadata;
+    call: SurfaceCall;
+    channel: Channel;
+    methodDefinition: ClientMethodDefinition<RequestType, ResponseType>;
+    callOptions: CallOptions;
+    callback?: UnaryCallback<ResponseType>;
+}
+export interface CallInvocationTransformer {
+    (callProperties: CallProperties<any, any>): CallProperties<any, any>;
+}
+export type ClientOptions = Partial<ChannelOptions> & {
+    channelOverride?: Channel;
+    channelFactoryOverride?: (address: string, credentials: ChannelCredentials, options: ClientOptions) => Channel;
+    interceptors?: Interceptor[];
+    interceptor_providers?: InterceptorProvider[];
+    callInvocationTransformer?: CallInvocationTransformer;
+};
+/**
+ * A generic gRPC client. Primarily useful as a base class for all generated
+ * clients.
+ */
+export declare class Client {
+    private readonly [CHANNEL_SYMBOL];
+    private readonly [INTERCEPTOR_SYMBOL];
+    private readonly [INTERCEPTOR_PROVIDER_SYMBOL];
+    private readonly [CALL_INVOCATION_TRANSFORMER_SYMBOL]?;
+    constructor(address: string, credentials: ChannelCredentials, options?: ClientOptions);
+    close(): void;
+    getChannel(): Channel;
+    waitForReady(deadline: Deadline, callback: (error?: Error) => void): void;
+    private checkOptionalUnaryResponseArguments;
+    makeUnaryRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, argument: RequestType, metadata: Metadata, options: CallOptions, callback: UnaryCallback<ResponseType>): ClientUnaryCall;
+    makeUnaryRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, argument: RequestType, metadata: Metadata, callback: UnaryCallback<ResponseType>): ClientUnaryCall;
+    makeUnaryRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, argument: RequestType, options: CallOptions, callback: UnaryCallback<ResponseType>): ClientUnaryCall;
+    makeUnaryRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, argument: RequestType, callback: UnaryCallback<ResponseType>): ClientUnaryCall;
+    makeClientStreamRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, metadata: Metadata, options: CallOptions, callback: UnaryCallback<ResponseType>): ClientWritableStream<RequestType>;
+    makeClientStreamRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, metadata: Metadata, callback: UnaryCallback<ResponseType>): ClientWritableStream<RequestType>;
+    makeClientStreamRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, options: CallOptions, callback: UnaryCallback<ResponseType>): ClientWritableStream<RequestType>;
+    makeClientStreamRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, callback: UnaryCallback<ResponseType>): ClientWritableStream<RequestType>;
+    private checkMetadataAndOptions;
+    makeServerStreamRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, argument: RequestType, metadata: Metadata, options?: CallOptions): ClientReadableStream<ResponseType>;
+    makeServerStreamRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, argument: RequestType, options?: CallOptions): ClientReadableStream<ResponseType>;
+    makeBidiStreamRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, metadata: Metadata, options?: CallOptions): ClientDuplexStream<RequestType, ResponseType>;
+    makeBidiStreamRequest<RequestType, ResponseType>(method: string, serialize: (value: RequestType) => Buffer, deserialize: (value: Buffer) => ResponseType, options?: CallOptions): ClientDuplexStream<RequestType, ResponseType>;
+}
+export {};

node_modules/@grpc/grpc-js/build/src/client.js

@@ -0,0 +1,432 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const call_1 = require("./call");
+const channel_1 = require("./channel");
+const connectivity_state_1 = require("./connectivity-state");
+const constants_1 = require("./constants");
+const metadata_1 = require("./metadata");
+const client_interceptors_1 = require("./client-interceptors");
+const CHANNEL_SYMBOL = Symbol();
+const INTERCEPTOR_SYMBOL = Symbol();
+const INTERCEPTOR_PROVIDER_SYMBOL = Symbol();
+const CALL_INVOCATION_TRANSFORMER_SYMBOL = Symbol();
+function isFunction(arg) {
+    return typeof arg === 'function';
+}
+function getErrorStackString(error) {
+    var _a;
+    return ((_a = error.stack) === null || _a === void 0 ? void 0 : _a.split('\n').slice(1).join('\n')) || 'no stack trace available';
+}
+/**
+ * A generic gRPC client. Primarily useful as a base class for all generated
+ * clients.
+ */
+class Client {
+    constructor(address, credentials, options = {}) {
+        var _a, _b;
+        options = Object.assign({}, options);
+        this[INTERCEPTOR_SYMBOL] = (_a = options.interceptors) !== null && _a !== void 0 ? _a : [];
+        delete options.interceptors;
+        this[INTERCEPTOR_PROVIDER_SYMBOL] = (_b = options.interceptor_providers) !== null && _b !== void 0 ? _b : [];
+        delete options.interceptor_providers;
+        if (this[INTERCEPTOR_SYMBOL].length > 0 &&
+            this[INTERCEPTOR_PROVIDER_SYMBOL].length > 0) {
+            throw new Error('Both interceptors and interceptor_providers were passed as options ' +
+                'to the client constructor. Only one of these is allowed.');
+        }
+        this[CALL_INVOCATION_TRANSFORMER_SYMBOL] =
+            options.callInvocationTransformer;
+        delete options.callInvocationTransformer;
+        if (options.channelOverride) {
+            this[CHANNEL_SYMBOL] = options.channelOverride;
+        }
+        else if (options.channelFactoryOverride) {
+            const channelFactoryOverride = options.channelFactoryOverride;
+            delete options.channelFactoryOverride;
+            this[CHANNEL_SYMBOL] = channelFactoryOverride(address, credentials, options);
+        }
+        else {
+            this[CHANNEL_SYMBOL] = new channel_1.ChannelImplementation(address, credentials, options);
+        }
+    }
+    close() {
+        this[CHANNEL_SYMBOL].close();
+    }
+    getChannel() {
+        return this[CHANNEL_SYMBOL];
+    }
+    waitForReady(deadline, callback) {
+        const checkState = (err) => {
+            if (err) {
+                callback(new Error('Failed to connect before the deadline'));
+                return;
+            }
+            let newState;
+            try {
+                newState = this[CHANNEL_SYMBOL].getConnectivityState(true);
+            }
+            catch (e) {
+                callback(new Error('The channel has been closed'));
+                return;
+            }
+            if (newState === connectivity_state_1.ConnectivityState.READY) {
+                callback();
+            }
+            else {
+                try {
+                    this[CHANNEL_SYMBOL].watchConnectivityState(newState, deadline, checkState);
+                }
+                catch (e) {
+                    callback(new Error('The channel has been closed'));
+                }
+            }
+        };
+        setImmediate(checkState);
+    }
+    checkOptionalUnaryResponseArguments(arg1, arg2, arg3) {
+        if (isFunction(arg1)) {
+            return { metadata: new metadata_1.Metadata(), options: {}, callback: arg1 };
+        }
+        else if (isFunction(arg2)) {
+            if (arg1 instanceof metadata_1.Metadata) {
+                return { metadata: arg1, options: {}, callback: arg2 };
+            }
+            else {
+                return { metadata: new metadata_1.Metadata(), options: arg1, callback: arg2 };
+            }
+        }
+        else {
+            if (!(arg1 instanceof metadata_1.Metadata &&
+                arg2 instanceof Object &&
+                isFunction(arg3))) {
+                throw new Error('Incorrect arguments passed');
+            }
+            return { metadata: arg1, options: arg2, callback: arg3 };
+        }
+    }
+    makeUnaryRequest(method, serialize, deserialize, argument, metadata, options, callback) {
+        var _a, _b;
+        const checkedArguments = this.checkOptionalUnaryResponseArguments(metadata, options, callback);
+        const methodDefinition = {
+            path: method,
+            requestStream: false,
+            responseStream: false,
+            requestSerialize: serialize,
+            responseDeserialize: deserialize,
+        };
+        let callProperties = {
+            argument: argument,
+            metadata: checkedArguments.metadata,
+            call: new call_1.ClientUnaryCallImpl(),
+            channel: this[CHANNEL_SYMBOL],
+            methodDefinition: methodDefinition,
+            callOptions: checkedArguments.options,
+            callback: checkedArguments.callback,
+        };
+        if (this[CALL_INVOCATION_TRANSFORMER_SYMBOL]) {
+            callProperties = this[CALL_INVOCATION_TRANSFORMER_SYMBOL](callProperties);
+        }
+        const emitter = callProperties.call;
+        const interceptorArgs = {
+            clientInterceptors: this[INTERCEPTOR_SYMBOL],
+            clientInterceptorProviders: this[INTERCEPTOR_PROVIDER_SYMBOL],
+            callInterceptors: (_a = callProperties.callOptions.interceptors) !== null && _a !== void 0 ? _a : [],
+            callInterceptorProviders: (_b = callProperties.callOptions.interceptor_providers) !== null && _b !== void 0 ? _b : [],
+        };
+        const call = (0, client_interceptors_1.getInterceptingCall)(interceptorArgs, callProperties.methodDefinition, callProperties.callOptions, callProperties.channel);
+        /* This needs to happen before the emitter is used. Unfortunately we can't
+         * enforce this with the type system. We need to construct this emitter
+         * before calling the CallInvocationTransformer, and we need to create the
+         * call after that. */
+        emitter.call = call;
+        let responseMessage = null;
+        let receivedStatus = false;
+        let callerStackError = new Error();
+        call.start(callProperties.metadata, {
+            onReceiveMetadata: metadata => {
+                emitter.emit('metadata', metadata);
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onReceiveMessage(message) {
+                if (responseMessage !== null) {
+                    call.cancelWithStatus(constants_1.Status.INTERNAL, 'Too many responses received');
+                }
+                responseMessage = message;
+            },
+            onReceiveStatus(status) {
+                if (receivedStatus) {
+                    return;
+                }
+                receivedStatus = true;
+                if (status.code === constants_1.Status.OK) {
+                    if (responseMessage === null) {
+                        const callerStack = getErrorStackString(callerStackError);
+                        callProperties.callback((0, call_1.callErrorFromStatus)({
+                            code: constants_1.Status.INTERNAL,
+                            details: 'No message received',
+                            metadata: status.metadata,
+                        }, callerStack));
+                    }
+                    else {
+                        callProperties.callback(null, responseMessage);
+                    }
+                }
+                else {
+                    const callerStack = getErrorStackString(callerStackError);
+                    callProperties.callback((0, call_1.callErrorFromStatus)(status, callerStack));
+                }
+                /* Avoid retaining the callerStackError object in the call context of
+                 * the status event handler. */
+                callerStackError = null;
+                emitter.emit('status', status);
+            },
+        });
+        call.sendMessage(argument);
+        call.halfClose();
+        return emitter;
+    }
+    makeClientStreamRequest(method, serialize, deserialize, metadata, options, callback) {
+        var _a, _b;
+        const checkedArguments = this.checkOptionalUnaryResponseArguments(metadata, options, callback);
+        const methodDefinition = {
+            path: method,
+            requestStream: true,
+            responseStream: false,
+            requestSerialize: serialize,
+            responseDeserialize: deserialize,
+        };
+        let callProperties = {
+            metadata: checkedArguments.metadata,
+            call: new call_1.ClientWritableStreamImpl(serialize),
+            channel: this[CHANNEL_SYMBOL],
+            methodDefinition: methodDefinition,
+            callOptions: checkedArguments.options,
+            callback: checkedArguments.callback,
+        };
+        if (this[CALL_INVOCATION_TRANSFORMER_SYMBOL]) {
+            callProperties = this[CALL_INVOCATION_TRANSFORMER_SYMBOL](callProperties);
+        }
+        const emitter = callProperties.call;
+        const interceptorArgs = {
+            clientInterceptors: this[INTERCEPTOR_SYMBOL],
+            clientInterceptorProviders: this[INTERCEPTOR_PROVIDER_SYMBOL],
+            callInterceptors: (_a = callProperties.callOptions.interceptors) !== null && _a !== void 0 ? _a : [],
+            callInterceptorProviders: (_b = callProperties.callOptions.interceptor_providers) !== null && _b !== void 0 ? _b : [],
+        };
+        const call = (0, client_interceptors_1.getInterceptingCall)(interceptorArgs, callProperties.methodDefinition, callProperties.callOptions, callProperties.channel);
+        /* This needs to happen before the emitter is used. Unfortunately we can't
+         * enforce this with the type system. We need to construct this emitter
+         * before calling the CallInvocationTransformer, and we need to create the
+         * call after that. */
+        emitter.call = call;
+        let responseMessage = null;
+        let receivedStatus = false;
+        let callerStackError = new Error();
+        call.start(callProperties.metadata, {
+            onReceiveMetadata: metadata => {
+                emitter.emit('metadata', metadata);
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onReceiveMessage(message) {
+                if (responseMessage !== null) {
+                    call.cancelWithStatus(constants_1.Status.INTERNAL, 'Too many responses received');
+                }
+                responseMessage = message;
+            },
+            onReceiveStatus(status) {
+                if (receivedStatus) {
+                    return;
+                }
+                receivedStatus = true;
+                if (status.code === constants_1.Status.OK) {
+                    if (responseMessage === null) {
+                        const callerStack = getErrorStackString(callerStackError);
+                        callProperties.callback((0, call_1.callErrorFromStatus)({
+                            code: constants_1.Status.INTERNAL,
+                            details: 'No message received',
+                            metadata: status.metadata,
+                        }, callerStack));
+                    }
+                    else {
+                        callProperties.callback(null, responseMessage);
+                    }
+                }
+                else {
+                    const callerStack = getErrorStackString(callerStackError);
+                    callProperties.callback((0, call_1.callErrorFromStatus)(status, callerStack));
+                }
+                /* Avoid retaining the callerStackError object in the call context of
+                 * the status event handler. */
+                callerStackError = null;
+                emitter.emit('status', status);
+            },
+        });
+        return emitter;
+    }
+    checkMetadataAndOptions(arg1, arg2) {
+        let metadata;
+        let options;
+        if (arg1 instanceof metadata_1.Metadata) {
+            metadata = arg1;
+            if (arg2) {
+                options = arg2;
+            }
+            else {
+                options = {};
+            }
+        }
+        else {
+            if (arg1) {
+                options = arg1;
+            }
+            else {
+                options = {};
+            }
+            metadata = new metadata_1.Metadata();
+        }
+        return { metadata, options };
+    }
+    makeServerStreamRequest(method, serialize, deserialize, argument, metadata, options) {
+        var _a, _b;
+        const checkedArguments = this.checkMetadataAndOptions(metadata, options);
+        const methodDefinition = {
+            path: method,
+            requestStream: false,
+            responseStream: true,
+            requestSerialize: serialize,
+            responseDeserialize: deserialize,
+        };
+        let callProperties = {
+            argument: argument,
+            metadata: checkedArguments.metadata,
+            call: new call_1.ClientReadableStreamImpl(deserialize),
+            channel: this[CHANNEL_SYMBOL],
+            methodDefinition: methodDefinition,
+            callOptions: checkedArguments.options,
+        };
+        if (this[CALL_INVOCATION_TRANSFORMER_SYMBOL]) {
+            callProperties = this[CALL_INVOCATION_TRANSFORMER_SYMBOL](callProperties);
+        }
+        const stream = callProperties.call;
+        const interceptorArgs = {
+            clientInterceptors: this[INTERCEPTOR_SYMBOL],
+            clientInterceptorProviders: this[INTERCEPTOR_PROVIDER_SYMBOL],
+            callInterceptors: (_a = callProperties.callOptions.interceptors) !== null && _a !== void 0 ? _a : [],
+            callInterceptorProviders: (_b = callProperties.callOptions.interceptor_providers) !== null && _b !== void 0 ? _b : [],
+        };
+        const call = (0, client_interceptors_1.getInterceptingCall)(interceptorArgs, callProperties.methodDefinition, callProperties.callOptions, callProperties.channel);
+        /* This needs to happen before the emitter is used. Unfortunately we can't
+         * enforce this with the type system. We need to construct this emitter
+         * before calling the CallInvocationTransformer, and we need to create the
+         * call after that. */
+        stream.call = call;
+        let receivedStatus = false;
+        let callerStackError = new Error();
+        call.start(callProperties.metadata, {
+            onReceiveMetadata(metadata) {
+                stream.emit('metadata', metadata);
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onReceiveMessage(message) {
+                stream.push(message);
+            },
+            onReceiveStatus(status) {
+                if (receivedStatus) {
+                    return;
+                }
+                receivedStatus = true;
+                stream.push(null);
+                if (status.code !== constants_1.Status.OK) {
+                    const callerStack = getErrorStackString(callerStackError);
+                    stream.emit('error', (0, call_1.callErrorFromStatus)(status, callerStack));
+                }
+                /* Avoid retaining the callerStackError object in the call context of
+                 * the status event handler. */
+                callerStackError = null;
+                stream.emit('status', status);
+            },
+        });
+        call.sendMessage(argument);
+        call.halfClose();
+        return stream;
+    }
+    makeBidiStreamRequest(method, serialize, deserialize, metadata, options) {
+        var _a, _b;
+        const checkedArguments = this.checkMetadataAndOptions(metadata, options);
+        const methodDefinition = {
+            path: method,
+            requestStream: true,
+            responseStream: true,
+            requestSerialize: serialize,
+            responseDeserialize: deserialize,
+        };
+        let callProperties = {
+            metadata: checkedArguments.metadata,
+            call: new call_1.ClientDuplexStreamImpl(serialize, deserialize),
+            channel: this[CHANNEL_SYMBOL],
+            methodDefinition: methodDefinition,
+            callOptions: checkedArguments.options,
+        };
+        if (this[CALL_INVOCATION_TRANSFORMER_SYMBOL]) {
+            callProperties = this[CALL_INVOCATION_TRANSFORMER_SYMBOL](callProperties);
+        }
+        const stream = callProperties.call;
+        const interceptorArgs = {
+            clientInterceptors: this[INTERCEPTOR_SYMBOL],
+            clientInterceptorProviders: this[INTERCEPTOR_PROVIDER_SYMBOL],
+            callInterceptors: (_a = callProperties.callOptions.interceptors) !== null && _a !== void 0 ? _a : [],
+            callInterceptorProviders: (_b = callProperties.callOptions.interceptor_providers) !== null && _b !== void 0 ? _b : [],
+        };
+        const call = (0, client_interceptors_1.getInterceptingCall)(interceptorArgs, callProperties.methodDefinition, callProperties.callOptions, callProperties.channel);
+        /* This needs to happen before the emitter is used. Unfortunately we can't
+         * enforce this with the type system. We need to construct this emitter
+         * before calling the CallInvocationTransformer, and we need to create the
+         * call after that. */
+        stream.call = call;
+        let receivedStatus = false;
+        let callerStackError = new Error();
+        call.start(callProperties.metadata, {
+            onReceiveMetadata(metadata) {
+                stream.emit('metadata', metadata);
+            },
+            onReceiveMessage(message) {
+                stream.push(message);
+            },
+            onReceiveStatus(status) {
+                if (receivedStatus) {
+                    return;
+                }
+                receivedStatus = true;
+                stream.push(null);
+                if (status.code !== constants_1.Status.OK) {
+                    const callerStack = getErrorStackString(callerStackError);
+                    stream.emit('error', (0, call_1.callErrorFromStatus)(status, callerStack));
+                }
+                /* Avoid retaining the callerStackError object in the call context of
+                 * the status event handler. */
+                callerStackError = null;
+                stream.emit('status', status);
+            },
+        });
+        return stream;
+    }
+}
+exports.Client = Client;
+//# sourceMappingURL=client.js.map

node_modules/@grpc/grpc-js/build/src/compression-algorithms.d.ts

@@ -0,0 +1,5 @@
+export declare enum CompressionAlgorithms {
+    identity = 0,
+    deflate = 1,
+    gzip = 2
+}

node_modules/@grpc/grpc-js/build/src/compression-algorithms.js

@@ -0,0 +1,26 @@
+"use strict";
+/*
+ * Copyright 2021 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionAlgorithms = void 0;
+var CompressionAlgorithms;
+(function (CompressionAlgorithms) {
+    CompressionAlgorithms[CompressionAlgorithms["identity"] = 0] = "identity";
+    CompressionAlgorithms[CompressionAlgorithms["deflate"] = 1] = "deflate";
+    CompressionAlgorithms[CompressionAlgorithms["gzip"] = 2] = "gzip";
+})(CompressionAlgorithms || (exports.CompressionAlgorithms = CompressionAlgorithms = {}));
+//# sourceMappingURL=compression-algorithms.js.map

node_modules/@grpc/grpc-js/build/src/compression-algorithms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compression-algorithms.js","sourceRoot":"","sources":["../../src/compression-algorithms.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,IAAY,qBAIX;AAJD,WAAY,qBAAqB;IAC/B,yEAAY,CAAA;IACZ,uEAAW,CAAA;IACX,iEAAQ,CAAA;AACV,CAAC,EAJW,qBAAqB,qCAArB,qBAAqB,QAIhC"}

node_modules/@grpc/grpc-js/build/src/compression-filter.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { WriteObject } from './call-interface';
+import { Channel } from './channel';
+import { ChannelOptions } from './channel-options';
+import { BaseFilter, Filter, FilterFactory } from './filter';
+import { Metadata } from './metadata';
+type SharedCompressionFilterConfig = {
+    serverSupportedEncodingHeader?: string;
+};
+export declare class CompressionFilter extends BaseFilter implements Filter {
+    private sharedFilterConfig;
+    private sendCompression;
+    private receiveCompression;
+    private currentCompressionAlgorithm;
+    constructor(channelOptions: ChannelOptions, sharedFilterConfig: SharedCompressionFilterConfig);
+    sendMetadata(metadata: Promise<Metadata>): Promise<Metadata>;
+    receiveMetadata(metadata: Metadata): Metadata;
+    sendMessage(message: Promise<WriteObject>): Promise<WriteObject>;
+    receiveMessage(message: Promise<Buffer>): Promise<Buffer>;
+}
+export declare class CompressionFilterFactory implements FilterFactory<CompressionFilter> {
+    private readonly options;
+    private sharedFilterConfig;
+    constructor(channel: Channel, options: ChannelOptions);
+    createFilter(): CompressionFilter;
+}
+export {};

node_modules/@grpc/grpc-js/build/src/compression-filter.js

@@ -0,0 +1,257 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionFilterFactory = exports.CompressionFilter = void 0;
+const zlib = require("zlib");
+const compression_algorithms_1 = require("./compression-algorithms");
+const constants_1 = require("./constants");
+const filter_1 = require("./filter");
+const logging = require("./logging");
+const isCompressionAlgorithmKey = (key) => {
+    return (typeof key === 'number' && typeof compression_algorithms_1.CompressionAlgorithms[key] === 'string');
+};
+class CompressionHandler {
+    /**
+     * @param message Raw uncompressed message bytes
+     * @param compress Indicates whether the message should be compressed
+     * @return Framed message, compressed if applicable
+     */
+    async writeMessage(message, compress) {
+        let messageBuffer = message;
+        if (compress) {
+            messageBuffer = await this.compressMessage(messageBuffer);
+        }
+        const output = Buffer.allocUnsafe(messageBuffer.length + 5);
+        output.writeUInt8(compress ? 1 : 0, 0);
+        output.writeUInt32BE(messageBuffer.length, 1);
+        messageBuffer.copy(output, 5);
+        return output;
+    }
+    /**
+     * @param data Framed message, possibly compressed
+     * @return Uncompressed message
+     */
+    async readMessage(data) {
+        const compressed = data.readUInt8(0) === 1;
+        let messageBuffer = data.slice(5);
+        if (compressed) {
+            messageBuffer = await this.decompressMessage(messageBuffer);
+        }
+        return messageBuffer;
+    }
+}
+class IdentityHandler extends CompressionHandler {
+    async compressMessage(message) {
+        return message;
+    }
+    async writeMessage(message, compress) {
+        const output = Buffer.allocUnsafe(message.length + 5);
+        /* With "identity" compression, messages should always be marked as
+         * uncompressed */
+        output.writeUInt8(0, 0);
+        output.writeUInt32BE(message.length, 1);
+        message.copy(output, 5);
+        return output;
+    }
+    decompressMessage(message) {
+        return Promise.reject(new Error('Received compressed message but "grpc-encoding" header was identity'));
+    }
+}
+class DeflateHandler extends CompressionHandler {
+    compressMessage(message) {
+        return new Promise((resolve, reject) => {
+            zlib.deflate(message, (err, output) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(output);
+                }
+            });
+        });
+    }
+    decompressMessage(message) {
+        return new Promise((resolve, reject) => {
+            zlib.inflate(message, (err, output) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(output);
+                }
+            });
+        });
+    }
+}
+class GzipHandler extends CompressionHandler {
+    compressMessage(message) {
+        return new Promise((resolve, reject) => {
+            zlib.gzip(message, (err, output) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(output);
+                }
+            });
+        });
+    }
+    decompressMessage(message) {
+        return new Promise((resolve, reject) => {
+            zlib.unzip(message, (err, output) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(output);
+                }
+            });
+        });
+    }
+}
+class UnknownHandler extends CompressionHandler {
+    constructor(compressionName) {
+        super();
+        this.compressionName = compressionName;
+    }
+    compressMessage(message) {
+        return Promise.reject(new Error(`Received message compressed with unsupported compression method ${this.compressionName}`));
+    }
+    decompressMessage(message) {
+        // This should be unreachable
+        return Promise.reject(new Error(`Compression method not supported: ${this.compressionName}`));
+    }
+}
+function getCompressionHandler(compressionName) {
+    switch (compressionName) {
+        case 'identity':
+            return new IdentityHandler();
+        case 'deflate':
+            return new DeflateHandler();
+        case 'gzip':
+            return new GzipHandler();
+        default:
+            return new UnknownHandler(compressionName);
+    }
+}
+class CompressionFilter extends filter_1.BaseFilter {
+    constructor(channelOptions, sharedFilterConfig) {
+        var _a;
+        super();
+        this.sharedFilterConfig = sharedFilterConfig;
+        this.sendCompression = new IdentityHandler();
+        this.receiveCompression = new IdentityHandler();
+        this.currentCompressionAlgorithm = 'identity';
+        const compressionAlgorithmKey = channelOptions['grpc.default_compression_algorithm'];
+        if (compressionAlgorithmKey !== undefined) {
+            if (isCompressionAlgorithmKey(compressionAlgorithmKey)) {
+                const clientSelectedEncoding = compression_algorithms_1.CompressionAlgorithms[compressionAlgorithmKey];
+                const serverSupportedEncodings = (_a = sharedFilterConfig.serverSupportedEncodingHeader) === null || _a === void 0 ? void 0 : _a.split(',');
+                /**
+                 * There are two possible situations here:
+                 * 1) We don't have any info yet from the server about what compression it supports
+                 *    In that case we should just use what the client tells us to use
+                 * 2) We've previously received a response from the server including a grpc-accept-encoding header
+                 *    In that case we only want to use the encoding chosen by the client if the server supports it
+                 */
+                if (!serverSupportedEncodings ||
+                    serverSupportedEncodings.includes(clientSelectedEncoding)) {
+                    this.currentCompressionAlgorithm = clientSelectedEncoding;
+                    this.sendCompression = getCompressionHandler(this.currentCompressionAlgorithm);
+                }
+            }
+            else {
+                logging.log(constants_1.LogVerbosity.ERROR, `Invalid value provided for grpc.default_compression_algorithm option: ${compressionAlgorithmKey}`);
+            }
+        }
+    }
+    async sendMetadata(metadata) {
+        const headers = await metadata;
+        headers.set('grpc-accept-encoding', 'identity,deflate,gzip');
+        headers.set('accept-encoding', 'identity');
+        // No need to send the header if it's "identity" -  behavior is identical; save the bandwidth
+        if (this.currentCompressionAlgorithm === 'identity') {
+            headers.remove('grpc-encoding');
+        }
+        else {
+            headers.set('grpc-encoding', this.currentCompressionAlgorithm);
+        }
+        return headers;
+    }
+    receiveMetadata(metadata) {
+        const receiveEncoding = metadata.get('grpc-encoding');
+        if (receiveEncoding.length > 0) {
+            const encoding = receiveEncoding[0];
+            if (typeof encoding === 'string') {
+                this.receiveCompression = getCompressionHandler(encoding);
+            }
+        }
+        metadata.remove('grpc-encoding');
+        /* Check to see if the compression we're using to send messages is supported by the server
+         * If not, reset the sendCompression filter and have it use the default IdentityHandler */
+        const serverSupportedEncodingsHeader = metadata.get('grpc-accept-encoding')[0];
+        if (serverSupportedEncodingsHeader) {
+            this.sharedFilterConfig.serverSupportedEncodingHeader =
+                serverSupportedEncodingsHeader;
+            const serverSupportedEncodings = serverSupportedEncodingsHeader.split(',');
+            if (!serverSupportedEncodings.includes(this.currentCompressionAlgorithm)) {
+                this.sendCompression = new IdentityHandler();
+                this.currentCompressionAlgorithm = 'identity';
+            }
+        }
+        metadata.remove('grpc-accept-encoding');
+        return metadata;
+    }
+    async sendMessage(message) {
+        var _a;
+        /* This filter is special. The input message is the bare message bytes,
+         * and the output is a framed and possibly compressed message. For this
+         * reason, this filter should be at the bottom of the filter stack */
+        const resolvedMessage = await message;
+        let compress;
+        if (this.sendCompression instanceof IdentityHandler) {
+            compress = false;
+        }
+        else {
+            compress = (((_a = resolvedMessage.flags) !== null && _a !== void 0 ? _a : 0) & 2 /* WriteFlags.NoCompress */) === 0;
+        }
+        return {
+            message: await this.sendCompression.writeMessage(resolvedMessage.message, compress),
+            flags: resolvedMessage.flags,
+        };
+    }
+    async receiveMessage(message) {
+        /* This filter is also special. The input message is framed and possibly
+         * compressed, and the output message is deframed and uncompressed. So
+         * this is another reason that this filter should be at the bottom of the
+         * filter stack. */
+        return this.receiveCompression.readMessage(await message);
+    }
+}
+exports.CompressionFilter = CompressionFilter;
+class CompressionFilterFactory {
+    constructor(channel, options) {
+        this.options = options;
+        this.sharedFilterConfig = {};
+    }
+    createFilter() {
+        return new CompressionFilter(this.options, this.sharedFilterConfig);
+    }
+}
+exports.CompressionFilterFactory = CompressionFilterFactory;
+//# sourceMappingURL=compression-filter.js.map

node_modules/@grpc/grpc-js/build/src/connectivity-state.d.ts

@@ -0,0 +1,7 @@
+export declare enum ConnectivityState {
+    IDLE = 0,
+    CONNECTING = 1,
+    READY = 2,
+    TRANSIENT_FAILURE = 3,
+    SHUTDOWN = 4
+}

node_modules/@grpc/grpc-js/build/src/connectivity-state.js

@@ -0,0 +1,28 @@
+"use strict";
+/*
+ * Copyright 2021 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectivityState = void 0;
+var ConnectivityState;
+(function (ConnectivityState) {
+    ConnectivityState[ConnectivityState["IDLE"] = 0] = "IDLE";
+    ConnectivityState[ConnectivityState["CONNECTING"] = 1] = "CONNECTING";
+    ConnectivityState[ConnectivityState["READY"] = 2] = "READY";
+    ConnectivityState[ConnectivityState["TRANSIENT_FAILURE"] = 3] = "TRANSIENT_FAILURE";
+    ConnectivityState[ConnectivityState["SHUTDOWN"] = 4] = "SHUTDOWN";
+})(ConnectivityState || (exports.ConnectivityState = ConnectivityState = {}));
+//# sourceMappingURL=connectivity-state.js.map

node_modules/@grpc/grpc-js/build/src/connectivity-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectivity-state.js","sourceRoot":"","sources":["../../src/connectivity-state.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,IAAY,iBAMX;AAND,WAAY,iBAAiB;IAC3B,yDAAI,CAAA;IACJ,qEAAU,CAAA;IACV,2DAAK,CAAA;IACL,mFAAiB,CAAA;IACjB,iEAAQ,CAAA;AACV,CAAC,EANW,iBAAiB,iCAAjB,iBAAiB,QAM5B"}

node_modules/@grpc/grpc-js/build/src/constants.d.ts

@@ -0,0 +1,38 @@
+export declare enum Status {
+    OK = 0,
+    CANCELLED = 1,
+    UNKNOWN = 2,
+    INVALID_ARGUMENT = 3,
+    DEADLINE_EXCEEDED = 4,
+    NOT_FOUND = 5,
+    ALREADY_EXISTS = 6,
+    PERMISSION_DENIED = 7,
+    RESOURCE_EXHAUSTED = 8,
+    FAILED_PRECONDITION = 9,
+    ABORTED = 10,
+    OUT_OF_RANGE = 11,
+    UNIMPLEMENTED = 12,
+    INTERNAL = 13,
+    UNAVAILABLE = 14,
+    DATA_LOSS = 15,
+    UNAUTHENTICATED = 16
+}
+export declare enum LogVerbosity {
+    DEBUG = 0,
+    INFO = 1,
+    ERROR = 2,
+    NONE = 3
+}
+/**
+ * NOTE: This enum is not currently used in any implemented API in this
+ * library. It is included only for type parity with the other implementation.
+ */
+export declare enum Propagate {
+    DEADLINE = 1,
+    CENSUS_STATS_CONTEXT = 2,
+    CENSUS_TRACING_CONTEXT = 4,
+    CANCELLATION = 8,
+    DEFAULTS = 65535
+}
+export declare const DEFAULT_MAX_SEND_MESSAGE_LENGTH = -1;
+export declare const DEFAULT_MAX_RECEIVE_MESSAGE_LENGTH: number;

node_modules/@grpc/grpc-js/build/src/constants.js

@@ -0,0 +1,64 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_RECEIVE_MESSAGE_LENGTH = exports.DEFAULT_MAX_SEND_MESSAGE_LENGTH = exports.Propagate = exports.LogVerbosity = exports.Status = void 0;
+var Status;
+(function (Status) {
+    Status[Status["OK"] = 0] = "OK";
+    Status[Status["CANCELLED"] = 1] = "CANCELLED";
+    Status[Status["UNKNOWN"] = 2] = "UNKNOWN";
+    Status[Status["INVALID_ARGUMENT"] = 3] = "INVALID_ARGUMENT";
+    Status[Status["DEADLINE_EXCEEDED"] = 4] = "DEADLINE_EXCEEDED";
+    Status[Status["NOT_FOUND"] = 5] = "NOT_FOUND";
+    Status[Status["ALREADY_EXISTS"] = 6] = "ALREADY_EXISTS";
+    Status[Status["PERMISSION_DENIED"] = 7] = "PERMISSION_DENIED";
+    Status[Status["RESOURCE_EXHAUSTED"] = 8] = "RESOURCE_EXHAUSTED";
+    Status[Status["FAILED_PRECONDITION"] = 9] = "FAILED_PRECONDITION";
+    Status[Status["ABORTED"] = 10] = "ABORTED";
+    Status[Status["OUT_OF_RANGE"] = 11] = "OUT_OF_RANGE";
+    Status[Status["UNIMPLEMENTED"] = 12] = "UNIMPLEMENTED";
+    Status[Status["INTERNAL"] = 13] = "INTERNAL";
+    Status[Status["UNAVAILABLE"] = 14] = "UNAVAILABLE";
+    Status[Status["DATA_LOSS"] = 15] = "DATA_LOSS";
+    Status[Status["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
+})(Status || (exports.Status = Status = {}));
+var LogVerbosity;
+(function (LogVerbosity) {
+    LogVerbosity[LogVerbosity["DEBUG"] = 0] = "DEBUG";
+    LogVerbosity[LogVerbosity["INFO"] = 1] = "INFO";
+    LogVerbosity[LogVerbosity["ERROR"] = 2] = "ERROR";
+    LogVerbosity[LogVerbosity["NONE"] = 3] = "NONE";
+})(LogVerbosity || (exports.LogVerbosity = LogVerbosity = {}));
+/**
+ * NOTE: This enum is not currently used in any implemented API in this
+ * library. It is included only for type parity with the other implementation.
+ */
+var Propagate;
+(function (Propagate) {
+    Propagate[Propagate["DEADLINE"] = 1] = "DEADLINE";
+    Propagate[Propagate["CENSUS_STATS_CONTEXT"] = 2] = "CENSUS_STATS_CONTEXT";
+    Propagate[Propagate["CENSUS_TRACING_CONTEXT"] = 4] = "CENSUS_TRACING_CONTEXT";
+    Propagate[Propagate["CANCELLATION"] = 8] = "CANCELLATION";
+    // https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/propagation_bits.h#L43
+    Propagate[Propagate["DEFAULTS"] = 65535] = "DEFAULTS";
+})(Propagate || (exports.Propagate = Propagate = {}));
+// -1 means unlimited
+exports.DEFAULT_MAX_SEND_MESSAGE_LENGTH = -1;
+// 4 MB default
+exports.DEFAULT_MAX_RECEIVE_MESSAGE_LENGTH = 4 * 1024 * 1024;
+//# sourceMappingURL=constants.js.map

node_modules/@grpc/grpc-js/build/src/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,IAAY,MAkBX;AAlBD,WAAY,MAAM;IAChB,+BAAM,CAAA;IACN,6CAAS,CAAA;IACT,yCAAO,CAAA;IACP,2DAAgB,CAAA;IAChB,6DAAiB,CAAA;IACjB,6CAAS,CAAA;IACT,uDAAc,CAAA;IACd,6DAAiB,CAAA;IACjB,+DAAkB,CAAA;IAClB,iEAAmB,CAAA;IACnB,0CAAO,CAAA;IACP,oDAAY,CAAA;IACZ,sDAAa,CAAA;IACb,4CAAQ,CAAA;IACR,kDAAW,CAAA;IACX,8CAAS,CAAA;IACT,0DAAe,CAAA;AACjB,CAAC,EAlBW,MAAM,sBAAN,MAAM,QAkBjB;AAED,IAAY,YAKX;AALD,WAAY,YAAY;IACtB,iDAAS,CAAA;IACT,+CAAI,CAAA;IACJ,iDAAK,CAAA;IACL,+CAAI,CAAA;AACN,CAAC,EALW,YAAY,4BAAZ,YAAY,QAKvB;AAED;;;GAGG;AACH,IAAY,SAWX;AAXD,WAAY,SAAS;IACnB,iDAAY,CAAA;IACZ,yEAAwB,CAAA;IACxB,6EAA0B,CAAA;IAC1B,yDAAgB,CAAA;IAChB,4FAA4F;IAC5F,qDAIwB,CAAA;AAC1B,CAAC,EAXW,SAAS,yBAAT,SAAS,QAWpB;AAED,qBAAqB;AACR,QAAA,+BAA+B,GAAG,CAAC,CAAC,CAAC;AAElD,eAAe;AACF,QAAA,kCAAkC,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC"}

node_modules/@grpc/grpc-js/build/src/control-plane-status.d.ts

@@ -0,0 +1,5 @@
+import { Status } from './constants';
+export declare function restrictControlPlaneStatusCode(code: Status, details: string): {
+    code: Status;
+    details: string;
+};

node_modules/@grpc/grpc-js/build/src/control-plane-status.js

@@ -0,0 +1,43 @@
+"use strict";
+/*
+ * Copyright 2022 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restrictControlPlaneStatusCode = void 0;
+const constants_1 = require("./constants");
+const INAPPROPRIATE_CONTROL_PLANE_CODES = [
+    constants_1.Status.OK,
+    constants_1.Status.INVALID_ARGUMENT,
+    constants_1.Status.NOT_FOUND,
+    constants_1.Status.ALREADY_EXISTS,
+    constants_1.Status.FAILED_PRECONDITION,
+    constants_1.Status.ABORTED,
+    constants_1.Status.OUT_OF_RANGE,
+    constants_1.Status.DATA_LOSS,
+];
+function restrictControlPlaneStatusCode(code, details) {
+    if (INAPPROPRIATE_CONTROL_PLANE_CODES.includes(code)) {
+        return {
+            code: constants_1.Status.INTERNAL,
+            details: `Invalid status from control plane: ${code} ${constants_1.Status[code]} ${details}`,
+        };
+    }
+    else {
+        return { code, details };
+    }
+}
+exports.restrictControlPlaneStatusCode = restrictControlPlaneStatusCode;
+//# sourceMappingURL=control-plane-status.js.map

node_modules/@grpc/grpc-js/build/src/control-plane-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-plane-status.js","sourceRoot":"","sources":["../../src/control-plane-status.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,2CAAqC;AAErC,MAAM,iCAAiC,GAAa;IAClD,kBAAM,CAAC,EAAE;IACT,kBAAM,CAAC,gBAAgB;IACvB,kBAAM,CAAC,SAAS;IAChB,kBAAM,CAAC,cAAc;IACrB,kBAAM,CAAC,mBAAmB;IAC1B,kBAAM,CAAC,OAAO;IACd,kBAAM,CAAC,YAAY;IACnB,kBAAM,CAAC,SAAS;CACjB,CAAC;AAEF,SAAgB,8BAA8B,CAC5C,IAAY,EACZ,OAAe;IAEf,IAAI,iCAAiC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACrD,OAAO;YACL,IAAI,EAAE,kBAAM,CAAC,QAAQ;YACrB,OAAO,EAAE,sCAAsC,IAAI,IAAI,kBAAM,CAAC,IAAI,CAAC,IAAI,OAAO,EAAE;SACjF,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAC3B,CAAC;AACH,CAAC;AAZD,wEAYC"}

node_modules/@grpc/grpc-js/build/src/deadline.d.ts

@@ -0,0 +1,22 @@
+export type Deadline = Date | number;
+export declare function minDeadline(...deadlineList: Deadline[]): Deadline;
+export declare function getDeadlineTimeoutString(deadline: Deadline): string;
+/**
+ * Get the timeout value that should be passed to setTimeout now for the timer
+ * to end at the deadline. For any deadline before now, the timer should end
+ * immediately, represented by a value of 0. For any deadline more than
+ * MAX_TIMEOUT_TIME milliseconds in the future, a timer cannot be set that will
+ * end at that time, so it is treated as infinitely far in the future.
+ * @param deadline
+ * @returns
+ */
+export declare function getRelativeTimeout(deadline: Deadline): number;
+export declare function deadlineToString(deadline: Deadline): string;
+/**
+ * Calculate the difference between two dates as a number of seconds and format
+ * it as a string.
+ * @param startDate
+ * @param endDate
+ * @returns
+ */
+export declare function formatDateDifference(startDate: Date, endDate: Date): string;

node_modules/@grpc/grpc-js/build/src/deadline.js

@@ -0,0 +1,109 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDateDifference = exports.deadlineToString = exports.getRelativeTimeout = exports.getDeadlineTimeoutString = exports.minDeadline = void 0;
+function minDeadline(...deadlineList) {
+    let minValue = Infinity;
+    for (const deadline of deadlineList) {
+        const deadlineMsecs = deadline instanceof Date ? deadline.getTime() : deadline;
+        if (deadlineMsecs < minValue) {
+            minValue = deadlineMsecs;
+        }
+    }
+    return minValue;
+}
+exports.minDeadline = minDeadline;
+const units = [
+    ['m', 1],
+    ['S', 1000],
+    ['M', 60 * 1000],
+    ['H', 60 * 60 * 1000],
+];
+function getDeadlineTimeoutString(deadline) {
+    const now = new Date().getTime();
+    if (deadline instanceof Date) {
+        deadline = deadline.getTime();
+    }
+    const timeoutMs = Math.max(deadline - now, 0);
+    for (const [unit, factor] of units) {
+        const amount = timeoutMs / factor;
+        if (amount < 1e8) {
+            return String(Math.ceil(amount)) + unit;
+        }
+    }
+    throw new Error('Deadline is too far in the future');
+}
+exports.getDeadlineTimeoutString = getDeadlineTimeoutString;
+/**
+ * See https://nodejs.org/api/timers.html#settimeoutcallback-delay-args
+ * In particular, "When delay is larger than 2147483647 or less than 1, the
+ * delay will be set to 1. Non-integer delays are truncated to an integer."
+ * This number of milliseconds is almost 25 days.
+ */
+const MAX_TIMEOUT_TIME = 2147483647;
+/**
+ * Get the timeout value that should be passed to setTimeout now for the timer
+ * to end at the deadline. For any deadline before now, the timer should end
+ * immediately, represented by a value of 0. For any deadline more than
+ * MAX_TIMEOUT_TIME milliseconds in the future, a timer cannot be set that will
+ * end at that time, so it is treated as infinitely far in the future.
+ * @param deadline
+ * @returns
+ */
+function getRelativeTimeout(deadline) {
+    const deadlineMs = deadline instanceof Date ? deadline.getTime() : deadline;
+    const now = new Date().getTime();
+    const timeout = deadlineMs - now;
+    if (timeout < 0) {
+        return 0;
+    }
+    else if (timeout > MAX_TIMEOUT_TIME) {
+        return Infinity;
+    }
+    else {
+        return timeout;
+    }
+}
+exports.getRelativeTimeout = getRelativeTimeout;
+function deadlineToString(deadline) {
+    if (deadline instanceof Date) {
+        return deadline.toISOString();
+    }
+    else {
+        const dateDeadline = new Date(deadline);
+        if (Number.isNaN(dateDeadline.getTime())) {
+            return '' + deadline;
+        }
+        else {
+            return dateDeadline.toISOString();
+        }
+    }
+}
+exports.deadlineToString = deadlineToString;
+/**
+ * Calculate the difference between two dates as a number of seconds and format
+ * it as a string.
+ * @param startDate
+ * @param endDate
+ * @returns
+ */
+function formatDateDifference(startDate, endDate) {
+    return ((endDate.getTime() - startDate.getTime()) / 1000).toFixed(3) + 's';
+}
+exports.formatDateDifference = formatDateDifference;
+//# sourceMappingURL=deadline.js.map

node_modules/@grpc/grpc-js/build/src/deadline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.js","sourceRoot":"","sources":["../../src/deadline.ts"],"names":[],"mappings":"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"}

node_modules/@grpc/grpc-js/build/src/duration.d.ts

@@ -0,0 +1,7 @@
+export interface Duration {
+    seconds: number;
+    nanos: number;
+}
+export declare function msToDuration(millis: number): Duration;
+export declare function durationToMs(duration: Duration): number;
+export declare function isDuration(value: any): value is Duration;

node_modules/@grpc/grpc-js/build/src/duration.js

@@ -0,0 +1,35 @@
+"use strict";
+/*
+ * Copyright 2022 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDuration = exports.durationToMs = exports.msToDuration = void 0;
+function msToDuration(millis) {
+    return {
+        seconds: (millis / 1000) | 0,
+        nanos: ((millis % 1000) * 1000000) | 0,
+    };
+}
+exports.msToDuration = msToDuration;
+function durationToMs(duration) {
+    return (duration.seconds * 1000 + duration.nanos / 1000000) | 0;
+}
+exports.durationToMs = durationToMs;
+function isDuration(value) {
+    return typeof value.seconds === 'number' && typeof value.nanos === 'number';
+}
+exports.isDuration = isDuration;
+//# sourceMappingURL=duration.js.map

node_modules/@grpc/grpc-js/build/src/duration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.js","sourceRoot":"","sources":["../../src/duration.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAOH,SAAgB,YAAY,CAAC,MAAc;IACzC,OAAO;QACL,OAAO,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC;QAC5B,KAAK,EAAE,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,OAAS,CAAC,GAAG,CAAC;KACzC,CAAC;AACJ,CAAC;AALD,oCAKC;AAED,SAAgB,YAAY,CAAC,QAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,GAAG,IAAI,GAAG,QAAQ,CAAC,KAAK,GAAG,OAAS,CAAC,GAAG,CAAC,CAAC;AACpE,CAAC;AAFD,oCAEC;AAED,SAAgB,UAAU,CAAC,KAAU;IACnC,OAAO,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,CAAC;AAC9E,CAAC;AAFD,gCAEC"}

node_modules/@grpc/grpc-js/build/src/error.d.ts

@@ -0,0 +1,2 @@
+export declare function getErrorMessage(error: unknown): string;
+export declare function getErrorCode(error: unknown): number | null;

node_modules/@grpc/grpc-js/build/src/error.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+ * Copyright 2022 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorCode = exports.getErrorMessage = void 0;
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    else {
+        return String(error);
+    }
+}
+exports.getErrorMessage = getErrorMessage;
+function getErrorCode(error) {
+    if (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        typeof error.code === 'number') {
+        return error.code;
+    }
+    else {
+        return null;
+    }
+}
+exports.getErrorCode = getErrorCode;
+//# sourceMappingURL=error.js.map

node_modules/@grpc/grpc-js/build/src/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../src/error.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAEH,SAAgB,eAAe,CAAC,KAAc;IAC5C,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC,OAAO,CAAC;IACvB,CAAC;SAAM,CAAC;QACN,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;AACH,CAAC;AAND,0CAMC;AAED,SAAgB,YAAY,CAAC,KAAc;IACzC,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,MAAM,IAAI,KAAK;QACf,OAAQ,KAAiC,CAAC,IAAI,KAAK,QAAQ,EAC3D,CAAC;QACD,OAAQ,KAAgC,CAAC,IAAI,CAAC;IAChD,CAAC;SAAM,CAAC;QACN,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAXD,oCAWC"}

node_modules/@grpc/grpc-js/build/src/events.d.ts

@@ -0,0 +1,9 @@
+export interface EmitterAugmentation1<Name extends string | symbol, Arg> {
+    addListener(event: Name, listener: (arg1: Arg) => void): this;
+    emit(event: Name, arg1: Arg): boolean;
+    on(event: Name, listener: (arg1: Arg) => void): this;
+    once(event: Name, listener: (arg1: Arg) => void): this;
+    prependListener(event: Name, listener: (arg1: Arg) => void): this;
+    prependOnceListener(event: Name, listener: (arg1: Arg) => void): this;
+    removeListener(event: Name, listener: (arg1: Arg) => void): this;
+}

node_modules/@grpc/grpc-js/build/src/events.js

@@ -0,0 +1,19 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=events.js.map

node_modules/@grpc/grpc-js/build/src/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/events.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG"}

node_modules/@grpc/grpc-js/build/src/experimental.d.ts

@@ -0,0 +1,16 @@
+export { trace, log } from './logging';
+export { Resolver, ResolverListener, registerResolver, ConfigSelector, createResolver, } from './resolver';
+export { GrpcUri, uriToString } from './uri-parser';
+export { Duration, durationToMs } from './duration';
+export { BackoffTimeout } from './backoff-timeout';
+export { LoadBalancer, TypedLoadBalancingConfig, ChannelControlHelper, createChildChannelControlHelper, registerLoadBalancerType, selectLbConfigFromList, parseLoadBalancingConfig, isLoadBalancerNameRegistered, } from './load-balancer';
+export { LeafLoadBalancer } from './load-balancer-pick-first';
+export { SubchannelAddress, subchannelAddressToString, Endpoint, endpointToString, endpointHasAddress, EndpointMap, } from './subchannel-address';
+export { ChildLoadBalancerHandler } from './load-balancer-child-handler';
+export { Picker, UnavailablePicker, QueuePicker, PickResult, PickArgs, PickResultType, } from './picker';
+export { Call as CallStream } from './call-interface';
+export { Filter, BaseFilter, FilterFactory } from './filter';
+export { FilterStackFactory } from './filter-stack';
+export { registerAdminService } from './admin';
+export { SubchannelInterface, BaseSubchannelWrapper, ConnectivityStateListener, HealthListener, } from './subchannel-interface';
+export { OutlierDetectionRawConfig, SuccessRateEjectionConfig, FailurePercentageEjectionConfig, } from './load-balancer-outlier-detection';

node_modules/@grpc/grpc-js/build/src/experimental.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSubchannelWrapper = exports.registerAdminService = exports.FilterStackFactory = exports.BaseFilter = exports.PickResultType = exports.QueuePicker = exports.UnavailablePicker = exports.ChildLoadBalancerHandler = exports.EndpointMap = exports.endpointHasAddress = exports.endpointToString = exports.subchannelAddressToString = exports.LeafLoadBalancer = exports.isLoadBalancerNameRegistered = exports.parseLoadBalancingConfig = exports.selectLbConfigFromList = exports.registerLoadBalancerType = exports.createChildChannelControlHelper = exports.BackoffTimeout = exports.durationToMs = exports.uriToString = exports.createResolver = exports.registerResolver = exports.log = exports.trace = void 0;
+var logging_1 = require("./logging");
+Object.defineProperty(exports, "trace", { enumerable: true, get: function () { return logging_1.trace; } });
+Object.defineProperty(exports, "log", { enumerable: true, get: function () { return logging_1.log; } });
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "registerResolver", { enumerable: true, get: function () { return resolver_1.registerResolver; } });
+Object.defineProperty(exports, "createResolver", { enumerable: true, get: function () { return resolver_1.createResolver; } });
+var uri_parser_1 = require("./uri-parser");
+Object.defineProperty(exports, "uriToString", { enumerable: true, get: function () { return uri_parser_1.uriToString; } });
+var duration_1 = require("./duration");
+Object.defineProperty(exports, "durationToMs", { enumerable: true, get: function () { return duration_1.durationToMs; } });
+var backoff_timeout_1 = require("./backoff-timeout");
+Object.defineProperty(exports, "BackoffTimeout", { enumerable: true, get: function () { return backoff_timeout_1.BackoffTimeout; } });
+var load_balancer_1 = require("./load-balancer");
+Object.defineProperty(exports, "createChildChannelControlHelper", { enumerable: true, get: function () { return load_balancer_1.createChildChannelControlHelper; } });
+Object.defineProperty(exports, "registerLoadBalancerType", { enumerable: true, get: function () { return load_balancer_1.registerLoadBalancerType; } });
+Object.defineProperty(exports, "selectLbConfigFromList", { enumerable: true, get: function () { return load_balancer_1.selectLbConfigFromList; } });
+Object.defineProperty(exports, "parseLoadBalancingConfig", { enumerable: true, get: function () { return load_balancer_1.parseLoadBalancingConfig; } });
+Object.defineProperty(exports, "isLoadBalancerNameRegistered", { enumerable: true, get: function () { return load_balancer_1.isLoadBalancerNameRegistered; } });
+var load_balancer_pick_first_1 = require("./load-balancer-pick-first");
+Object.defineProperty(exports, "LeafLoadBalancer", { enumerable: true, get: function () { return load_balancer_pick_first_1.LeafLoadBalancer; } });
+var subchannel_address_1 = require("./subchannel-address");
+Object.defineProperty(exports, "subchannelAddressToString", { enumerable: true, get: function () { return subchannel_address_1.subchannelAddressToString; } });
+Object.defineProperty(exports, "endpointToString", { enumerable: true, get: function () { return subchannel_address_1.endpointToString; } });
+Object.defineProperty(exports, "endpointHasAddress", { enumerable: true, get: function () { return subchannel_address_1.endpointHasAddress; } });
+Object.defineProperty(exports, "EndpointMap", { enumerable: true, get: function () { return subchannel_address_1.EndpointMap; } });
+var load_balancer_child_handler_1 = require("./load-balancer-child-handler");
+Object.defineProperty(exports, "ChildLoadBalancerHandler", { enumerable: true, get: function () { return load_balancer_child_handler_1.ChildLoadBalancerHandler; } });
+var picker_1 = require("./picker");
+Object.defineProperty(exports, "UnavailablePicker", { enumerable: true, get: function () { return picker_1.UnavailablePicker; } });
+Object.defineProperty(exports, "QueuePicker", { enumerable: true, get: function () { return picker_1.QueuePicker; } });
+Object.defineProperty(exports, "PickResultType", { enumerable: true, get: function () { return picker_1.PickResultType; } });
+var filter_1 = require("./filter");
+Object.defineProperty(exports, "BaseFilter", { enumerable: true, get: function () { return filter_1.BaseFilter; } });
+var filter_stack_1 = require("./filter-stack");
+Object.defineProperty(exports, "FilterStackFactory", { enumerable: true, get: function () { return filter_stack_1.FilterStackFactory; } });
+var admin_1 = require("./admin");
+Object.defineProperty(exports, "registerAdminService", { enumerable: true, get: function () { return admin_1.registerAdminService; } });
+var subchannel_interface_1 = require("./subchannel-interface");
+Object.defineProperty(exports, "BaseSubchannelWrapper", { enumerable: true, get: function () { return subchannel_interface_1.BaseSubchannelWrapper; } });
+//# sourceMappingURL=experimental.js.map

node_modules/@grpc/grpc-js/build/src/experimental.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"experimental.js","sourceRoot":"","sources":["../../src/experimental.ts"],"names":[],"mappings":";;;AAAA,qCAAuC;AAA9B,gGAAA,KAAK,OAAA;AAAE,8FAAA,GAAG,OAAA;AACnB,uCAMoB;AAHlB,4GAAA,gBAAgB,OAAA;AAEhB,0GAAA,cAAc,OAAA;AAEhB,2CAAoD;AAAlC,yGAAA,WAAW,OAAA;AAC7B,uCAAoD;AAAjC,wGAAA,YAAY,OAAA;AAC/B,qDAAmD;AAA1C,iHAAA,cAAc,OAAA;AACvB,iDASyB;AALvB,gIAAA,+BAA+B,OAAA;AAC/B,yHAAA,wBAAwB,OAAA;AACxB,uHAAA,sBAAsB,OAAA;AACtB,yHAAA,wBAAwB,OAAA;AACxB,6HAAA,4BAA4B,OAAA;AAE9B,uEAA8D;AAArD,4HAAA,gBAAgB,OAAA;AACzB,2DAO8B;AAL5B,+HAAA,yBAAyB,OAAA;AAEzB,sHAAA,gBAAgB,OAAA;AAChB,wHAAA,kBAAkB,OAAA;AAClB,iHAAA,WAAW,OAAA;AAEb,6EAAyE;AAAhE,uIAAA,wBAAwB,OAAA;AACjC,mCAOkB;AALhB,2GAAA,iBAAiB,OAAA;AACjB,qGAAA,WAAW,OAAA;AAGX,wGAAA,cAAc,OAAA;AAGhB,mCAA6D;AAA5C,oGAAA,UAAU,OAAA;AAC3B,+CAAoD;AAA3C,kHAAA,kBAAkB,OAAA;AAC3B,iCAA+C;AAAtC,6GAAA,oBAAoB,OAAA;AAC7B,+DAKgC;AAH9B,6HAAA,qBAAqB,OAAA"}

node_modules/@grpc/grpc-js/build/src/filter-stack.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { StatusObject, WriteObject } from './call-interface';
+import { Filter, FilterFactory } from './filter';
+import { Metadata } from './metadata';
+export declare class FilterStack implements Filter {
+    private readonly filters;
+    constructor(filters: Filter[]);
+    sendMetadata(metadata: Promise<Metadata>): Promise<Metadata>;
+    receiveMetadata(metadata: Metadata): Metadata;
+    sendMessage(message: Promise<WriteObject>): Promise<WriteObject>;
+    receiveMessage(message: Promise<Buffer>): Promise<Buffer>;
+    receiveTrailers(status: StatusObject): StatusObject;
+    push(filters: Filter[]): void;
+    getFilters(): Filter[];
+}
+export declare class FilterStackFactory implements FilterFactory<FilterStack> {
+    private readonly factories;
+    constructor(factories: Array<FilterFactory<Filter>>);
+    push(filterFactories: FilterFactory<Filter>[]): void;
+    clone(): FilterStackFactory;
+    createFilter(): FilterStack;
+}

node_modules/@grpc/grpc-js/build/src/filter-stack.js

@@ -0,0 +1,82 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterStackFactory = exports.FilterStack = void 0;
+class FilterStack {
+    constructor(filters) {
+        this.filters = filters;
+    }
+    sendMetadata(metadata) {
+        let result = metadata;
+        for (let i = 0; i < this.filters.length; i++) {
+            result = this.filters[i].sendMetadata(result);
+        }
+        return result;
+    }
+    receiveMetadata(metadata) {
+        let result = metadata;
+        for (let i = this.filters.length - 1; i >= 0; i--) {
+            result = this.filters[i].receiveMetadata(result);
+        }
+        return result;
+    }
+    sendMessage(message) {
+        let result = message;
+        for (let i = 0; i < this.filters.length; i++) {
+            result = this.filters[i].sendMessage(result);
+        }
+        return result;
+    }
+    receiveMessage(message) {
+        let result = message;
+        for (let i = this.filters.length - 1; i >= 0; i--) {
+            result = this.filters[i].receiveMessage(result);
+        }
+        return result;
+    }
+    receiveTrailers(status) {
+        let result = status;
+        for (let i = this.filters.length - 1; i >= 0; i--) {
+            result = this.filters[i].receiveTrailers(result);
+        }
+        return result;
+    }
+    push(filters) {
+        this.filters.unshift(...filters);
+    }
+    getFilters() {
+        return this.filters;
+    }
+}
+exports.FilterStack = FilterStack;
+class FilterStackFactory {
+    constructor(factories) {
+        this.factories = factories;
+    }
+    push(filterFactories) {
+        this.factories.unshift(...filterFactories);
+    }
+    clone() {
+        return new FilterStackFactory([...this.factories]);
+    }
+    createFilter() {
+        return new FilterStack(this.factories.map(factory => factory.createFilter()));
+    }
+}
+exports.FilterStackFactory = FilterStackFactory;
+//# sourceMappingURL=filter-stack.js.map

node_modules/@grpc/grpc-js/build/src/filter-stack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-stack.js","sourceRoot":"","sources":["../../src/filter-stack.ts"],"names":[],"mappings":"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"}

node_modules/@grpc/grpc-js/build/src/filter.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { StatusObject, WriteObject } from './call-interface';
+import { Metadata } from './metadata';
+/**
+ * Filter classes represent related per-call logic and state that is primarily
+ * used to modify incoming and outgoing data. All async filters can be
+ * rejected. The rejection error must be a StatusObject, and a rejection will
+ * cause the call to end with that status.
+ */
+export interface Filter {
+    sendMetadata(metadata: Promise<Metadata>): Promise<Metadata>;
+    receiveMetadata(metadata: Metadata): Metadata;
+    sendMessage(message: Promise<WriteObject>): Promise<WriteObject>;
+    receiveMessage(message: Promise<Buffer>): Promise<Buffer>;
+    receiveTrailers(status: StatusObject): StatusObject;
+}
+export declare abstract class BaseFilter implements Filter {
+    sendMetadata(metadata: Promise<Metadata>): Promise<Metadata>;
+    receiveMetadata(metadata: Metadata): Metadata;
+    sendMessage(message: Promise<WriteObject>): Promise<WriteObject>;
+    receiveMessage(message: Promise<Buffer>): Promise<Buffer>;
+    receiveTrailers(status: StatusObject): StatusObject;
+}
+export interface FilterFactory<T extends Filter> {
+    createFilter(): T;
+}

node_modules/@grpc/grpc-js/build/src/filter.js

@@ -0,0 +1,38 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseFilter = void 0;
+class BaseFilter {
+    async sendMetadata(metadata) {
+        return metadata;
+    }
+    receiveMetadata(metadata) {
+        return metadata;
+    }
+    async sendMessage(message) {
+        return message;
+    }
+    async receiveMessage(message) {
+        return message;
+    }
+    receiveTrailers(status) {
+        return status;
+    }
+}
+exports.BaseFilter = BaseFilter;
+//# sourceMappingURL=filter.js.map

node_modules/@grpc/grpc-js/build/src/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.js","sourceRoot":"","sources":["../../src/filter.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAuBH,MAAsB,UAAU;IAC9B,KAAK,CAAC,YAAY,CAAC,QAA2B;QAC5C,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,eAAe,CAAC,QAAkB;QAChC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,OAA6B;QAC7C,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,OAAwB;QAC3C,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,eAAe,CAAC,MAAoB;QAClC,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AApBD,gCAoBC"}

node_modules/@grpc/grpc-js/build/src/generated/channelz.d.ts

@@ -0,0 +1,72 @@
+import type * as grpc from '../index';
+import type { MessageTypeDefinition } from '@grpc/proto-loader';
+import type { ChannelzClient as _grpc_channelz_v1_ChannelzClient, ChannelzDefinition as _grpc_channelz_v1_ChannelzDefinition } from './grpc/channelz/v1/Channelz';
+type SubtypeConstructor<Constructor extends new (...args: any) => any, Subtype> = {
+    new (...args: ConstructorParameters<Constructor>): Subtype;
+};
+export interface ProtoGrpcType {
+    google: {
+        protobuf: {
+            Any: MessageTypeDefinition;
+            BoolValue: MessageTypeDefinition;
+            BytesValue: MessageTypeDefinition;
+            DoubleValue: MessageTypeDefinition;
+            Duration: MessageTypeDefinition;
+            FloatValue: MessageTypeDefinition;
+            Int32Value: MessageTypeDefinition;
+            Int64Value: MessageTypeDefinition;
+            StringValue: MessageTypeDefinition;
+            Timestamp: MessageTypeDefinition;
+            UInt32Value: MessageTypeDefinition;
+            UInt64Value: MessageTypeDefinition;
+        };
+    };
+    grpc: {
+        channelz: {
+            v1: {
+                Address: MessageTypeDefinition;
+                Channel: MessageTypeDefinition;
+                ChannelConnectivityState: MessageTypeDefinition;
+                ChannelData: MessageTypeDefinition;
+                ChannelRef: MessageTypeDefinition;
+                ChannelTrace: MessageTypeDefinition;
+                ChannelTraceEvent: MessageTypeDefinition;
+                /**
+                 * Channelz is a service exposed by gRPC servers that provides detailed debug
+                 * information.
+                 */
+                Channelz: SubtypeConstructor<typeof grpc.Client, _grpc_channelz_v1_ChannelzClient> & {
+                    service: _grpc_channelz_v1_ChannelzDefinition;
+                };
+                GetChannelRequest: MessageTypeDefinition;
+                GetChannelResponse: MessageTypeDefinition;
+                GetServerRequest: MessageTypeDefinition;
+                GetServerResponse: MessageTypeDefinition;
+                GetServerSocketsRequest: MessageTypeDefinition;
+                GetServerSocketsResponse: MessageTypeDefinition;
+                GetServersRequest: MessageTypeDefinition;
+                GetServersResponse: MessageTypeDefinition;
+                GetSocketRequest: MessageTypeDefinition;
+                GetSocketResponse: MessageTypeDefinition;
+                GetSubchannelRequest: MessageTypeDefinition;
+                GetSubchannelResponse: MessageTypeDefinition;
+                GetTopChannelsRequest: MessageTypeDefinition;
+                GetTopChannelsResponse: MessageTypeDefinition;
+                Security: MessageTypeDefinition;
+                Server: MessageTypeDefinition;
+                ServerData: MessageTypeDefinition;
+                ServerRef: MessageTypeDefinition;
+                Socket: MessageTypeDefinition;
+                SocketData: MessageTypeDefinition;
+                SocketOption: MessageTypeDefinition;
+                SocketOptionLinger: MessageTypeDefinition;
+                SocketOptionTcpInfo: MessageTypeDefinition;
+                SocketOptionTimeout: MessageTypeDefinition;
+                SocketRef: MessageTypeDefinition;
+                Subchannel: MessageTypeDefinition;
+                SubchannelRef: MessageTypeDefinition;
+            };
+        };
+    };
+}
+export {};

node_modules/@grpc/grpc-js/build/src/generated/channelz.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=channelz.js.map

node_modules/@grpc/grpc-js/build/src/generated/channelz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channelz.js","sourceRoot":"","sources":["../../../src/generated/channelz.ts"],"names":[],"mappings":""}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/Any.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import type { AnyExtension } from '@grpc/proto-loader';
+export type Any = AnyExtension | {
+    type_url: string;
+    value: Buffer | Uint8Array | string;
+};
+export interface Any__Output {
+    'type_url': (string);
+    'value': (Buffer);
+}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/Any.js

@@ -0,0 +1,4 @@
+"use strict";
+// Original file: null
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Any.js.map

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/Any.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Any.js","sourceRoot":"","sources":["../../../../../src/generated/google/protobuf/Any.ts"],"names":[],"mappings":";AAAA,sBAAsB"}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/BoolValue.d.ts

@@ -0,0 +1,6 @@
+export interface BoolValue {
+    'value'?: (boolean);
+}
+export interface BoolValue__Output {
+    'value': (boolean);
+}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/BoolValue.js

@@ -0,0 +1,4 @@
+"use strict";
+// Original file: null
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=BoolValue.js.map

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/BoolValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoolValue.js","sourceRoot":"","sources":["../../../../../src/generated/google/protobuf/BoolValue.ts"],"names":[],"mappings":";AAAA,sBAAsB"}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/BytesValue.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+export interface BytesValue {
+    'value'?: (Buffer | Uint8Array | string);
+}
+export interface BytesValue__Output {
+    'value': (Buffer);
+}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/BytesValue.js

@@ -0,0 +1,4 @@
+"use strict";
+// Original file: null
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=BytesValue.js.map

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/BytesValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BytesValue.js","sourceRoot":"","sources":["../../../../../src/generated/google/protobuf/BytesValue.ts"],"names":[],"mappings":";AAAA,sBAAsB"}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/DoubleValue.d.ts

@@ -0,0 +1,6 @@
+export interface DoubleValue {
+    'value'?: (number | string);
+}
+export interface DoubleValue__Output {
+    'value': (number);
+}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/DoubleValue.js

@@ -0,0 +1,4 @@
+"use strict";
+// Original file: null
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=DoubleValue.js.map

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/DoubleValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DoubleValue.js","sourceRoot":"","sources":["../../../../../src/generated/google/protobuf/DoubleValue.ts"],"names":[],"mappings":";AAAA,sBAAsB"}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/Duration.d.ts

@@ -0,0 +1,9 @@
+import type { Long } from '@grpc/proto-loader';
+export interface Duration {
+    'seconds'?: (number | string | Long);
+    'nanos'?: (number);
+}
+export interface Duration__Output {
+    'seconds': (string);
+    'nanos': (number);
+}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/Duration.js

@@ -0,0 +1,4 @@
+"use strict";
+// Original file: null
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Duration.js.map

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/Duration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Duration.js","sourceRoot":"","sources":["../../../../../src/generated/google/protobuf/Duration.ts"],"names":[],"mappings":";AAAA,sBAAsB"}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/FloatValue.d.ts

@@ -0,0 +1,6 @@
+export interface FloatValue {
+    'value'?: (number | string);
+}
+export interface FloatValue__Output {
+    'value': (number);
+}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/FloatValue.js

@@ -0,0 +1,4 @@
+"use strict";
+// Original file: null
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=FloatValue.js.map

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/FloatValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatValue.js","sourceRoot":"","sources":["../../../../../src/generated/google/protobuf/FloatValue.ts"],"names":[],"mappings":";AAAA,sBAAsB"}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/Int32Value.d.ts

@@ -0,0 +1,6 @@
+export interface Int32Value {
+    'value'?: (number);
+}
+export interface Int32Value__Output {
+    'value': (number);
+}

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/Int32Value.js

@@ -0,0 +1,4 @@
+"use strict";
+// Original file: null
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Int32Value.js.map

node_modules/@grpc/grpc-js/build/src/generated/google/protobuf/Int32Value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Int32Value.js","sourceRoot":"","sources":["../../../../../src/generated/google/protobuf/Int32Value.ts"],"names":[],"mappings":";AAAA,sBAAsB"}