@ondewo/csi-client-angular 2.3.1

package/esm2020/api/google/api/http.pb.mjs

@@ -0,0 +1,524 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+/**
+ * Message implementation for google.api.Http
+ */
+export class Http {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Http to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.rules = (_value.rules || []).map(m => new HttpRule(m));
+        this.fullyDecodeReservedExpansion = _value.fullyDecodeReservedExpansion;
+        Http.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Http();
+        Http.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.rules = _instance.rules || [];
+        _instance.fullyDecodeReservedExpansion =
+            _instance.fullyDecodeReservedExpansion || false;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    const messageInitializer1 = new HttpRule();
+                    _reader.readMessage(messageInitializer1, HttpRule.deserializeBinaryFromReader);
+                    (_instance.rules = _instance.rules || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.fullyDecodeReservedExpansion = _reader.readBool();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        Http.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.rules && _instance.rules.length) {
+            _writer.writeRepeatedMessage(1, _instance.rules, HttpRule.serializeBinaryToWriter);
+        }
+        if (_instance.fullyDecodeReservedExpansion) {
+            _writer.writeBool(2, _instance.fullyDecodeReservedExpansion);
+        }
+    }
+    get rules() {
+        return this._rules;
+    }
+    set rules(value) {
+        this._rules = value;
+    }
+    get fullyDecodeReservedExpansion() {
+        return this._fullyDecodeReservedExpansion;
+    }
+    set fullyDecodeReservedExpansion(value) {
+        this._fullyDecodeReservedExpansion = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        Http.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            rules: (this.rules || []).map(m => m.toObject()),
+            fullyDecodeReservedExpansion: this.fullyDecodeReservedExpansion
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            rules: (this.rules || []).map(m => m.toProtobufJSON(options)),
+            fullyDecodeReservedExpansion: this.fullyDecodeReservedExpansion
+        };
+    }
+}
+Http.id = 'google.api.Http';
+/**
+ * Message implementation for google.api.HttpRule
+ */
+export class HttpRule {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of HttpRule to deeply clone from
+     */
+    constructor(_value) {
+        this._pattern = HttpRule.PatternCase.none;
+        _value = _value || {};
+        this.selector = _value.selector;
+        this.get = _value.get;
+        this.put = _value.put;
+        this.post = _value.post;
+        this.delete = _value.delete;
+        this.patch = _value.patch;
+        this.custom = _value.custom
+            ? new CustomHttpPattern(_value.custom)
+            : undefined;
+        this.body = _value.body;
+        this.responseBody = _value.responseBody;
+        this.additionalBindings = (_value.additionalBindings || []).map(m => new HttpRule(m));
+        HttpRule.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new HttpRule();
+        HttpRule.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.selector = _instance.selector || '';
+        _instance.body = _instance.body || '';
+        _instance.responseBody = _instance.responseBody || '';
+        _instance.additionalBindings = _instance.additionalBindings || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.selector = _reader.readString();
+                    break;
+                case 2:
+                    _instance.get = _reader.readString();
+                    break;
+                case 3:
+                    _instance.put = _reader.readString();
+                    break;
+                case 4:
+                    _instance.post = _reader.readString();
+                    break;
+                case 5:
+                    _instance.delete = _reader.readString();
+                    break;
+                case 6:
+                    _instance.patch = _reader.readString();
+                    break;
+                case 8:
+                    _instance.custom = new CustomHttpPattern();
+                    _reader.readMessage(_instance.custom, CustomHttpPattern.deserializeBinaryFromReader);
+                    break;
+                case 7:
+                    _instance.body = _reader.readString();
+                    break;
+                case 12:
+                    _instance.responseBody = _reader.readString();
+                    break;
+                case 11:
+                    const messageInitializer11 = new HttpRule();
+                    _reader.readMessage(messageInitializer11, HttpRule.deserializeBinaryFromReader);
+                    (_instance.additionalBindings =
+                        _instance.additionalBindings || []).push(messageInitializer11);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        HttpRule.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.selector) {
+            _writer.writeString(1, _instance.selector);
+        }
+        if (_instance.get || _instance.get === '') {
+            _writer.writeString(2, _instance.get);
+        }
+        if (_instance.put || _instance.put === '') {
+            _writer.writeString(3, _instance.put);
+        }
+        if (_instance.post || _instance.post === '') {
+            _writer.writeString(4, _instance.post);
+        }
+        if (_instance.delete || _instance.delete === '') {
+            _writer.writeString(5, _instance.delete);
+        }
+        if (_instance.patch || _instance.patch === '') {
+            _writer.writeString(6, _instance.patch);
+        }
+        if (_instance.custom) {
+            _writer.writeMessage(8, _instance.custom, CustomHttpPattern.serializeBinaryToWriter);
+        }
+        if (_instance.body) {
+            _writer.writeString(7, _instance.body);
+        }
+        if (_instance.responseBody) {
+            _writer.writeString(12, _instance.responseBody);
+        }
+        if (_instance.additionalBindings && _instance.additionalBindings.length) {
+            _writer.writeRepeatedMessage(11, _instance.additionalBindings, HttpRule.serializeBinaryToWriter);
+        }
+    }
+    get selector() {
+        return this._selector;
+    }
+    set selector(value) {
+        this._selector = value;
+    }
+    get get() {
+        return this._get;
+    }
+    set get(value) {
+        if (value !== undefined && value !== null) {
+            this._put = this._post = this._delete = this._patch = this._custom = undefined;
+            this._pattern = HttpRule.PatternCase.get;
+        }
+        this._get = value;
+    }
+    get put() {
+        return this._put;
+    }
+    set put(value) {
+        if (value !== undefined && value !== null) {
+            this._get = this._post = this._delete = this._patch = this._custom = undefined;
+            this._pattern = HttpRule.PatternCase.put;
+        }
+        this._put = value;
+    }
+    get post() {
+        return this._post;
+    }
+    set post(value) {
+        if (value !== undefined && value !== null) {
+            this._get = this._put = this._delete = this._patch = this._custom = undefined;
+            this._pattern = HttpRule.PatternCase.post;
+        }
+        this._post = value;
+    }
+    get delete() {
+        return this._delete;
+    }
+    set delete(value) {
+        if (value !== undefined && value !== null) {
+            this._get = this._put = this._post = this._patch = this._custom = undefined;
+            this._pattern = HttpRule.PatternCase.delete;
+        }
+        this._delete = value;
+    }
+    get patch() {
+        return this._patch;
+    }
+    set patch(value) {
+        if (value !== undefined && value !== null) {
+            this._get = this._put = this._post = this._delete = this._custom = undefined;
+            this._pattern = HttpRule.PatternCase.patch;
+        }
+        this._patch = value;
+    }
+    get custom() {
+        return this._custom;
+    }
+    set custom(value) {
+        if (value !== undefined && value !== null) {
+            this._get = this._put = this._post = this._delete = this._patch = undefined;
+            this._pattern = HttpRule.PatternCase.custom;
+        }
+        this._custom = value;
+    }
+    get body() {
+        return this._body;
+    }
+    set body(value) {
+        this._body = value;
+    }
+    get responseBody() {
+        return this._responseBody;
+    }
+    set responseBody(value) {
+        this._responseBody = value;
+    }
+    get additionalBindings() {
+        return this._additionalBindings;
+    }
+    set additionalBindings(value) {
+        this._additionalBindings = value;
+    }
+    get pattern() {
+        return this._pattern;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        HttpRule.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            selector: this.selector,
+            get: this.get,
+            put: this.put,
+            post: this.post,
+            delete: this.delete,
+            patch: this.patch,
+            custom: this.custom ? this.custom.toObject() : undefined,
+            body: this.body,
+            responseBody: this.responseBody,
+            additionalBindings: (this.additionalBindings || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            selector: this.selector,
+            get: this.get === null || this.get === undefined ? null : this.get,
+            put: this.put === null || this.put === undefined ? null : this.put,
+            post: this.post === null || this.post === undefined ? null : this.post,
+            delete: this.delete === null || this.delete === undefined ? null : this.delete,
+            patch: this.patch === null || this.patch === undefined ? null : this.patch,
+            custom: this.custom ? this.custom.toProtobufJSON(options) : null,
+            body: this.body,
+            responseBody: this.responseBody,
+            additionalBindings: (this.additionalBindings || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+HttpRule.id = 'google.api.HttpRule';
+(function (HttpRule) {
+    let PatternCase;
+    (function (PatternCase) {
+        PatternCase[PatternCase["none"] = 0] = "none";
+        PatternCase[PatternCase["get"] = 1] = "get";
+        PatternCase[PatternCase["put"] = 2] = "put";
+        PatternCase[PatternCase["post"] = 3] = "post";
+        PatternCase[PatternCase["delete"] = 4] = "delete";
+        PatternCase[PatternCase["patch"] = 5] = "patch";
+        PatternCase[PatternCase["custom"] = 6] = "custom";
+    })(PatternCase = HttpRule.PatternCase || (HttpRule.PatternCase = {}));
+})(HttpRule || (HttpRule = {}));
+/**
+ * Message implementation for google.api.CustomHttpPattern
+ */
+export class CustomHttpPattern {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CustomHttpPattern to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.kind = _value.kind;
+        this.path = _value.path;
+        CustomHttpPattern.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CustomHttpPattern();
+        CustomHttpPattern.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.kind = _instance.kind || '';
+        _instance.path = _instance.path || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.kind = _reader.readString();
+                    break;
+                case 2:
+                    _instance.path = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CustomHttpPattern.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.kind) {
+            _writer.writeString(1, _instance.kind);
+        }
+        if (_instance.path) {
+            _writer.writeString(2, _instance.path);
+        }
+    }
+    get kind() {
+        return this._kind;
+    }
+    set kind(value) {
+        this._kind = value;
+    }
+    get path() {
+        return this._path;
+    }
+    set path(value) {
+        this._path = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CustomHttpPattern.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            kind: this.kind,
+            path: this.path
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            kind: this.kind,
+            path: this.path
+        };
+    }
+}
+CustomHttpPattern.id = 'google.api.CustomHttpPattern';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.pb.js","sourceRoot":"","sources":["../../../../../api/google/api/http.pb.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable */\n/* eslint-disable */\n// @ts-nocheck\n//\n// THIS IS A GENERATED FILE\n// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST\nimport {\n  GrpcMessage,\n  RecursivePartial,\n  ToProtobufJSONOptions\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\n\n/**\n * Message implementation for google.api.Http\n */\nexport class Http implements GrpcMessage {\n  static id = 'google.api.Http';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Http();\n    Http.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: Http) {\n    _instance.rules = _instance.rules || [];\n    _instance.fullyDecodeReservedExpansion =\n      _instance.fullyDecodeReservedExpansion || false;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(_instance: Http, _reader: BinaryReader) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          const messageInitializer1 = new HttpRule();\n          _reader.readMessage(\n            messageInitializer1,\n            HttpRule.deserializeBinaryFromReader\n          );\n          (_instance.rules = _instance.rules || []).push(messageInitializer1);\n          break;\n        case 2:\n          _instance.fullyDecodeReservedExpansion = _reader.readBool();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    Http.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(_instance: Http, _writer: BinaryWriter) {\n    if (_instance.rules && _instance.rules.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.rules as any,\n        HttpRule.serializeBinaryToWriter\n      );\n    }\n    if (_instance.fullyDecodeReservedExpansion) {\n      _writer.writeBool(2, _instance.fullyDecodeReservedExpansion);\n    }\n  }\n\n  private _rules?: HttpRule[];\n  private _fullyDecodeReservedExpansion?: boolean;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of Http to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Http.AsObject>) {\n    _value = _value || {};\n    this.rules = (_value.rules || []).map(m => new HttpRule(m));\n    this.fullyDecodeReservedExpansion = _value.fullyDecodeReservedExpansion;\n    Http.refineValues(this);\n  }\n  get rules(): HttpRule[] | undefined {\n    return this._rules;\n  }\n  set rules(value: HttpRule[] | undefined) {\n    this._rules = value;\n  }\n  get fullyDecodeReservedExpansion(): boolean | undefined {\n    return this._fullyDecodeReservedExpansion;\n  }\n  set fullyDecodeReservedExpansion(value: boolean | undefined) {\n    this._fullyDecodeReservedExpansion = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    Http.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): Http.AsObject {\n    return {\n      rules: (this.rules || []).map(m => m.toObject()),\n      fullyDecodeReservedExpansion: this.fullyDecodeReservedExpansion\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): Http.AsProtobufJSON {\n    return {\n      rules: (this.rules || []).map(m => m.toProtobufJSON(options)),\n      fullyDecodeReservedExpansion: this.fullyDecodeReservedExpansion\n    };\n  }\n}\nexport module Http {\n  /**\n   * Standard JavaScript object representation for Http\n   */\n  export interface AsObject {\n    rules?: HttpRule.AsObject[];\n    fullyDecodeReservedExpansion?: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for Http\n   */\n  export interface AsProtobufJSON {\n    rules?: HttpRule.AsProtobufJSON[] | null;\n    fullyDecodeReservedExpansion?: boolean;\n  }\n}\n\n/**\n * Message implementation for google.api.HttpRule\n */\nexport class HttpRule implements GrpcMessage {\n  static id = 'google.api.HttpRule';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new HttpRule();\n    HttpRule.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: HttpRule) {\n    _instance.selector = _instance.selector || '';\n\n    _instance.body = _instance.body || '';\n    _instance.responseBody = _instance.responseBody || '';\n    _instance.additionalBindings = _instance.additionalBindings || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: HttpRule,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.selector = _reader.readString();\n          break;\n        case 2:\n          _instance.get = _reader.readString();\n          break;\n        case 3:\n          _instance.put = _reader.readString();\n          break;\n        case 4:\n          _instance.post = _reader.readString();\n          break;\n        case 5:\n          _instance.delete = _reader.readString();\n          break;\n        case 6:\n          _instance.patch = _reader.readString();\n          break;\n        case 8:\n          _instance.custom = new CustomHttpPattern();\n          _reader.readMessage(\n            _instance.custom,\n            CustomHttpPattern.deserializeBinaryFromReader\n          );\n          break;\n        case 7:\n          _instance.body = _reader.readString();\n          break;\n        case 12:\n          _instance.responseBody = _reader.readString();\n          break;\n        case 11:\n          const messageInitializer11 = new HttpRule();\n          _reader.readMessage(\n            messageInitializer11,\n            HttpRule.deserializeBinaryFromReader\n          );\n          (_instance.additionalBindings =\n            _instance.additionalBindings || []).push(messageInitializer11);\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    HttpRule.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(_instance: HttpRule, _writer: BinaryWriter) {\n    if (_instance.selector) {\n      _writer.writeString(1, _instance.selector);\n    }\n    if (_instance.get || _instance.get === '') {\n      _writer.writeString(2, _instance.get);\n    }\n    if (_instance.put || _instance.put === '') {\n      _writer.writeString(3, _instance.put);\n    }\n    if (_instance.post || _instance.post === '') {\n      _writer.writeString(4, _instance.post);\n    }\n    if (_instance.delete || _instance.delete === '') {\n      _writer.writeString(5, _instance.delete);\n    }\n    if (_instance.patch || _instance.patch === '') {\n      _writer.writeString(6, _instance.patch);\n    }\n    if (_instance.custom) {\n      _writer.writeMessage(\n        8,\n        _instance.custom as any,\n        CustomHttpPattern.serializeBinaryToWriter\n      );\n    }\n    if (_instance.body) {\n      _writer.writeString(7, _instance.body);\n    }\n    if (_instance.responseBody) {\n      _writer.writeString(12, _instance.responseBody);\n    }\n    if (_instance.additionalBindings && _instance.additionalBindings.length) {\n      _writer.writeRepeatedMessage(\n        11,\n        _instance.additionalBindings as any,\n        HttpRule.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _selector?: string;\n  private _get?: string;\n  private _put?: string;\n  private _post?: string;\n  private _delete?: string;\n  private _patch?: string;\n  private _custom?: CustomHttpPattern;\n  private _body?: string;\n  private _responseBody?: string;\n  private _additionalBindings?: HttpRule[];\n\n  private _pattern: HttpRule.PatternCase = HttpRule.PatternCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of HttpRule to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<HttpRule.AsObject>) {\n    _value = _value || {};\n    this.selector = _value.selector;\n    this.get = _value.get;\n    this.put = _value.put;\n    this.post = _value.post;\n    this.delete = _value.delete;\n    this.patch = _value.patch;\n    this.custom = _value.custom\n      ? new CustomHttpPattern(_value.custom)\n      : undefined;\n    this.body = _value.body;\n    this.responseBody = _value.responseBody;\n    this.additionalBindings = (_value.additionalBindings || []).map(\n      m => new HttpRule(m)\n    );\n    HttpRule.refineValues(this);\n  }\n  get selector(): string | undefined {\n    return this._selector;\n  }\n  set selector(value: string | undefined) {\n    this._selector = value;\n  }\n  get get(): string | undefined {\n    return this._get;\n  }\n  set get(value: string | undefined) {\n    if (value !== undefined && value !== null) {\n      this._put = this._post = this._delete = this._patch = this._custom = undefined;\n      this._pattern = HttpRule.PatternCase.get;\n    }\n    this._get = value;\n  }\n  get put(): string | undefined {\n    return this._put;\n  }\n  set put(value: string | undefined) {\n    if (value !== undefined && value !== null) {\n      this._get = this._post = this._delete = this._patch = this._custom = undefined;\n      this._pattern = HttpRule.PatternCase.put;\n    }\n    this._put = value;\n  }\n  get post(): string | undefined {\n    return this._post;\n  }\n  set post(value: string | undefined) {\n    if (value !== undefined && value !== null) {\n      this._get = this._put = this._delete = this._patch = this._custom = undefined;\n      this._pattern = HttpRule.PatternCase.post;\n    }\n    this._post = value;\n  }\n  get delete(): string | undefined {\n    return this._delete;\n  }\n  set delete(value: string | undefined) {\n    if (value !== undefined && value !== null) {\n      this._get = this._put = this._post = this._patch = this._custom = undefined;\n      this._pattern = HttpRule.PatternCase.delete;\n    }\n    this._delete = value;\n  }\n  get patch(): string | undefined {\n    return this._patch;\n  }\n  set patch(value: string | undefined) {\n    if (value !== undefined && value !== null) {\n      this._get = this._put = this._post = this._delete = this._custom = undefined;\n      this._pattern = HttpRule.PatternCase.patch;\n    }\n    this._patch = value;\n  }\n  get custom(): CustomHttpPattern | undefined {\n    return this._custom;\n  }\n  set custom(value: CustomHttpPattern | undefined) {\n    if (value !== undefined && value !== null) {\n      this._get = this._put = this._post = this._delete = this._patch = undefined;\n      this._pattern = HttpRule.PatternCase.custom;\n    }\n    this._custom = value;\n  }\n  get body(): string | undefined {\n    return this._body;\n  }\n  set body(value: string | undefined) {\n    this._body = value;\n  }\n  get responseBody(): string | undefined {\n    return this._responseBody;\n  }\n  set responseBody(value: string | undefined) {\n    this._responseBody = value;\n  }\n  get additionalBindings(): HttpRule[] | undefined {\n    return this._additionalBindings;\n  }\n  set additionalBindings(value: HttpRule[] | undefined) {\n    this._additionalBindings = value;\n  }\n  get pattern() {\n    return this._pattern;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    HttpRule.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): HttpRule.AsObject {\n    return {\n      selector: this.selector,\n      get: this.get,\n      put: this.put,\n      post: this.post,\n      delete: this.delete,\n      patch: this.patch,\n      custom: this.custom ? this.custom.toObject() : undefined,\n      body: this.body,\n      responseBody: this.responseBody,\n      additionalBindings: (this.additionalBindings || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): HttpRule.AsProtobufJSON {\n    return {\n      selector: this.selector,\n      get: this.get === null || this.get === undefined ? null : this.get,\n      put: this.put === null || this.put === undefined ? null : this.put,\n      post: this.post === null || this.post === undefined ? null : this.post,\n      delete:\n        this.delete === null || this.delete === undefined ? null : this.delete,\n      patch:\n        this.patch === null || this.patch === undefined ? null : this.patch,\n      custom: this.custom ? this.custom.toProtobufJSON(options) : null,\n      body: this.body,\n      responseBody: this.responseBody,\n      additionalBindings: (this.additionalBindings || []).map(m =>\n        m.toProtobufJSON(options)\n      )\n    };\n  }\n}\nexport module HttpRule {\n  /**\n   * Standard JavaScript object representation for HttpRule\n   */\n  export interface AsObject {\n    selector?: string;\n    get?: string;\n    put?: string;\n    post?: string;\n    delete?: string;\n    patch?: string;\n    custom?: CustomHttpPattern.AsObject;\n    body?: string;\n    responseBody?: string;\n    additionalBindings?: HttpRule.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for HttpRule\n   */\n  export interface AsProtobufJSON {\n    selector?: string;\n    get?: string | null;\n    put?: string | null;\n    post?: string | null;\n    delete?: string | null;\n    patch?: string | null;\n    custom?: CustomHttpPattern.AsProtobufJSON | null;\n    body?: string;\n    responseBody?: string;\n    additionalBindings?: HttpRule.AsProtobufJSON[] | null;\n  }\n  export enum PatternCase {\n    none = 0,\n    get = 1,\n    put = 2,\n    post = 3,\n    delete = 4,\n    patch = 5,\n    custom = 6\n  }\n}\n\n/**\n * Message implementation for google.api.CustomHttpPattern\n */\nexport class CustomHttpPattern implements GrpcMessage {\n  static id = 'google.api.CustomHttpPattern';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CustomHttpPattern();\n    CustomHttpPattern.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: CustomHttpPattern) {\n    _instance.kind = _instance.kind || '';\n    _instance.path = _instance.path || '';\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: CustomHttpPattern,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.kind = _reader.readString();\n          break;\n        case 2:\n          _instance.path = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CustomHttpPattern.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: CustomHttpPattern,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.kind) {\n      _writer.writeString(1, _instance.kind);\n    }\n    if (_instance.path) {\n      _writer.writeString(2, _instance.path);\n    }\n  }\n\n  private _kind?: string;\n  private _path?: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CustomHttpPattern to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CustomHttpPattern.AsObject>) {\n    _value = _value || {};\n    this.kind = _value.kind;\n    this.path = _value.path;\n    CustomHttpPattern.refineValues(this);\n  }\n  get kind(): string | undefined {\n    return this._kind;\n  }\n  set kind(value: string | undefined) {\n    this._kind = value;\n  }\n  get path(): string | undefined {\n    return this._path;\n  }\n  set path(value: string | undefined) {\n    this._path = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CustomHttpPattern.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): CustomHttpPattern.AsObject {\n    return {\n      kind: this.kind,\n      path: this.path\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): CustomHttpPattern.AsProtobufJSON {\n    return {\n      kind: this.kind,\n      path: this.path\n    };\n  }\n}\nexport module CustomHttpPattern {\n  /**\n   * Standard JavaScript object representation for CustomHttpPattern\n   */\n  export interface AsObject {\n    kind?: string;\n    path?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for CustomHttpPattern\n   */\n  export interface AsProtobufJSON {\n    kind?: string;\n    path?: string;\n  }\n}\n"]}