@furo/open-models 1.6.0 → 1.6.2

package/dist/protoc-gen-open-models/google/api/HttpRule.js

@@ -1,502 +0,0 @@
-// Code generated by furo protoc-gen-open-models. DO NOT EDIT.
-// protoc-gen-open-models version: ????
-import { ARRAY, FieldNode, Registry, STRING, } from '@furo/open-models/dist/index';
-import { CustomHttpPattern as GoogleApiCustomHttpPattern, } from './CustomHttpPattern.js';
-/**
- * HttpRule
- *  # gRPC Transcoding
- *
- *  gRPC Transcoding is a feature for mapping between a gRPC method and one or
- *  more HTTP REST endpoints. It allows developers to build a single API service
- *  that supports both gRPC APIs and REST APIs. Many systems, including [Google
- *  APIs](https://github.com/googleapis/googleapis),
- *  [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC
- *  Gateway](https://github.com/grpc-ecosystem/grpc-gateway),
- *  and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature
- *  and use it for large scale production services.
- *
- *  `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies
- *  how different portions of the gRPC request message are mapped to the URL
- *  path, URL query parameters, and HTTP request body. It also controls how the
- *  gRPC response message is mapped to the HTTP response body. `HttpRule` is
- *  typically specified as an `google.api.http` annotation on the gRPC method.
- *
- *  Each mapping specifies a URL path template and an HTTP method. The path
- *  template may refer to one or more fields in the gRPC request message, as long
- *  as each field is a non-repeated field with a primitive (non-message) type.
- *  The path template controls how fields of the request message are mapped to
- *  the URL path.
- *
- *  Example:
- *
- *      service Messaging {
- *        rpc GetMessage(GetMessageRequest) returns (Message) {
- *          option (google.api.http) = {
- *              get: "/v1/{name=messages/*}"
- *          };
- *        }
- *      }
- *      message GetMessageRequest {
- *        string name = 1; // Mapped to URL path.
- *      }
- *      message Message {
- *        string text = 1; // The resource content.
- *      }
- *
- *  This enables an HTTP REST to gRPC mapping as below:
- *
- *  HTTP | gRPC
- *  -----|-----
- *  `GET /v1/messages/123456`  | `GetMessage(name: "messages/123456")`
- *
- *  Any fields in the request message which are not bound by the path template
- *  automatically become HTTP query parameters if there is no HTTP request body.
- *  For example:
- *
- *      service Messaging {
- *        rpc GetMessage(GetMessageRequest) returns (Message) {
- *          option (google.api.http) = {
- *              get:"/v1/messages/{message_id}"
- *          };
- *        }
- *      }
- *      message GetMessageRequest {
- *        message SubMessage {
- *          string subfield = 1;
- *        }
- *        string message_id = 1; // Mapped to URL path.
- *        int64 revision = 2;    // Mapped to URL query parameter `revision`.
- *        SubMessage sub = 3;    // Mapped to URL query parameter `sub.subfield`.
- *      }
- *
- *  This enables a HTTP JSON to RPC mapping as below:
- *
- *  HTTP | gRPC
- *  -----|-----
- *  `GET /v1/messages/123456?revision=2&sub.subfield=foo` |
- *  `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield:
- *  "foo"))`
- *
- *  Note that fields which are mapped to URL query parameters must have a
- *  primitive type or a repeated primitive type or a non-repeated message type.
- *  In the case of a repeated type, the parameter can be repeated in the URL
- *  as `...?param=A&param=B`. In the case of a message type, each field of the
- *  message is mapped to a separate parameter, such as
- *  `...?foo.a=A&foo.b=B&foo.c=C`.
- *
- *  For HTTP methods that allow a request body, the `body` field
- *  specifies the mapping. Consider a REST update method on the
- *  message resource collection:
- *
- *      service Messaging {
- *        rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
- *          option (google.api.http) = {
- *            patch: "/v1/messages/{message_id}"
- *            body: "message"
- *          };
- *        }
- *      }
- *      message UpdateMessageRequest {
- *        string message_id = 1; // mapped to the URL
- *        Message message = 2;   // mapped to the body
- *      }
- *
- *  The following HTTP JSON to RPC mapping is enabled, where the
- *  representation of the JSON in the request body is determined by
- *  protos JSON encoding:
- *
- *  HTTP | gRPC
- *  -----|-----
- *  `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
- *  "123456" message { text: "Hi!" })`
- *
- *  The special name `*` can be used in the body mapping to define that
- *  every field not bound by the path template should be mapped to the
- *  request body.  This enables the following alternative definition of
- *  the update method:
- *
- *      service Messaging {
- *        rpc UpdateMessage(Message) returns (Message) {
- *          option (google.api.http) = {
- *            patch: "/v1/messages/{message_id}"
- *            body: "*"
- *          };
- *        }
- *      }
- *      message Message {
- *        string message_id = 1;
- *        string text = 2;
- *      }
- *
- *
- *  The following HTTP JSON to RPC mapping is enabled:
- *
- *  HTTP | gRPC
- *  -----|-----
- *  `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
- *  "123456" text: "Hi!")`
- *
- *  Note that when using `*` in the body mapping, it is not possible to
- *  have HTTP parameters, as all fields not bound by the path end in
- *  the body. This makes this option more rarely used in practice when
- *  defining REST APIs. The common usage of `*` is in custom methods
- *  which don't use the URL at all for transferring data.
- *
- *  It is possible to define multiple HTTP methods for one RPC by using
- *  the `additional_bindings` option. Example:
- *
- *      service Messaging {
- *        rpc GetMessage(GetMessageRequest) returns (Message) {
- *          option (google.api.http) = {
- *            get: "/v1/messages/{message_id}"
- *            additional_bindings {
- *              get: "/v1/users/{user_id}/messages/{message_id}"
- *            }
- *          };
- *        }
- *      }
- *      message GetMessageRequest {
- *        string message_id = 1;
- *        string user_id = 2;
- *      }
- *
- *  This enables the following two alternative HTTP JSON to RPC mappings:
- *
- *  HTTP | gRPC
- *  -----|-----
- *  `GET /v1/messages/123456` | `GetMessage(message_id: "123456")`
- *  `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id:
- *  "123456")`
- *
- *  ## Rules for HTTP mapping
- *
- *  1. Leaf request fields (recursive expansion nested messages in the request
- *     message) are classified into three categories:
- *     - Fields referred by the path template. They are passed via the URL path.
- *     - Fields referred by the [HttpRule.body][google.api.HttpRule.body]. They
- *     are passed via the HTTP
- *       request body.
- *     - All other fields are passed via the URL query parameters, and the
- *       parameter name is the field path in the request message. A repeated
- *       field can be represented as multiple query parameters under the same
- *       name.
- *   2. If [HttpRule.body][google.api.HttpRule.body] is "*", there is no URL
- *   query parameter, all fields
- *      are passed via URL path and HTTP request body.
- *   3. If [HttpRule.body][google.api.HttpRule.body] is omitted, there is no HTTP
- *   request body, all
- *      fields are passed via URL path and URL query parameters.
- *
- *  ### Path template syntax
- *
- *      Template = "/" Segments [ Verb ] ;
- *      Segments = Segment { "/" Segment } ;
- *      Segment  = "*" | "**" | LITERAL | Variable ;
- *      Variable = "{" FieldPath [ "=" Segments ] "}" ;
- *      FieldPath = IDENT { "." IDENT } ;
- *      Verb     = ":" LITERAL ;
- *
- *  The syntax `*` matches a single URL path segment. The syntax `**` matches
- *  zero or more URL path segments, which must be the last part of the URL path
- *  except the `Verb`.
- *
- *  The syntax `Variable` matches part of the URL path as specified by its
- *  template. A variable template must not contain other variables. If a variable
- *  matches a single path segment, its template may be omitted, e.g. `{var}`
- *  is equivalent to `{var=*}`.
- *
- *  The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL`
- *  contains any reserved character, such characters should be percent-encoded
- *  before the matching.
- *
- *  If a variable contains exactly one path segment, such as `"{var}"` or
- *  `"{var=*}"`, when such a variable is expanded into a URL path on the client
- *  side, all characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The
- *  server side does the reverse decoding. Such variables show up in the
- *  [Discovery
- *  Document](https://developers.google.com/discovery/v1/reference/apis) as
- *  `{var}`.
- *
- *  If a variable contains multiple path segments, such as `"{var=foo/*}"`
- *  or `"{var=**}"`, when such a variable is expanded into a URL path on the
- *  client side, all characters except `[-_.~/0-9a-zA-Z]` are percent-encoded.
- *  The server side does the reverse decoding, except "%2F" and "%2f" are left
- *  unchanged. Such variables show up in the
- *  [Discovery
- *  Document](https://developers.google.com/discovery/v1/reference/apis) as
- *  `{+var}`.
- *
- *  ## Using gRPC API Service Configuration
- *
- *  gRPC API Service Configuration (service config) is a configuration language
- *  for configuring a gRPC service to become a user-facing product. The
- *  service config is simply the YAML representation of the `google.api.Service`
- *  proto message.
- *
- *  As an alternative to annotating your proto file, you can configure gRPC
- *  transcoding in your service config YAML files. You do this by specifying a
- *  `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same
- *  effect as the proto annotation. This can be particularly useful if you
- *  have a proto that is reused in multiple services. Note that any transcoding
- *  specified in the service config will override any matching transcoding
- *  configuration in the proto.
- *
- *  Example:
- *
- *      http:
- *        rules:
- *          # Selects a gRPC method and applies HttpRule to it.
- *          - selector: example.v1.Messaging.GetMessage
- *            get: /v1/messages/{message_id}/{sub.subfield}
- *
- *  ## Special notes
- *
- *  When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the
- *  proto to JSON conversion must follow the [proto3
- *  specification](https://developers.google.com/protocol-buffers/docs/proto3#json).
- *
- *  While the single segment variable follows the semantics of
- *  [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String
- *  Expansion, the multi segment variable **does not** follow RFC 6570 Section
- *  3.2.3 Reserved Expansion. The reason is that the Reserved Expansion
- *  does not expand special characters like `?` and `#`, which would lead
- *  to invalid URLs. As the result, gRPC Transcoding uses a custom encoding
- *  for multi segment variables.
- *
- *  The path variables **must not** refer to any repeated or mapped field,
- *  because client libraries are not capable of handling such variable expansion.
- *
- *  The path variables **must not** capture the leading "/" character. The reason
- *  is that the most common use case "{var}" does not capture the leading "/"
- *  character. For consistency, all path variables must share the same behavior.
- *
- *  Repeated message fields must not be mapped to URL query parameters, because
- *  no client library can support such complicated mapping.
- *
- *  If an API needs to use a JSON array for request or response body, it can map
- *  the request or response body to a repeated field. However, some gRPC
- *  Transcoding implementations may not support this feature.
- */
-export class HttpRule extends FieldNode {
-    constructor(initData, parent, parentAttributeName) {
-        super(undefined, parent, parentAttributeName);
-        this.__meta.typeName = 'google.api.HttpRule';
-        this.__meta.nodeFields = [
-            {
-                fieldName: 'selector',
-                protoName: 'selector',
-                FieldConstructor: STRING,
-                constraints: {},
-            },
-            {
-                fieldName: 'get',
-                protoName: 'get',
-                FieldConstructor: STRING,
-                constraints: {},
-            },
-            {
-                fieldName: 'put',
-                protoName: 'put',
-                FieldConstructor: STRING,
-                constraints: {},
-            },
-            {
-                fieldName: 'post',
-                protoName: 'post',
-                FieldConstructor: STRING,
-                constraints: {},
-            },
-            {
-                fieldName: 'delete',
-                protoName: 'delete',
-                FieldConstructor: STRING,
-                constraints: {},
-            },
-            {
-                fieldName: 'patch',
-                protoName: 'patch',
-                FieldConstructor: STRING,
-                constraints: {},
-            },
-            {
-                fieldName: 'custom',
-                protoName: 'custom',
-                FieldConstructor: GoogleApiCustomHttpPattern,
-                constraints: {},
-            },
-            {
-                fieldName: 'body',
-                protoName: 'body',
-                FieldConstructor: STRING,
-                constraints: {},
-            },
-            {
-                fieldName: 'responseBody',
-                protoName: 'response_body',
-                FieldConstructor: STRING,
-                constraints: {},
-            },
-            {
-                fieldName: 'additionalBindings',
-                protoName: 'additional_bindings',
-                FieldConstructor: HttpRule,
-                constraints: {},
-            },
-        ];
-        // Initialize the fields
-        //  Selects a method to which this rule applies.
-        //
-        //  Refer to [selector][google.api.DocumentationRule.selector] for syntax
-        //  details.
-        this._selector = new STRING(undefined, this, 'selector');
-        //  Maps to HTTP GET. Used for listing and getting information about
-        //  resources.
-        this._get = new STRING(undefined, this, 'get');
-        //  Maps to HTTP PUT. Used for replacing a resource.
-        this._put = new STRING(undefined, this, 'put');
-        //  Maps to HTTP POST. Used for creating a resource or performing an action.
-        this._post = new STRING(undefined, this, 'post');
-        //  Maps to HTTP DELETE. Used for deleting a resource.
-        this._delete = new STRING(undefined, this, 'delete');
-        //  Maps to HTTP PATCH. Used for updating a resource.
-        this._patch = new STRING(undefined, this, 'patch');
-        //  The custom pattern is used for specifying an HTTP method that is not
-        //  included in the `pattern` field, such as HEAD, or "*" to leave the
-        //  HTTP method unspecified for this rule. The wild-card rule is useful
-        //  for services that provide content to Web (HTML) clients.
-        this._custom = new GoogleApiCustomHttpPattern(undefined, this, 'custom');
-        //  The name of the request field whose value is mapped to the HTTP request
-        //  body, or `*` for mapping all request fields not captured by the path
-        //  pattern to the HTTP body, or omitted for not having any HTTP request body.
-        //
-        //  NOTE: the referred field must be present at the top-level of the request
-        //  message type.
-        this._body = new STRING(undefined, this, 'body');
-        //  Optional. The name of the response field whose value is mapped to the HTTP
-        //  response body. When omitted, the entire response message will be used
-        //  as the HTTP response body.
-        //
-        //  NOTE: The referred field must be present at the top-level of the response
-        //  message type.
-        this._responseBody = new STRING(undefined, this, 'responseBody');
-        //  Additional HTTP bindings for the selector. Nested bindings must
-        //  not contain an `additional_bindings` field themselves (that is,
-        //  the nesting may only be one level deep).
-        this._additionalBindings = new ARRAY(undefined, this, 'additionalBindings');
-        // Set required fields
-        [].forEach(fieldName => {
-            this[fieldName].__meta.required = true;
-        });
-        // Default values from openAPI annotations
-        this.__defaultValues = {};
-        // Initialize the fields with init data
-        if (initData !== undefined) {
-            this.__fromLiteral({ ...this.__defaultValues, ...initData });
-        }
-        else {
-            this.__fromLiteral(this.__defaultValues);
-        }
-        // Set readonly fields after the init, so child nodes are readonly too
-        [].forEach(fieldName => {
-            this[fieldName].__readonly = true;
-        });
-        this.__meta.isPristine = true;
-    }
-    //  Selects a method to which this rule applies.
-    //
-    //  Refer to [selector][google.api.DocumentationRule.selector] for syntax
-    //  details.
-    get selector() {
-        return this._selector;
-    }
-    set selector(v) {
-        this.__PrimitivesSetter(this._selector, v);
-    }
-    //  Maps to HTTP GET. Used for listing and getting information about
-    //  resources.
-    get get() {
-        return this._get;
-    }
-    set get(v) {
-        this.__PrimitivesSetter(this._get, v);
-    }
-    //  Maps to HTTP PUT. Used for replacing a resource.
-    get put() {
-        return this._put;
-    }
-    set put(v) {
-        this.__PrimitivesSetter(this._put, v);
-    }
-    //  Maps to HTTP POST. Used for creating a resource or performing an action.
-    get post() {
-        return this._post;
-    }
-    set post(v) {
-        this.__PrimitivesSetter(this._post, v);
-    }
-    //  Maps to HTTP DELETE. Used for deleting a resource.
-    get delete() {
-        return this._delete;
-    }
-    set delete(v) {
-        this.__PrimitivesSetter(this._delete, v);
-    }
-    //  Maps to HTTP PATCH. Used for updating a resource.
-    get patch() {
-        return this._patch;
-    }
-    set patch(v) {
-        this.__PrimitivesSetter(this._patch, v);
-    }
-    //  The custom pattern is used for specifying an HTTP method that is not
-    //  included in the `pattern` field, such as HEAD, or "*" to leave the
-    //  HTTP method unspecified for this rule. The wild-card rule is useful
-    //  for services that provide content to Web (HTML) clients.
-    get custom() {
-        return this._custom;
-    }
-    set custom(v) {
-        this.__TypeSetter(this._custom, v);
-    }
-    //  The name of the request field whose value is mapped to the HTTP request
-    //  body, or `*` for mapping all request fields not captured by the path
-    //  pattern to the HTTP body, or omitted for not having any HTTP request body.
-    //
-    //  NOTE: the referred field must be present at the top-level of the request
-    //  message type.
-    get body() {
-        return this._body;
-    }
-    set body(v) {
-        this.__PrimitivesSetter(this._body, v);
-    }
-    //  Optional. The name of the response field whose value is mapped to the HTTP
-    //  response body. When omitted, the entire response message will be used
-    //  as the HTTP response body.
-    //
-    //  NOTE: The referred field must be present at the top-level of the response
-    //  message type.
-    get responseBody() {
-        return this._responseBody;
-    }
-    set responseBody(v) {
-        this.__PrimitivesSetter(this._responseBody, v);
-    }
-    //  Additional HTTP bindings for the selector. Nested bindings must
-    //  not contain an `additional_bindings` field themselves (that is,
-    //  the nesting may only be one level deep).
-    get additionalBindings() {
-        return this._additionalBindings;
-    }
-    set additionalBindings(v) {
-        this.__TypeSetter(this._additionalBindings, v);
-    }
-    fromLiteral(data) {
-        super.__fromLiteral(data);
-    }
-    toLiteral() {
-        return super.__toLiteral();
-    }
-}
-Registry.register('google.api.HttpRule', HttpRule);
-//# sourceMappingURL=HttpRule.js.map

package/dist/protoc-gen-open-models/google/api/HttpRule.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HttpRule.js","sourceRoot":"","sources":["../../../../protoc-gen-open-models/google/api/HttpRule.ts"],"names":[],"mappings":"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","sourcesContent":["// Code generated by furo protoc-gen-open-models. DO NOT EDIT.\n// protoc-gen-open-models version: ????\n\nimport {\n  ARRAY,\n  FieldNode,\n  Registry,\n  STRING,\n} from '@furo/open-models/dist/index';\nimport {\n  CustomHttpPattern as GoogleApiCustomHttpPattern,\n  ICustomHttpPattern as IGoogleApiCustomHttpPattern,\n  TCustomHttpPattern as TGoogleApiCustomHttpPattern,\n} from './CustomHttpPattern';\n\n/**\n * @interface IHttpRule\n *  # gRPC Transcoding\n *\n *  gRPC Transcoding is a feature for mapping between a gRPC method and one or\n *  more HTTP REST endpoints. It allows developers to build a single API service\n *  that supports both gRPC APIs and REST APIs. Many systems, including [Google\n *  APIs](https://github.com/googleapis/googleapis),\n *  [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC\n *  Gateway](https://github.com/grpc-ecosystem/grpc-gateway),\n *  and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature\n *  and use it for large scale production services.\n *\n *  `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies\n *  how different portions of the gRPC request message are mapped to the URL\n *  path, URL query parameters, and HTTP request body. It also controls how the\n *  gRPC response message is mapped to the HTTP response body. `HttpRule` is\n *  typically specified as an `google.api.http` annotation on the gRPC method.\n *\n *  Each mapping specifies a URL path template and an HTTP method. The path\n *  template may refer to one or more fields in the gRPC request message, as long\n *  as each field is a non-repeated field with a primitive (non-message) type.\n *  The path template controls how fields of the request message are mapped to\n *  the URL path.\n *\n *  Example:\n *\n *      service Messaging {\n *        rpc GetMessage(GetMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *              get: \"/v1/{name=messages/*}\"\n *          };\n *        }\n *      }\n *      message GetMessageRequest {\n *        string name = 1; // Mapped to URL path.\n *      }\n *      message Message {\n *        string text = 1; // The resource content.\n *      }\n *\n *  This enables an HTTP REST to gRPC mapping as below:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `GET /v1/messages/123456`  | `GetMessage(name: \"messages/123456\")`\n *\n *  Any fields in the request message which are not bound by the path template\n *  automatically become HTTP query parameters if there is no HTTP request body.\n *  For example:\n *\n *      service Messaging {\n *        rpc GetMessage(GetMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *              get:\"/v1/messages/{message_id}\"\n *          };\n *        }\n *      }\n *      message GetMessageRequest {\n *        message SubMessage {\n *          string subfield = 1;\n *        }\n *        string message_id = 1; // Mapped to URL path.\n *        int64 revision = 2;    // Mapped to URL query parameter `revision`.\n *        SubMessage sub = 3;    // Mapped to URL query parameter `sub.subfield`.\n *      }\n *\n *  This enables a HTTP JSON to RPC mapping as below:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `GET /v1/messages/123456?revision=2&sub.subfield=foo` |\n *  `GetMessage(message_id: \"123456\" revision: 2 sub: SubMessage(subfield:\n *  \"foo\"))`\n *\n *  Note that fields which are mapped to URL query parameters must have a\n *  primitive type or a repeated primitive type or a non-repeated message type.\n *  In the case of a repeated type, the parameter can be repeated in the URL\n *  as `...?param=A&param=B`. In the case of a message type, each field of the\n *  message is mapped to a separate parameter, such as\n *  `...?foo.a=A&foo.b=B&foo.c=C`.\n *\n *  For HTTP methods that allow a request body, the `body` field\n *  specifies the mapping. Consider a REST update method on the\n *  message resource collection:\n *\n *      service Messaging {\n *        rpc UpdateMessage(UpdateMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *            patch: \"/v1/messages/{message_id}\"\n *            body: \"message\"\n *          };\n *        }\n *      }\n *      message UpdateMessageRequest {\n *        string message_id = 1; // mapped to the URL\n *        Message message = 2;   // mapped to the body\n *      }\n *\n *  The following HTTP JSON to RPC mapping is enabled, where the\n *  representation of the JSON in the request body is determined by\n *  protos JSON encoding:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `PATCH /v1/messages/123456 { \"text\": \"Hi!\" }` | `UpdateMessage(message_id:\n *  \"123456\" message { text: \"Hi!\" })`\n *\n *  The special name `*` can be used in the body mapping to define that\n *  every field not bound by the path template should be mapped to the\n *  request body.  This enables the following alternative definition of\n *  the update method:\n *\n *      service Messaging {\n *        rpc UpdateMessage(Message) returns (Message) {\n *          option (google.api.http) = {\n *            patch: \"/v1/messages/{message_id}\"\n *            body: \"*\"\n *          };\n *        }\n *      }\n *      message Message {\n *        string message_id = 1;\n *        string text = 2;\n *      }\n *\n *\n *  The following HTTP JSON to RPC mapping is enabled:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `PATCH /v1/messages/123456 { \"text\": \"Hi!\" }` | `UpdateMessage(message_id:\n *  \"123456\" text: \"Hi!\")`\n *\n *  Note that when using `*` in the body mapping, it is not possible to\n *  have HTTP parameters, as all fields not bound by the path end in\n *  the body. This makes this option more rarely used in practice when\n *  defining REST APIs. The common usage of `*` is in custom methods\n *  which don't use the URL at all for transferring data.\n *\n *  It is possible to define multiple HTTP methods for one RPC by using\n *  the `additional_bindings` option. Example:\n *\n *      service Messaging {\n *        rpc GetMessage(GetMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *            get: \"/v1/messages/{message_id}\"\n *            additional_bindings {\n *              get: \"/v1/users/{user_id}/messages/{message_id}\"\n *            }\n *          };\n *        }\n *      }\n *      message GetMessageRequest {\n *        string message_id = 1;\n *        string user_id = 2;\n *      }\n *\n *  This enables the following two alternative HTTP JSON to RPC mappings:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `GET /v1/messages/123456` | `GetMessage(message_id: \"123456\")`\n *  `GET /v1/users/me/messages/123456` | `GetMessage(user_id: \"me\" message_id:\n *  \"123456\")`\n *\n *  ## Rules for HTTP mapping\n *\n *  1. Leaf request fields (recursive expansion nested messages in the request\n *     message) are classified into three categories:\n *     - Fields referred by the path template. They are passed via the URL path.\n *     - Fields referred by the [HttpRule.body][google.api.HttpRule.body]. They\n *     are passed via the HTTP\n *       request body.\n *     - All other fields are passed via the URL query parameters, and the\n *       parameter name is the field path in the request message. A repeated\n *       field can be represented as multiple query parameters under the same\n *       name.\n *   2. If [HttpRule.body][google.api.HttpRule.body] is \"*\", there is no URL\n *   query parameter, all fields\n *      are passed via URL path and HTTP request body.\n *   3. If [HttpRule.body][google.api.HttpRule.body] is omitted, there is no HTTP\n *   request body, all\n *      fields are passed via URL path and URL query parameters.\n *\n *  ### Path template syntax\n *\n *      Template = \"/\" Segments [ Verb ] ;\n *      Segments = Segment { \"/\" Segment } ;\n *      Segment  = \"*\" | \"**\" | LITERAL | Variable ;\n *      Variable = \"{\" FieldPath [ \"=\" Segments ] \"}\" ;\n *      FieldPath = IDENT { \".\" IDENT } ;\n *      Verb     = \":\" LITERAL ;\n *\n *  The syntax `*` matches a single URL path segment. The syntax `**` matches\n *  zero or more URL path segments, which must be the last part of the URL path\n *  except the `Verb`.\n *\n *  The syntax `Variable` matches part of the URL path as specified by its\n *  template. A variable template must not contain other variables. If a variable\n *  matches a single path segment, its template may be omitted, e.g. `{var}`\n *  is equivalent to `{var=*}`.\n *\n *  The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL`\n *  contains any reserved character, such characters should be percent-encoded\n *  before the matching.\n *\n *  If a variable contains exactly one path segment, such as `\"{var}\"` or\n *  `\"{var=*}\"`, when such a variable is expanded into a URL path on the client\n *  side, all characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The\n *  server side does the reverse decoding. Such variables show up in the\n *  [Discovery\n *  Document](https://developers.google.com/discovery/v1/reference/apis) as\n *  `{var}`.\n *\n *  If a variable contains multiple path segments, such as `\"{var=foo/*}\"`\n *  or `\"{var=**}\"`, when such a variable is expanded into a URL path on the\n *  client side, all characters except `[-_.~/0-9a-zA-Z]` are percent-encoded.\n *  The server side does the reverse decoding, except \"%2F\" and \"%2f\" are left\n *  unchanged. Such variables show up in the\n *  [Discovery\n *  Document](https://developers.google.com/discovery/v1/reference/apis) as\n *  `{+var}`.\n *\n *  ## Using gRPC API Service Configuration\n *\n *  gRPC API Service Configuration (service config) is a configuration language\n *  for configuring a gRPC service to become a user-facing product. The\n *  service config is simply the YAML representation of the `google.api.Service`\n *  proto message.\n *\n *  As an alternative to annotating your proto file, you can configure gRPC\n *  transcoding in your service config YAML files. You do this by specifying a\n *  `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same\n *  effect as the proto annotation. This can be particularly useful if you\n *  have a proto that is reused in multiple services. Note that any transcoding\n *  specified in the service config will override any matching transcoding\n *  configuration in the proto.\n *\n *  Example:\n *\n *      http:\n *        rules:\n *          # Selects a gRPC method and applies HttpRule to it.\n *          - selector: example.v1.Messaging.GetMessage\n *            get: /v1/messages/{message_id}/{sub.subfield}\n *\n *  ## Special notes\n *\n *  When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the\n *  proto to JSON conversion must follow the [proto3\n *  specification](https://developers.google.com/protocol-buffers/docs/proto3#json).\n *\n *  While the single segment variable follows the semantics of\n *  [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String\n *  Expansion, the multi segment variable **does not** follow RFC 6570 Section\n *  3.2.3 Reserved Expansion. The reason is that the Reserved Expansion\n *  does not expand special characters like `?` and `#`, which would lead\n *  to invalid URLs. As the result, gRPC Transcoding uses a custom encoding\n *  for multi segment variables.\n *\n *  The path variables **must not** refer to any repeated or mapped field,\n *  because client libraries are not capable of handling such variable expansion.\n *\n *  The path variables **must not** capture the leading \"/\" character. The reason\n *  is that the most common use case \"{var}\" does not capture the leading \"/\"\n *  character. For consistency, all path variables must share the same behavior.\n *\n *  Repeated message fields must not be mapped to URL query parameters, because\n *  no client library can support such complicated mapping.\n *\n *  If an API needs to use a JSON array for request or response body, it can map\n *  the request or response body to a repeated field. However, some gRPC\n *  Transcoding implementations may not support this feature.\n */\nexport interface IHttpRule {\n  /**\n   *  Selects a method to which this rule applies.\n   *\n   *  Refer to [selector][google.api.DocumentationRule.selector] for syntax\n   *  details.\n   */\n  selector?: string;\n  /**\n   *  Maps to HTTP GET. Used for listing and getting information about\n   *  resources.\n   */\n  get?: string;\n  /**\n   *  Maps to HTTP PUT. Used for replacing a resource.\n   */\n  put?: string;\n  /**\n   *  Maps to HTTP POST. Used for creating a resource or performing an action.\n   */\n  post?: string;\n  /**\n   *  Maps to HTTP DELETE. Used for deleting a resource.\n   */\n  delete?: string;\n  /**\n   *  Maps to HTTP PATCH. Used for updating a resource.\n   */\n  patch?: string;\n  /**\n   *  The custom pattern is used for specifying an HTTP method that is not\n   *  included in the `pattern` field, such as HEAD, or \"*\" to leave the\n   *  HTTP method unspecified for this rule. The wild-card rule is useful\n   *  for services that provide content to Web (HTML) clients.\n   */\n  custom?: IGoogleApiCustomHttpPattern;\n  /**\n   *  The name of the request field whose value is mapped to the HTTP request\n   *  body, or `*` for mapping all request fields not captured by the path\n   *  pattern to the HTTP body, or omitted for not having any HTTP request body.\n   *\n   *  NOTE: the referred field must be present at the top-level of the request\n   *  message type.\n   */\n  body?: string;\n  /**\n   *  Optional. The name of the response field whose value is mapped to the HTTP\n   *  response body. When omitted, the entire response message will be used\n   *  as the HTTP response body.\n   *\n   *  NOTE: The referred field must be present at the top-level of the response\n   *  message type.\n   */\n  responseBody?: string;\n  /**\n   *  Additional HTTP bindings for the selector. Nested bindings must\n   *  not contain an `additional_bindings` field themselves (that is,\n   *  the nesting may only be one level deep).\n   */\n  additionalBindings?: IHttpRule[];\n}\n\n/**\n * @interface THttpRule\n *  # gRPC Transcoding\n *\n *  gRPC Transcoding is a feature for mapping between a gRPC method and one or\n *  more HTTP REST endpoints. It allows developers to build a single API service\n *  that supports both gRPC APIs and REST APIs. Many systems, including [Google\n *  APIs](https://github.com/googleapis/googleapis),\n *  [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC\n *  Gateway](https://github.com/grpc-ecosystem/grpc-gateway),\n *  and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature\n *  and use it for large scale production services.\n *\n *  `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies\n *  how different portions of the gRPC request message are mapped to the URL\n *  path, URL query parameters, and HTTP request body. It also controls how the\n *  gRPC response message is mapped to the HTTP response body. `HttpRule` is\n *  typically specified as an `google.api.http` annotation on the gRPC method.\n *\n *  Each mapping specifies a URL path template and an HTTP method. The path\n *  template may refer to one or more fields in the gRPC request message, as long\n *  as each field is a non-repeated field with a primitive (non-message) type.\n *  The path template controls how fields of the request message are mapped to\n *  the URL path.\n *\n *  Example:\n *\n *      service Messaging {\n *        rpc GetMessage(GetMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *              get: \"/v1/{name=messages/*}\"\n *          };\n *        }\n *      }\n *      message GetMessageRequest {\n *        string name = 1; // Mapped to URL path.\n *      }\n *      message Message {\n *        string text = 1; // The resource content.\n *      }\n *\n *  This enables an HTTP REST to gRPC mapping as below:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `GET /v1/messages/123456`  | `GetMessage(name: \"messages/123456\")`\n *\n *  Any fields in the request message which are not bound by the path template\n *  automatically become HTTP query parameters if there is no HTTP request body.\n *  For example:\n *\n *      service Messaging {\n *        rpc GetMessage(GetMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *              get:\"/v1/messages/{message_id}\"\n *          };\n *        }\n *      }\n *      message GetMessageRequest {\n *        message SubMessage {\n *          string subfield = 1;\n *        }\n *        string message_id = 1; // Mapped to URL path.\n *        int64 revision = 2;    // Mapped to URL query parameter `revision`.\n *        SubMessage sub = 3;    // Mapped to URL query parameter `sub.subfield`.\n *      }\n *\n *  This enables a HTTP JSON to RPC mapping as below:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `GET /v1/messages/123456?revision=2&sub.subfield=foo` |\n *  `GetMessage(message_id: \"123456\" revision: 2 sub: SubMessage(subfield:\n *  \"foo\"))`\n *\n *  Note that fields which are mapped to URL query parameters must have a\n *  primitive type or a repeated primitive type or a non-repeated message type.\n *  In the case of a repeated type, the parameter can be repeated in the URL\n *  as `...?param=A&param=B`. In the case of a message type, each field of the\n *  message is mapped to a separate parameter, such as\n *  `...?foo.a=A&foo.b=B&foo.c=C`.\n *\n *  For HTTP methods that allow a request body, the `body` field\n *  specifies the mapping. Consider a REST update method on the\n *  message resource collection:\n *\n *      service Messaging {\n *        rpc UpdateMessage(UpdateMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *            patch: \"/v1/messages/{message_id}\"\n *            body: \"message\"\n *          };\n *        }\n *      }\n *      message UpdateMessageRequest {\n *        string message_id = 1; // mapped to the URL\n *        Message message = 2;   // mapped to the body\n *      }\n *\n *  The following HTTP JSON to RPC mapping is enabled, where the\n *  representation of the JSON in the request body is determined by\n *  protos JSON encoding:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `PATCH /v1/messages/123456 { \"text\": \"Hi!\" }` | `UpdateMessage(message_id:\n *  \"123456\" message { text: \"Hi!\" })`\n *\n *  The special name `*` can be used in the body mapping to define that\n *  every field not bound by the path template should be mapped to the\n *  request body.  This enables the following alternative definition of\n *  the update method:\n *\n *      service Messaging {\n *        rpc UpdateMessage(Message) returns (Message) {\n *          option (google.api.http) = {\n *            patch: \"/v1/messages/{message_id}\"\n *            body: \"*\"\n *          };\n *        }\n *      }\n *      message Message {\n *        string message_id = 1;\n *        string text = 2;\n *      }\n *\n *\n *  The following HTTP JSON to RPC mapping is enabled:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `PATCH /v1/messages/123456 { \"text\": \"Hi!\" }` | `UpdateMessage(message_id:\n *  \"123456\" text: \"Hi!\")`\n *\n *  Note that when using `*` in the body mapping, it is not possible to\n *  have HTTP parameters, as all fields not bound by the path end in\n *  the body. This makes this option more rarely used in practice when\n *  defining REST APIs. The common usage of `*` is in custom methods\n *  which don't use the URL at all for transferring data.\n *\n *  It is possible to define multiple HTTP methods for one RPC by using\n *  the `additional_bindings` option. Example:\n *\n *      service Messaging {\n *        rpc GetMessage(GetMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *            get: \"/v1/messages/{message_id}\"\n *            additional_bindings {\n *              get: \"/v1/users/{user_id}/messages/{message_id}\"\n *            }\n *          };\n *        }\n *      }\n *      message GetMessageRequest {\n *        string message_id = 1;\n *        string user_id = 2;\n *      }\n *\n *  This enables the following two alternative HTTP JSON to RPC mappings:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `GET /v1/messages/123456` | `GetMessage(message_id: \"123456\")`\n *  `GET /v1/users/me/messages/123456` | `GetMessage(user_id: \"me\" message_id:\n *  \"123456\")`\n *\n *  ## Rules for HTTP mapping\n *\n *  1. Leaf request fields (recursive expansion nested messages in the request\n *     message) are classified into three categories:\n *     - Fields referred by the path template. They are passed via the URL path.\n *     - Fields referred by the [HttpRule.body][google.api.HttpRule.body]. They\n *     are passed via the HTTP\n *       request body.\n *     - All other fields are passed via the URL query parameters, and the\n *       parameter name is the field path in the request message. A repeated\n *       field can be represented as multiple query parameters under the same\n *       name.\n *   2. If [HttpRule.body][google.api.HttpRule.body] is \"*\", there is no URL\n *   query parameter, all fields\n *      are passed via URL path and HTTP request body.\n *   3. If [HttpRule.body][google.api.HttpRule.body] is omitted, there is no HTTP\n *   request body, all\n *      fields are passed via URL path and URL query parameters.\n *\n *  ### Path template syntax\n *\n *      Template = \"/\" Segments [ Verb ] ;\n *      Segments = Segment { \"/\" Segment } ;\n *      Segment  = \"*\" | \"**\" | LITERAL | Variable ;\n *      Variable = \"{\" FieldPath [ \"=\" Segments ] \"}\" ;\n *      FieldPath = IDENT { \".\" IDENT } ;\n *      Verb     = \":\" LITERAL ;\n *\n *  The syntax `*` matches a single URL path segment. The syntax `**` matches\n *  zero or more URL path segments, which must be the last part of the URL path\n *  except the `Verb`.\n *\n *  The syntax `Variable` matches part of the URL path as specified by its\n *  template. A variable template must not contain other variables. If a variable\n *  matches a single path segment, its template may be omitted, e.g. `{var}`\n *  is equivalent to `{var=*}`.\n *\n *  The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL`\n *  contains any reserved character, such characters should be percent-encoded\n *  before the matching.\n *\n *  If a variable contains exactly one path segment, such as `\"{var}\"` or\n *  `\"{var=*}\"`, when such a variable is expanded into a URL path on the client\n *  side, all characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The\n *  server side does the reverse decoding. Such variables show up in the\n *  [Discovery\n *  Document](https://developers.google.com/discovery/v1/reference/apis) as\n *  `{var}`.\n *\n *  If a variable contains multiple path segments, such as `\"{var=foo/*}\"`\n *  or `\"{var=**}\"`, when such a variable is expanded into a URL path on the\n *  client side, all characters except `[-_.~/0-9a-zA-Z]` are percent-encoded.\n *  The server side does the reverse decoding, except \"%2F\" and \"%2f\" are left\n *  unchanged. Such variables show up in the\n *  [Discovery\n *  Document](https://developers.google.com/discovery/v1/reference/apis) as\n *  `{+var}`.\n *\n *  ## Using gRPC API Service Configuration\n *\n *  gRPC API Service Configuration (service config) is a configuration language\n *  for configuring a gRPC service to become a user-facing product. The\n *  service config is simply the YAML representation of the `google.api.Service`\n *  proto message.\n *\n *  As an alternative to annotating your proto file, you can configure gRPC\n *  transcoding in your service config YAML files. You do this by specifying a\n *  `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same\n *  effect as the proto annotation. This can be particularly useful if you\n *  have a proto that is reused in multiple services. Note that any transcoding\n *  specified in the service config will override any matching transcoding\n *  configuration in the proto.\n *\n *  Example:\n *\n *      http:\n *        rules:\n *          # Selects a gRPC method and applies HttpRule to it.\n *          - selector: example.v1.Messaging.GetMessage\n *            get: /v1/messages/{message_id}/{sub.subfield}\n *\n *  ## Special notes\n *\n *  When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the\n *  proto to JSON conversion must follow the [proto3\n *  specification](https://developers.google.com/protocol-buffers/docs/proto3#json).\n *\n *  While the single segment variable follows the semantics of\n *  [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String\n *  Expansion, the multi segment variable **does not** follow RFC 6570 Section\n *  3.2.3 Reserved Expansion. The reason is that the Reserved Expansion\n *  does not expand special characters like `?` and `#`, which would lead\n *  to invalid URLs. As the result, gRPC Transcoding uses a custom encoding\n *  for multi segment variables.\n *\n *  The path variables **must not** refer to any repeated or mapped field,\n *  because client libraries are not capable of handling such variable expansion.\n *\n *  The path variables **must not** capture the leading \"/\" character. The reason\n *  is that the most common use case \"{var}\" does not capture the leading \"/\"\n *  character. For consistency, all path variables must share the same behavior.\n *\n *  Repeated message fields must not be mapped to URL query parameters, because\n *  no client library can support such complicated mapping.\n *\n *  If an API needs to use a JSON array for request or response body, it can map\n *  the request or response body to a repeated field. However, some gRPC\n *  Transcoding implementations may not support this feature.\n */\nexport interface THttpRule {\n  /**\n   *  Selects a method to which this rule applies.\n   *\n   *  Refer to [selector][google.api.DocumentationRule.selector] for syntax\n   *  details.\n   */\n  selector?: string;\n  /**\n   *  Maps to HTTP GET. Used for listing and getting information about\n   *  resources.\n   */\n  get?: string;\n  /**\n   *  Maps to HTTP PUT. Used for replacing a resource.\n   */\n  put?: string;\n  /**\n   *  Maps to HTTP POST. Used for creating a resource or performing an action.\n   */\n  post?: string;\n  /**\n   *  Maps to HTTP DELETE. Used for deleting a resource.\n   */\n  delete?: string;\n  /**\n   *  Maps to HTTP PATCH. Used for updating a resource.\n   */\n  patch?: string;\n  /**\n   *  The custom pattern is used for specifying an HTTP method that is not\n   *  included in the `pattern` field, such as HEAD, or \"*\" to leave the\n   *  HTTP method unspecified for this rule. The wild-card rule is useful\n   *  for services that provide content to Web (HTML) clients.\n   */\n  custom?: TGoogleApiCustomHttpPattern;\n  /**\n   *  The name of the request field whose value is mapped to the HTTP request\n   *  body, or `*` for mapping all request fields not captured by the path\n   *  pattern to the HTTP body, or omitted for not having any HTTP request body.\n   *\n   *  NOTE: the referred field must be present at the top-level of the request\n   *  message type.\n   */\n  body?: string;\n  /**\n   *  Optional. The name of the response field whose value is mapped to the HTTP\n   *  response body. When omitted, the entire response message will be used\n   *  as the HTTP response body.\n   *\n   *  NOTE: The referred field must be present at the top-level of the response\n   *  message type.\n   */\n  response_body?: string;\n  /**\n   *  Additional HTTP bindings for the selector. Nested bindings must\n   *  not contain an `additional_bindings` field themselves (that is,\n   *  the nesting may only be one level deep).\n   */\n  additional_bindings?: THttpRule[];\n}\n\n/**\n * HttpRule\n *  # gRPC Transcoding\n *\n *  gRPC Transcoding is a feature for mapping between a gRPC method and one or\n *  more HTTP REST endpoints. It allows developers to build a single API service\n *  that supports both gRPC APIs and REST APIs. Many systems, including [Google\n *  APIs](https://github.com/googleapis/googleapis),\n *  [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC\n *  Gateway](https://github.com/grpc-ecosystem/grpc-gateway),\n *  and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature\n *  and use it for large scale production services.\n *\n *  `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies\n *  how different portions of the gRPC request message are mapped to the URL\n *  path, URL query parameters, and HTTP request body. It also controls how the\n *  gRPC response message is mapped to the HTTP response body. `HttpRule` is\n *  typically specified as an `google.api.http` annotation on the gRPC method.\n *\n *  Each mapping specifies a URL path template and an HTTP method. The path\n *  template may refer to one or more fields in the gRPC request message, as long\n *  as each field is a non-repeated field with a primitive (non-message) type.\n *  The path template controls how fields of the request message are mapped to\n *  the URL path.\n *\n *  Example:\n *\n *      service Messaging {\n *        rpc GetMessage(GetMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *              get: \"/v1/{name=messages/*}\"\n *          };\n *        }\n *      }\n *      message GetMessageRequest {\n *        string name = 1; // Mapped to URL path.\n *      }\n *      message Message {\n *        string text = 1; // The resource content.\n *      }\n *\n *  This enables an HTTP REST to gRPC mapping as below:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `GET /v1/messages/123456`  | `GetMessage(name: \"messages/123456\")`\n *\n *  Any fields in the request message which are not bound by the path template\n *  automatically become HTTP query parameters if there is no HTTP request body.\n *  For example:\n *\n *      service Messaging {\n *        rpc GetMessage(GetMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *              get:\"/v1/messages/{message_id}\"\n *          };\n *        }\n *      }\n *      message GetMessageRequest {\n *        message SubMessage {\n *          string subfield = 1;\n *        }\n *        string message_id = 1; // Mapped to URL path.\n *        int64 revision = 2;    // Mapped to URL query parameter `revision`.\n *        SubMessage sub = 3;    // Mapped to URL query parameter `sub.subfield`.\n *      }\n *\n *  This enables a HTTP JSON to RPC mapping as below:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `GET /v1/messages/123456?revision=2&sub.subfield=foo` |\n *  `GetMessage(message_id: \"123456\" revision: 2 sub: SubMessage(subfield:\n *  \"foo\"))`\n *\n *  Note that fields which are mapped to URL query parameters must have a\n *  primitive type or a repeated primitive type or a non-repeated message type.\n *  In the case of a repeated type, the parameter can be repeated in the URL\n *  as `...?param=A&param=B`. In the case of a message type, each field of the\n *  message is mapped to a separate parameter, such as\n *  `...?foo.a=A&foo.b=B&foo.c=C`.\n *\n *  For HTTP methods that allow a request body, the `body` field\n *  specifies the mapping. Consider a REST update method on the\n *  message resource collection:\n *\n *      service Messaging {\n *        rpc UpdateMessage(UpdateMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *            patch: \"/v1/messages/{message_id}\"\n *            body: \"message\"\n *          };\n *        }\n *      }\n *      message UpdateMessageRequest {\n *        string message_id = 1; // mapped to the URL\n *        Message message = 2;   // mapped to the body\n *      }\n *\n *  The following HTTP JSON to RPC mapping is enabled, where the\n *  representation of the JSON in the request body is determined by\n *  protos JSON encoding:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `PATCH /v1/messages/123456 { \"text\": \"Hi!\" }` | `UpdateMessage(message_id:\n *  \"123456\" message { text: \"Hi!\" })`\n *\n *  The special name `*` can be used in the body mapping to define that\n *  every field not bound by the path template should be mapped to the\n *  request body.  This enables the following alternative definition of\n *  the update method:\n *\n *      service Messaging {\n *        rpc UpdateMessage(Message) returns (Message) {\n *          option (google.api.http) = {\n *            patch: \"/v1/messages/{message_id}\"\n *            body: \"*\"\n *          };\n *        }\n *      }\n *      message Message {\n *        string message_id = 1;\n *        string text = 2;\n *      }\n *\n *\n *  The following HTTP JSON to RPC mapping is enabled:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `PATCH /v1/messages/123456 { \"text\": \"Hi!\" }` | `UpdateMessage(message_id:\n *  \"123456\" text: \"Hi!\")`\n *\n *  Note that when using `*` in the body mapping, it is not possible to\n *  have HTTP parameters, as all fields not bound by the path end in\n *  the body. This makes this option more rarely used in practice when\n *  defining REST APIs. The common usage of `*` is in custom methods\n *  which don't use the URL at all for transferring data.\n *\n *  It is possible to define multiple HTTP methods for one RPC by using\n *  the `additional_bindings` option. Example:\n *\n *      service Messaging {\n *        rpc GetMessage(GetMessageRequest) returns (Message) {\n *          option (google.api.http) = {\n *            get: \"/v1/messages/{message_id}\"\n *            additional_bindings {\n *              get: \"/v1/users/{user_id}/messages/{message_id}\"\n *            }\n *          };\n *        }\n *      }\n *      message GetMessageRequest {\n *        string message_id = 1;\n *        string user_id = 2;\n *      }\n *\n *  This enables the following two alternative HTTP JSON to RPC mappings:\n *\n *  HTTP | gRPC\n *  -----|-----\n *  `GET /v1/messages/123456` | `GetMessage(message_id: \"123456\")`\n *  `GET /v1/users/me/messages/123456` | `GetMessage(user_id: \"me\" message_id:\n *  \"123456\")`\n *\n *  ## Rules for HTTP mapping\n *\n *  1. Leaf request fields (recursive expansion nested messages in the request\n *     message) are classified into three categories:\n *     - Fields referred by the path template. They are passed via the URL path.\n *     - Fields referred by the [HttpRule.body][google.api.HttpRule.body]. They\n *     are passed via the HTTP\n *       request body.\n *     - All other fields are passed via the URL query parameters, and the\n *       parameter name is the field path in the request message. A repeated\n *       field can be represented as multiple query parameters under the same\n *       name.\n *   2. If [HttpRule.body][google.api.HttpRule.body] is \"*\", there is no URL\n *   query parameter, all fields\n *      are passed via URL path and HTTP request body.\n *   3. If [HttpRule.body][google.api.HttpRule.body] is omitted, there is no HTTP\n *   request body, all\n *      fields are passed via URL path and URL query parameters.\n *\n *  ### Path template syntax\n *\n *      Template = \"/\" Segments [ Verb ] ;\n *      Segments = Segment { \"/\" Segment } ;\n *      Segment  = \"*\" | \"**\" | LITERAL | Variable ;\n *      Variable = \"{\" FieldPath [ \"=\" Segments ] \"}\" ;\n *      FieldPath = IDENT { \".\" IDENT } ;\n *      Verb     = \":\" LITERAL ;\n *\n *  The syntax `*` matches a single URL path segment. The syntax `**` matches\n *  zero or more URL path segments, which must be the last part of the URL path\n *  except the `Verb`.\n *\n *  The syntax `Variable` matches part of the URL path as specified by its\n *  template. A variable template must not contain other variables. If a variable\n *  matches a single path segment, its template may be omitted, e.g. `{var}`\n *  is equivalent to `{var=*}`.\n *\n *  The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL`\n *  contains any reserved character, such characters should be percent-encoded\n *  before the matching.\n *\n *  If a variable contains exactly one path segment, such as `\"{var}\"` or\n *  `\"{var=*}\"`, when such a variable is expanded into a URL path on the client\n *  side, all characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The\n *  server side does the reverse decoding. Such variables show up in the\n *  [Discovery\n *  Document](https://developers.google.com/discovery/v1/reference/apis) as\n *  `{var}`.\n *\n *  If a variable contains multiple path segments, such as `\"{var=foo/*}\"`\n *  or `\"{var=**}\"`, when such a variable is expanded into a URL path on the\n *  client side, all characters except `[-_.~/0-9a-zA-Z]` are percent-encoded.\n *  The server side does the reverse decoding, except \"%2F\" and \"%2f\" are left\n *  unchanged. Such variables show up in the\n *  [Discovery\n *  Document](https://developers.google.com/discovery/v1/reference/apis) as\n *  `{+var}`.\n *\n *  ## Using gRPC API Service Configuration\n *\n *  gRPC API Service Configuration (service config) is a configuration language\n *  for configuring a gRPC service to become a user-facing product. The\n *  service config is simply the YAML representation of the `google.api.Service`\n *  proto message.\n *\n *  As an alternative to annotating your proto file, you can configure gRPC\n *  transcoding in your service config YAML files. You do this by specifying a\n *  `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same\n *  effect as the proto annotation. This can be particularly useful if you\n *  have a proto that is reused in multiple services. Note that any transcoding\n *  specified in the service config will override any matching transcoding\n *  configuration in the proto.\n *\n *  Example:\n *\n *      http:\n *        rules:\n *          # Selects a gRPC method and applies HttpRule to it.\n *          - selector: example.v1.Messaging.GetMessage\n *            get: /v1/messages/{message_id}/{sub.subfield}\n *\n *  ## Special notes\n *\n *  When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the\n *  proto to JSON conversion must follow the [proto3\n *  specification](https://developers.google.com/protocol-buffers/docs/proto3#json).\n *\n *  While the single segment variable follows the semantics of\n *  [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String\n *  Expansion, the multi segment variable **does not** follow RFC 6570 Section\n *  3.2.3 Reserved Expansion. The reason is that the Reserved Expansion\n *  does not expand special characters like `?` and `#`, which would lead\n *  to invalid URLs. As the result, gRPC Transcoding uses a custom encoding\n *  for multi segment variables.\n *\n *  The path variables **must not** refer to any repeated or mapped field,\n *  because client libraries are not capable of handling such variable expansion.\n *\n *  The path variables **must not** capture the leading \"/\" character. The reason\n *  is that the most common use case \"{var}\" does not capture the leading \"/\"\n *  character. For consistency, all path variables must share the same behavior.\n *\n *  Repeated message fields must not be mapped to URL query parameters, because\n *  no client library can support such complicated mapping.\n *\n *  If an API needs to use a JSON array for request or response body, it can map\n *  the request or response body to a repeated field. However, some gRPC\n *  Transcoding implementations may not support this feature.\n */\nexport class HttpRule extends FieldNode {\n  //  Selects a method to which this rule applies.\n  //\n  //  Refer to [selector][google.api.DocumentationRule.selector] for syntax\n  //  details.\n  private _selector: STRING;\n\n  //  Maps to HTTP GET. Used for listing and getting information about\n  //  resources.\n  private _get: STRING;\n\n  //  Maps to HTTP PUT. Used for replacing a resource.\n  private _put: STRING;\n\n  //  Maps to HTTP POST. Used for creating a resource or performing an action.\n  private _post: STRING;\n\n  //  Maps to HTTP DELETE. Used for deleting a resource.\n  private _delete: STRING;\n\n  //  Maps to HTTP PATCH. Used for updating a resource.\n  private _patch: STRING;\n\n  //  The custom pattern is used for specifying an HTTP method that is not\n  //  included in the `pattern` field, such as HEAD, or \"*\" to leave the\n  //  HTTP method unspecified for this rule. The wild-card rule is useful\n  //  for services that provide content to Web (HTML) clients.\n  private _custom: GoogleApiCustomHttpPattern;\n\n  //  The name of the request field whose value is mapped to the HTTP request\n  //  body, or `*` for mapping all request fields not captured by the path\n  //  pattern to the HTTP body, or omitted for not having any HTTP request body.\n  //\n  //  NOTE: the referred field must be present at the top-level of the request\n  //  message type.\n  private _body: STRING;\n\n  //  Optional. The name of the response field whose value is mapped to the HTTP\n  //  response body. When omitted, the entire response message will be used\n  //  as the HTTP response body.\n  //\n  //  NOTE: The referred field must be present at the top-level of the response\n  //  message type.\n  private _responseBody: STRING;\n\n  //  Additional HTTP bindings for the selector. Nested bindings must\n  //  not contain an `additional_bindings` field themselves (that is,\n  //  the nesting may only be one level deep).\n  private _additionalBindings: ARRAY<HttpRule, IHttpRule>;\n\n  public __defaultValues: IHttpRule;\n\n  constructor(\n    initData?: IHttpRule,\n    parent?: FieldNode,\n    parentAttributeName?: string,\n  ) {\n    super(undefined, parent, parentAttributeName);\n    this.__meta.typeName = 'google.api.HttpRule';\n\n    this.__meta.nodeFields = [\n      {\n        fieldName: 'selector',\n        protoName: 'selector',\n        FieldConstructor: STRING,\n        constraints: {},\n      },\n      {\n        fieldName: 'get',\n        protoName: 'get',\n        FieldConstructor: STRING,\n        constraints: {},\n      },\n      {\n        fieldName: 'put',\n        protoName: 'put',\n        FieldConstructor: STRING,\n        constraints: {},\n      },\n      {\n        fieldName: 'post',\n        protoName: 'post',\n        FieldConstructor: STRING,\n        constraints: {},\n      },\n      {\n        fieldName: 'delete',\n        protoName: 'delete',\n        FieldConstructor: STRING,\n        constraints: {},\n      },\n      {\n        fieldName: 'patch',\n        protoName: 'patch',\n        FieldConstructor: STRING,\n        constraints: {},\n      },\n      {\n        fieldName: 'custom',\n        protoName: 'custom',\n        FieldConstructor: GoogleApiCustomHttpPattern,\n        constraints: {},\n      },\n      {\n        fieldName: 'body',\n        protoName: 'body',\n        FieldConstructor: STRING,\n        constraints: {},\n      },\n      {\n        fieldName: 'responseBody',\n        protoName: 'response_body',\n        FieldConstructor: STRING,\n        constraints: {},\n      },\n      {\n        fieldName: 'additionalBindings',\n        protoName: 'additional_bindings',\n        FieldConstructor: HttpRule,\n        constraints: {},\n      },\n    ];\n\n    // Initialize the fields\n    //  Selects a method to which this rule applies.\n    //\n    //  Refer to [selector][google.api.DocumentationRule.selector] for syntax\n    //  details.\n    this._selector = new STRING(undefined, this, 'selector');\n\n    //  Maps to HTTP GET. Used for listing and getting information about\n    //  resources.\n    this._get = new STRING(undefined, this, 'get');\n\n    //  Maps to HTTP PUT. Used for replacing a resource.\n    this._put = new STRING(undefined, this, 'put');\n\n    //  Maps to HTTP POST. Used for creating a resource or performing an action.\n    this._post = new STRING(undefined, this, 'post');\n\n    //  Maps to HTTP DELETE. Used for deleting a resource.\n    this._delete = new STRING(undefined, this, 'delete');\n\n    //  Maps to HTTP PATCH. Used for updating a resource.\n    this._patch = new STRING(undefined, this, 'patch');\n\n    //  The custom pattern is used for specifying an HTTP method that is not\n    //  included in the `pattern` field, such as HEAD, or \"*\" to leave the\n    //  HTTP method unspecified for this rule. The wild-card rule is useful\n    //  for services that provide content to Web (HTML) clients.\n    this._custom = new GoogleApiCustomHttpPattern(undefined, this, 'custom');\n\n    //  The name of the request field whose value is mapped to the HTTP request\n    //  body, or `*` for mapping all request fields not captured by the path\n    //  pattern to the HTTP body, or omitted for not having any HTTP request body.\n    //\n    //  NOTE: the referred field must be present at the top-level of the request\n    //  message type.\n    this._body = new STRING(undefined, this, 'body');\n\n    //  Optional. The name of the response field whose value is mapped to the HTTP\n    //  response body. When omitted, the entire response message will be used\n    //  as the HTTP response body.\n    //\n    //  NOTE: The referred field must be present at the top-level of the response\n    //  message type.\n    this._responseBody = new STRING(undefined, this, 'responseBody');\n\n    //  Additional HTTP bindings for the selector. Nested bindings must\n    //  not contain an `additional_bindings` field themselves (that is,\n    //  the nesting may only be one level deep).\n    this._additionalBindings = new ARRAY<HttpRule, IHttpRule>(\n      undefined,\n      this,\n      'additionalBindings',\n    );\n\n    // Set required fields\n    [].forEach(fieldName => {\n      (this[fieldName as keyof HttpRule] as FieldNode).__meta.required = true;\n    });\n\n    // Default values from openAPI annotations\n    this.__defaultValues = {};\n\n    // Initialize the fields with init data\n    if (initData !== undefined) {\n      this.__fromLiteral({ ...this.__defaultValues, ...initData });\n    } else {\n      this.__fromLiteral(this.__defaultValues);\n    }\n\n    // Set readonly fields after the init, so child nodes are readonly too\n    [].forEach(fieldName => {\n      (this[fieldName as keyof HttpRule] as FieldNode).__readonly = true;\n    });\n\n    this.__meta.isPristine = true;\n  }\n\n  //  Selects a method to which this rule applies.\n  //\n  //  Refer to [selector][google.api.DocumentationRule.selector] for syntax\n  //  details.\n  public get selector(): STRING {\n    return this._selector;\n  }\n\n  public set selector(v: string) {\n    this.__PrimitivesSetter(this._selector, v);\n  }\n\n  //  Maps to HTTP GET. Used for listing and getting information about\n  //  resources.\n  public get get(): STRING {\n    return this._get;\n  }\n\n  public set get(v: string) {\n    this.__PrimitivesSetter(this._get, v);\n  }\n\n  //  Maps to HTTP PUT. Used for replacing a resource.\n  public get put(): STRING {\n    return this._put;\n  }\n\n  public set put(v: string) {\n    this.__PrimitivesSetter(this._put, v);\n  }\n\n  //  Maps to HTTP POST. Used for creating a resource or performing an action.\n  public get post(): STRING {\n    return this._post;\n  }\n\n  public set post(v: string) {\n    this.__PrimitivesSetter(this._post, v);\n  }\n\n  //  Maps to HTTP DELETE. Used for deleting a resource.\n  public get delete(): STRING {\n    return this._delete;\n  }\n\n  public set delete(v: string) {\n    this.__PrimitivesSetter(this._delete, v);\n  }\n\n  //  Maps to HTTP PATCH. Used for updating a resource.\n  public get patch(): STRING {\n    return this._patch;\n  }\n\n  public set patch(v: string) {\n    this.__PrimitivesSetter(this._patch, v);\n  }\n\n  //  The custom pattern is used for specifying an HTTP method that is not\n  //  included in the `pattern` field, such as HEAD, or \"*\" to leave the\n  //  HTTP method unspecified for this rule. The wild-card rule is useful\n  //  for services that provide content to Web (HTML) clients.\n  public get custom(): GoogleApiCustomHttpPattern {\n    return this._custom;\n  }\n\n  public set custom(v: IGoogleApiCustomHttpPattern) {\n    this.__TypeSetter(this._custom, v);\n  }\n\n  //  The name of the request field whose value is mapped to the HTTP request\n  //  body, or `*` for mapping all request fields not captured by the path\n  //  pattern to the HTTP body, or omitted for not having any HTTP request body.\n  //\n  //  NOTE: the referred field must be present at the top-level of the request\n  //  message type.\n  public get body(): STRING {\n    return this._body;\n  }\n\n  public set body(v: string) {\n    this.__PrimitivesSetter(this._body, v);\n  }\n\n  //  Optional. The name of the response field whose value is mapped to the HTTP\n  //  response body. When omitted, the entire response message will be used\n  //  as the HTTP response body.\n  //\n  //  NOTE: The referred field must be present at the top-level of the response\n  //  message type.\n  public get responseBody(): STRING {\n    return this._responseBody;\n  }\n\n  public set responseBody(v: string) {\n    this.__PrimitivesSetter(this._responseBody, v);\n  }\n\n  //  Additional HTTP bindings for the selector. Nested bindings must\n  //  not contain an `additional_bindings` field themselves (that is,\n  //  the nesting may only be one level deep).\n  public get additionalBindings(): ARRAY<HttpRule, IHttpRule> {\n    return this._additionalBindings;\n  }\n\n  public set additionalBindings(v: IHttpRule[]) {\n    this.__TypeSetter(this._additionalBindings, v);\n  }\n\n  fromLiteral(data: IHttpRule) {\n    super.__fromLiteral(data);\n  }\n\n  toLiteral(): IHttpRule {\n    return super.__toLiteral();\n  }\n}\n\nRegistry.register('google.api.HttpRule', HttpRule);\n"]}