mirror of
https://github.com/grpc/grpc-node.git
synced 2025-12-08 18:23:54 +00:00
Merge branch 'master' into grpc-js_eds_lb_policy
This commit is contained in:
commit
50b5af09ed
@ -120,7 +120,7 @@ export interface _envoy_api_v2_Cluster_CommonLbConfig__Output {
|
||||
* .. note::
|
||||
* The specified percent will be truncated to the nearest 1%.
|
||||
*/
|
||||
'healthy_panic_threshold': (_envoy_type_Percent__Output);
|
||||
'healthy_panic_threshold'?: (_envoy_type_Percent__Output);
|
||||
'zone_aware_lb_config'?: (_envoy_api_v2_Cluster_CommonLbConfig_ZoneAwareLbConfig__Output);
|
||||
'locality_weighted_lb_config'?: (_envoy_api_v2_Cluster_CommonLbConfig_LocalityWeightedLbConfig__Output);
|
||||
/**
|
||||
@ -139,7 +139,7 @@ export interface _envoy_api_v2_Cluster_CommonLbConfig__Output {
|
||||
* because merging those updates isn't currently safe. See
|
||||
* https://github.com/envoyproxy/envoy/pull/3941.
|
||||
*/
|
||||
'update_merge_window': (_google_protobuf_Duration__Output);
|
||||
'update_merge_window'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* If set to true, Envoy will not consider new hosts when computing load balancing weights until
|
||||
* they have been health checked for the first time. This will have no effect unless
|
||||
@ -170,7 +170,7 @@ export interface _envoy_api_v2_Cluster_CommonLbConfig__Output {
|
||||
/**
|
||||
* Common Configuration for all consistent hashing load balancers (MaglevLb, RingHashLb, etc.)
|
||||
*/
|
||||
'consistent_hashing_lb_config': (_envoy_api_v2_Cluster_CommonLbConfig_ConsistentHashingLbConfig__Output);
|
||||
'consistent_hashing_lb_config'?: (_envoy_api_v2_Cluster_CommonLbConfig_ConsistentHashingLbConfig__Output);
|
||||
'locality_config_specifier': "zone_aware_lb_config"|"locality_weighted_lb_config";
|
||||
}
|
||||
|
||||
@ -223,7 +223,7 @@ export interface _envoy_api_v2_Cluster_CustomClusterType__Output {
|
||||
* Cluster specific configuration which depends on the cluster being instantiated.
|
||||
* See the supported cluster for further documentation.
|
||||
*/
|
||||
'typed_config': (_google_protobuf_Any__Output);
|
||||
'typed_config'?: (_google_protobuf_Any__Output);
|
||||
}
|
||||
|
||||
// Original file: deps/envoy-api/envoy/api/v2/cluster.proto
|
||||
@ -306,7 +306,7 @@ export interface _envoy_api_v2_Cluster_EdsClusterConfig__Output {
|
||||
/**
|
||||
* Configuration for the source of EDS updates for this Cluster.
|
||||
*/
|
||||
'eds_config': (_envoy_api_v2_core_ConfigSource__Output);
|
||||
'eds_config'?: (_envoy_api_v2_core_ConfigSource__Output);
|
||||
/**
|
||||
* Optional alternative to cluster name to present to EDS. This does not
|
||||
* have the same restrictions as cluster name, i.e. it may be arbitrary
|
||||
@ -494,7 +494,7 @@ export interface _envoy_api_v2_Cluster_LbSubsetConfig__Output {
|
||||
* is the same as a fallback_policy of
|
||||
* :ref:`NO_FALLBACK<envoy_api_enum_value_Cluster.LbSubsetConfig.LbSubsetFallbackPolicy.NO_FALLBACK>`.
|
||||
*/
|
||||
'default_subset': (_google_protobuf_Struct__Output);
|
||||
'default_subset'?: (_google_protobuf_Struct__Output);
|
||||
/**
|
||||
* For each entry, LbEndpoint.Metadata's
|
||||
* *envoy.lb* namespace is traversed and a subset is created for each unique
|
||||
@ -671,7 +671,7 @@ export interface _envoy_api_v2_Cluster_LeastRequestLbConfig__Output {
|
||||
* The number of random healthy hosts from which the host with the fewest active requests will
|
||||
* be chosen. Defaults to 2 so that we perform two-choice selection if the field is not set.
|
||||
*/
|
||||
'choice_count': (_google_protobuf_UInt32Value__Output);
|
||||
'choice_count'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -750,14 +750,14 @@ export interface _envoy_api_v2_Cluster_RefreshRate__Output {
|
||||
* than zero and less than
|
||||
* :ref:`max_interval <envoy_api_field_Cluster.RefreshRate.max_interval>`.
|
||||
*/
|
||||
'base_interval': (_google_protobuf_Duration__Output);
|
||||
'base_interval'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Specifies the maximum interval between refreshes. This parameter is optional, but must be
|
||||
* greater than or equal to the
|
||||
* :ref:`base_interval <envoy_api_field_Cluster.RefreshRate.base_interval>` if set. The default
|
||||
* is 10 times the :ref:`base_interval <envoy_api_field_Cluster.RefreshRate.base_interval>`.
|
||||
*/
|
||||
'max_interval': (_google_protobuf_Duration__Output);
|
||||
'max_interval'?: (_google_protobuf_Duration__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -796,7 +796,7 @@ export interface _envoy_api_v2_Cluster_RingHashLbConfig__Output {
|
||||
* to 1024 entries, and limited to 8M entries. See also
|
||||
* :ref:`maximum_ring_size<envoy_api_field_Cluster.RingHashLbConfig.maximum_ring_size>`.
|
||||
*/
|
||||
'minimum_ring_size': (_google_protobuf_UInt64Value__Output);
|
||||
'minimum_ring_size'?: (_google_protobuf_UInt64Value__Output);
|
||||
/**
|
||||
* The hash function used to hash hosts onto the ketama ring. The value defaults to
|
||||
* :ref:`XX_HASH<envoy_api_enum_value_Cluster.RingHashLbConfig.HashFunction.XX_HASH>`.
|
||||
@ -807,7 +807,7 @@ export interface _envoy_api_v2_Cluster_RingHashLbConfig__Output {
|
||||
* to further constrain resource use. See also
|
||||
* :ref:`minimum_ring_size<envoy_api_field_Cluster.RingHashLbConfig.minimum_ring_size>`.
|
||||
*/
|
||||
'maximum_ring_size': (_google_protobuf_UInt64Value__Output);
|
||||
'maximum_ring_size'?: (_google_protobuf_UInt64Value__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -849,11 +849,11 @@ export interface _envoy_api_v2_Cluster_TransportSocketMatch__Output {
|
||||
* The endpoint's metadata entry in *envoy.transport_socket_match* is used to match
|
||||
* against the values specified in this field.
|
||||
*/
|
||||
'match': (_google_protobuf_Struct__Output);
|
||||
'match'?: (_google_protobuf_Struct__Output);
|
||||
/**
|
||||
* The configuration of the transport socket.
|
||||
*/
|
||||
'transport_socket': (_envoy_api_v2_core_TransportSocket__Output);
|
||||
'transport_socket'?: (_envoy_api_v2_core_TransportSocket__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -896,7 +896,7 @@ export interface _envoy_api_v2_Cluster_CommonLbConfig_ZoneAwareLbConfig__Output
|
||||
* * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
|
||||
* * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
|
||||
*/
|
||||
'routing_enabled': (_envoy_type_Percent__Output);
|
||||
'routing_enabled'?: (_envoy_type_Percent__Output);
|
||||
/**
|
||||
* Configures minimum upstream cluster size required for zone aware routing
|
||||
* If upstream cluster size is less than specified, zone aware routing is not performed
|
||||
@ -904,7 +904,7 @@ export interface _envoy_api_v2_Cluster_CommonLbConfig_ZoneAwareLbConfig__Output
|
||||
* * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
|
||||
* * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
|
||||
*/
|
||||
'min_cluster_size': (_google_protobuf_UInt64Value__Output);
|
||||
'min_cluster_size'?: (_google_protobuf_UInt64Value__Output);
|
||||
/**
|
||||
* If set to true, Envoy will not consider any hosts when the cluster is in :ref:`panic
|
||||
* mode<arch_overview_load_balancing_panic_threshold>`. Instead, the cluster will fail all
|
||||
@ -1155,14 +1155,14 @@ export interface Cluster {
|
||||
* "envoy.filters.network.thrift_proxy". See the extension's documentation for details on
|
||||
* specific options.
|
||||
*/
|
||||
'extension_protocol_options'?: (_google_protobuf_Struct);
|
||||
'extension_protocol_options'?: ({[key: string]: _google_protobuf_Struct});
|
||||
/**
|
||||
* The extension_protocol_options field is used to provide extension-specific protocol options
|
||||
* for upstream connections. The key should match the extension filter name, such as
|
||||
* "envoy.filters.network.thrift_proxy". See the extension's documentation for details on
|
||||
* specific options.
|
||||
*/
|
||||
'typed_extension_protocol_options'?: (_google_protobuf_Any);
|
||||
'typed_extension_protocol_options'?: ({[key: string]: _google_protobuf_Any});
|
||||
/**
|
||||
* Optional configuration for the LeastRequest load balancing policy.
|
||||
*/
|
||||
@ -1317,16 +1317,16 @@ export interface Cluster__Output {
|
||||
/**
|
||||
* Configuration to use for EDS updates for the Cluster.
|
||||
*/
|
||||
'eds_cluster_config': (_envoy_api_v2_Cluster_EdsClusterConfig__Output);
|
||||
'eds_cluster_config'?: (_envoy_api_v2_Cluster_EdsClusterConfig__Output);
|
||||
/**
|
||||
* The timeout for new network connections to hosts in the cluster.
|
||||
*/
|
||||
'connect_timeout': (_google_protobuf_Duration__Output);
|
||||
'connect_timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Soft limit on size of the cluster’s connections read and write buffers. If
|
||||
* unspecified, an implementation defined default is applied (1MiB).
|
||||
*/
|
||||
'per_connection_buffer_limit_bytes': (_google_protobuf_UInt32Value__Output);
|
||||
'per_connection_buffer_limit_bytes'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The :ref:`load balancer type <arch_overview_load_balancing_types>` to use
|
||||
* when picking a host in the cluster.
|
||||
@ -1358,11 +1358,11 @@ export interface Cluster__Output {
|
||||
* implementations. If not specified, there is no limit. Setting this
|
||||
* parameter to 1 will effectively disable keep alive.
|
||||
*/
|
||||
'max_requests_per_connection': (_google_protobuf_UInt32Value__Output);
|
||||
'max_requests_per_connection'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Optional :ref:`circuit breaking <arch_overview_circuit_break>` for the cluster.
|
||||
*/
|
||||
'circuit_breakers': (_envoy_api_v2_cluster_CircuitBreakers__Output);
|
||||
'circuit_breakers'?: (_envoy_api_v2_cluster_CircuitBreakers__Output);
|
||||
/**
|
||||
* The TLS configuration for connections to the upstream cluster.
|
||||
*
|
||||
@ -1371,11 +1371,11 @@ export interface Cluster__Output {
|
||||
* **This field is deprecated**. Use `transport_socket` with name `tls` instead. If both are
|
||||
* set, `transport_socket` takes priority.
|
||||
*/
|
||||
'tls_context': (_envoy_api_v2_auth_UpstreamTlsContext__Output);
|
||||
'tls_context'?: (_envoy_api_v2_auth_UpstreamTlsContext__Output);
|
||||
/**
|
||||
* Additional options when handling HTTP1 requests.
|
||||
*/
|
||||
'http_protocol_options': (_envoy_api_v2_core_Http1ProtocolOptions__Output);
|
||||
'http_protocol_options'?: (_envoy_api_v2_core_Http1ProtocolOptions__Output);
|
||||
/**
|
||||
* Even if default HTTP2 protocol options are desired, this field must be
|
||||
* set so that Envoy will assume that the upstream supports HTTP/2 when
|
||||
@ -1384,7 +1384,7 @@ export interface Cluster__Output {
|
||||
* with ALPN, `http2_protocol_options` must be specified. As an aside this allows HTTP/2
|
||||
* connections to happen over plain text.
|
||||
*/
|
||||
'http2_protocol_options': (_envoy_api_v2_core_Http2ProtocolOptions__Output);
|
||||
'http2_protocol_options'?: (_envoy_api_v2_core_Http2ProtocolOptions__Output);
|
||||
/**
|
||||
* If the DNS refresh rate is specified and the cluster type is either
|
||||
* :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`,
|
||||
@ -1396,7 +1396,7 @@ export interface Cluster__Output {
|
||||
* and :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`
|
||||
* this setting is ignored.
|
||||
*/
|
||||
'dns_refresh_rate': (_google_protobuf_Duration__Output);
|
||||
'dns_refresh_rate'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* The DNS IP address resolution policy. If this setting is not specified, the
|
||||
* value defaults to
|
||||
@ -1421,7 +1421,7 @@ export interface Cluster__Output {
|
||||
* Each of the configuration values can be overridden via
|
||||
* :ref:`runtime values <config_cluster_manager_cluster_runtime_outlier_detection>`.
|
||||
*/
|
||||
'outlier_detection': (_envoy_api_v2_cluster_OutlierDetection__Output);
|
||||
'outlier_detection'?: (_envoy_api_v2_cluster_OutlierDetection__Output);
|
||||
/**
|
||||
* The interval for removing stale hosts from a cluster type
|
||||
* :ref:`ORIGINAL_DST<envoy_api_enum_value_Cluster.DiscoveryType.ORIGINAL_DST>`.
|
||||
@ -1437,17 +1437,17 @@ export interface Cluster__Output {
|
||||
* :ref:`ORIGINAL_DST<envoy_api_enum_value_Cluster.DiscoveryType.ORIGINAL_DST>`
|
||||
* this setting is ignored.
|
||||
*/
|
||||
'cleanup_interval': (_google_protobuf_Duration__Output);
|
||||
'cleanup_interval'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Optional configuration used to bind newly established upstream connections.
|
||||
* This overrides any bind_config specified in the bootstrap proto.
|
||||
* If the address and port are empty, no bind will be performed.
|
||||
*/
|
||||
'upstream_bind_config': (_envoy_api_v2_core_BindConfig__Output);
|
||||
'upstream_bind_config'?: (_envoy_api_v2_core_BindConfig__Output);
|
||||
/**
|
||||
* Configuration for load balancing subsetting.
|
||||
*/
|
||||
'lb_subset_config': (_envoy_api_v2_Cluster_LbSubsetConfig__Output);
|
||||
'lb_subset_config'?: (_envoy_api_v2_Cluster_LbSubsetConfig__Output);
|
||||
/**
|
||||
* Optional configuration for the Ring Hash load balancing policy.
|
||||
*/
|
||||
@ -1459,7 +1459,7 @@ export interface Cluster__Output {
|
||||
* If no transport socket configuration is specified, new connections
|
||||
* will be set up with plaintext.
|
||||
*/
|
||||
'transport_socket': (_envoy_api_v2_core_TransportSocket__Output);
|
||||
'transport_socket'?: (_envoy_api_v2_core_TransportSocket__Output);
|
||||
/**
|
||||
* The Metadata field can be used to provide additional information about the
|
||||
* cluster. It can be used for stats, logging, and varying filter behavior.
|
||||
@ -1467,7 +1467,7 @@ export interface Cluster__Output {
|
||||
* will need the information. For instance, if the metadata is intended for
|
||||
* the Router filter, the filter name should be specified as *envoy.filters.http.router*.
|
||||
*/
|
||||
'metadata': (_envoy_api_v2_core_Metadata__Output);
|
||||
'metadata'?: (_envoy_api_v2_core_Metadata__Output);
|
||||
/**
|
||||
* Determines how Envoy selects the protocol used to speak to upstream hosts.
|
||||
*/
|
||||
@ -1475,7 +1475,7 @@ export interface Cluster__Output {
|
||||
/**
|
||||
* Common configuration for all load balancer implementations.
|
||||
*/
|
||||
'common_lb_config': (_envoy_api_v2_Cluster_CommonLbConfig__Output);
|
||||
'common_lb_config'?: (_envoy_api_v2_Cluster_CommonLbConfig__Output);
|
||||
/**
|
||||
* An optional alternative to the cluster name to be used while emitting stats.
|
||||
* Any ``:`` in the name will be converted to ``_`` when emitting statistics. This should not be
|
||||
@ -1487,11 +1487,11 @@ export interface Cluster__Output {
|
||||
* Additional options when handling HTTP requests upstream. These options will be applicable to
|
||||
* both HTTP1 and HTTP2 requests.
|
||||
*/
|
||||
'common_http_protocol_options': (_envoy_api_v2_core_HttpProtocolOptions__Output);
|
||||
'common_http_protocol_options'?: (_envoy_api_v2_core_HttpProtocolOptions__Output);
|
||||
/**
|
||||
* Optional options for upstream connections.
|
||||
*/
|
||||
'upstream_connection_options': (_envoy_api_v2_UpstreamConnectionOptions__Output);
|
||||
'upstream_connection_options'?: (_envoy_api_v2_UpstreamConnectionOptions__Output);
|
||||
/**
|
||||
* If an upstream host becomes unhealthy (as determined by the configured health checks
|
||||
* or outlier detection), immediately close all connections to the failed host.
|
||||
@ -1526,7 +1526,7 @@ export interface Cluster__Output {
|
||||
* Setting this allows non-EDS cluster types to contain embedded EDS equivalent
|
||||
* :ref:`endpoint assignments<envoy_api_msg_ClusterLoadAssignment>`.
|
||||
*/
|
||||
'load_assignment': (_envoy_api_v2_ClusterLoadAssignment__Output);
|
||||
'load_assignment'?: (_envoy_api_v2_ClusterLoadAssignment__Output);
|
||||
/**
|
||||
* Optional configuration for the Original Destination load balancing policy.
|
||||
*/
|
||||
@ -1537,14 +1537,14 @@ export interface Cluster__Output {
|
||||
* "envoy.filters.network.thrift_proxy". See the extension's documentation for details on
|
||||
* specific options.
|
||||
*/
|
||||
'extension_protocol_options': (_google_protobuf_Struct__Output);
|
||||
'extension_protocol_options'?: ({[key: string]: _google_protobuf_Struct__Output});
|
||||
/**
|
||||
* The extension_protocol_options field is used to provide extension-specific protocol options
|
||||
* for upstream connections. The key should match the extension filter name, such as
|
||||
* "envoy.filters.network.thrift_proxy". See the extension's documentation for details on
|
||||
* specific options.
|
||||
*/
|
||||
'typed_extension_protocol_options': (_google_protobuf_Any__Output);
|
||||
'typed_extension_protocol_options'?: ({[key: string]: _google_protobuf_Any__Output});
|
||||
/**
|
||||
* Optional configuration for the LeastRequest load balancing policy.
|
||||
*/
|
||||
@ -1570,7 +1570,7 @@ export interface Cluster__Output {
|
||||
* :ref:`lb_policy<envoy_api_field_Cluster.lb_policy>` field has the value
|
||||
* :ref:`LOAD_BALANCING_POLICY_CONFIG<envoy_api_enum_value_Cluster.LbPolicy.LOAD_BALANCING_POLICY_CONFIG>`.
|
||||
*/
|
||||
'load_balancing_policy': (_envoy_api_v2_LoadBalancingPolicy__Output);
|
||||
'load_balancing_policy'?: (_envoy_api_v2_LoadBalancingPolicy__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:]
|
||||
* If present, tells the client where to send load reports via LRS. If not present, the
|
||||
@ -1587,7 +1587,7 @@ export interface Cluster__Output {
|
||||
* maybe by allowing LRS to go on the ADS stream, or maybe by moving some of the negotiation
|
||||
* from the LRS stream here.]
|
||||
*/
|
||||
'lrs_server': (_envoy_api_v2_core_ConfigSource__Output);
|
||||
'lrs_server'?: (_envoy_api_v2_core_ConfigSource__Output);
|
||||
/**
|
||||
* Configuration to use different transport sockets for different endpoints.
|
||||
* The entry of *envoy.transport_socket_match* in the
|
||||
@ -1646,7 +1646,7 @@ export interface Cluster__Output {
|
||||
* :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>` this setting is
|
||||
* ignored.
|
||||
*/
|
||||
'dns_failure_refresh_rate': (_envoy_api_v2_Cluster_RefreshRate__Output);
|
||||
'dns_failure_refresh_rate'?: (_envoy_api_v2_Cluster_RefreshRate__Output);
|
||||
/**
|
||||
* [#next-major-version: Reconcile DNS options in a single message.]
|
||||
* Always use TCP queries instead of UDP queries for DNS lookups.
|
||||
@ -1656,7 +1656,7 @@ export interface Cluster__Output {
|
||||
* HTTP protocol options that are applied only to upstream HTTP connections.
|
||||
* These options apply to all HTTP versions.
|
||||
*/
|
||||
'upstream_http_protocol_options': (_envoy_api_v2_core_UpstreamHttpProtocolOptions__Output);
|
||||
'upstream_http_protocol_options'?: (_envoy_api_v2_core_UpstreamHttpProtocolOptions__Output);
|
||||
/**
|
||||
* If track_timeout_budgets is true, the :ref:`timeout budget histograms
|
||||
* <config_cluster_manager_cluster_stats_timeout_budgets>` will be published for each
|
||||
|
||||
@ -31,7 +31,7 @@ export interface _envoy_api_v2_ClusterLoadAssignment_Policy_DropOverload__Output
|
||||
/**
|
||||
* Percentage of traffic that should be dropped for the category.
|
||||
*/
|
||||
'drop_percentage': (_envoy_type_FractionalPercent__Output);
|
||||
'drop_percentage'?: (_envoy_type_FractionalPercent__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -143,14 +143,14 @@ export interface _envoy_api_v2_ClusterLoadAssignment_Policy__Output {
|
||||
* Read more at :ref:`priority levels <arch_overview_load_balancing_priority_levels>` and
|
||||
* :ref:`localities <arch_overview_load_balancing_locality_weighted_lb>`.
|
||||
*/
|
||||
'overprovisioning_factor': (_google_protobuf_UInt32Value__Output);
|
||||
'overprovisioning_factor'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The max time until which the endpoints from this assignment can be used.
|
||||
* If no new assignments are received before this time expires the endpoints
|
||||
* are considered stale and should be marked unhealthy.
|
||||
* Defaults to 0 which means endpoints never go stale.
|
||||
*/
|
||||
'endpoint_stale_after': (_google_protobuf_Duration__Output);
|
||||
'endpoint_stale_after'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* The flag to disable overprovisioning. If it is set to true,
|
||||
* :ref:`overprovisioning factor
|
||||
@ -196,7 +196,7 @@ export interface ClusterLoadAssignment {
|
||||
* Map of named endpoints that can be referenced in LocalityLbEndpoints.
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
'named_endpoints'?: (_envoy_api_v2_endpoint_Endpoint);
|
||||
'named_endpoints'?: ({[key: string]: _envoy_api_v2_endpoint_Endpoint});
|
||||
}
|
||||
|
||||
/**
|
||||
@ -226,10 +226,10 @@ export interface ClusterLoadAssignment__Output {
|
||||
/**
|
||||
* Load balancing policy settings.
|
||||
*/
|
||||
'policy': (_envoy_api_v2_ClusterLoadAssignment_Policy__Output);
|
||||
'policy'?: (_envoy_api_v2_ClusterLoadAssignment_Policy__Output);
|
||||
/**
|
||||
* Map of named endpoints that can be referenced in LocalityLbEndpoints.
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
'named_endpoints': (_envoy_api_v2_endpoint_Endpoint__Output);
|
||||
'named_endpoints'?: ({[key: string]: _envoy_api_v2_endpoint_Endpoint__Output});
|
||||
}
|
||||
|
||||
@ -86,7 +86,7 @@ export interface DeltaDiscoveryRequest {
|
||||
* The map's keys are names of xDS resources known to the xDS client.
|
||||
* The map's values are opaque resource versions.
|
||||
*/
|
||||
'initial_resource_versions'?: (string);
|
||||
'initial_resource_versions'?: ({[key: string]: string});
|
||||
/**
|
||||
* When the DeltaDiscoveryRequest is a ACK or NACK message in response
|
||||
* to a previous DeltaDiscoveryResponse, the response_nonce must be the
|
||||
@ -141,7 +141,7 @@ export interface DeltaDiscoveryRequest__Output {
|
||||
/**
|
||||
* The node making the request.
|
||||
*/
|
||||
'node': (_envoy_api_v2_core_Node__Output);
|
||||
'node'?: (_envoy_api_v2_core_Node__Output);
|
||||
/**
|
||||
* Type of the resource that is being requested, e.g.
|
||||
* "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment".
|
||||
@ -185,7 +185,7 @@ export interface DeltaDiscoveryRequest__Output {
|
||||
* The map's keys are names of xDS resources known to the xDS client.
|
||||
* The map's values are opaque resource versions.
|
||||
*/
|
||||
'initial_resource_versions': (string);
|
||||
'initial_resource_versions': ({[key: string]: string});
|
||||
/**
|
||||
* When the DeltaDiscoveryRequest is a ACK or NACK message in response
|
||||
* to a previous DeltaDiscoveryResponse, the response_nonce must be the
|
||||
@ -198,5 +198,5 @@ export interface DeltaDiscoveryRequest__Output {
|
||||
* failed to update configuration. The *message* field in *error_details*
|
||||
* provides the Envoy internal exception related to the failure.
|
||||
*/
|
||||
'error_detail': (_google_rpc_Status__Output);
|
||||
'error_detail'?: (_google_rpc_Status__Output);
|
||||
}
|
||||
|
||||
@ -75,7 +75,7 @@ export interface DiscoveryRequest__Output {
|
||||
/**
|
||||
* The node making the request.
|
||||
*/
|
||||
'node': (_envoy_api_v2_core_Node__Output);
|
||||
'node'?: (_envoy_api_v2_core_Node__Output);
|
||||
/**
|
||||
* List of resources to subscribe to, e.g. list of cluster names or a route
|
||||
* configuration name. If this is empty, all resources for the API are
|
||||
@ -106,5 +106,5 @@ export interface DiscoveryRequest__Output {
|
||||
* internal exception related to the failure. It is only intended for consumption during manual
|
||||
* debugging, the string provided is not guaranteed to be stable across Envoy versions.
|
||||
*/
|
||||
'error_detail': (_google_rpc_Status__Output);
|
||||
'error_detail'?: (_google_rpc_Status__Output);
|
||||
}
|
||||
|
||||
@ -104,5 +104,5 @@ export interface DiscoveryResponse__Output {
|
||||
* [#not-implemented-hide:]
|
||||
* The control plane instance that sent the response.
|
||||
*/
|
||||
'control_plane': (_envoy_api_v2_core_ControlPlane__Output);
|
||||
'control_plane'?: (_envoy_api_v2_core_ControlPlane__Output);
|
||||
}
|
||||
|
||||
@ -70,7 +70,7 @@ export interface _envoy_api_v2_Listener_DeprecatedV1__Output {
|
||||
*
|
||||
* [#comment:TODO(PiotrSikora): Remove this once verified that we no longer need it.]
|
||||
*/
|
||||
'bind_to_port': (_google_protobuf_BoolValue__Output);
|
||||
'bind_to_port'?: (_google_protobuf_BoolValue__Output);
|
||||
}
|
||||
|
||||
// Original file: deps/envoy-api/envoy/api/v2/listener.proto
|
||||
@ -322,7 +322,7 @@ export interface Listener__Output {
|
||||
* that is governed by the bind rules of the OS. E.g., multiple listeners can listen on port 0 on
|
||||
* Linux as the actual port will be allocated by the OS.
|
||||
*/
|
||||
'address': (_envoy_api_v2_core_Address__Output);
|
||||
'address'?: (_envoy_api_v2_core_Address__Output);
|
||||
/**
|
||||
* A list of filter chains to consider for this listener. The
|
||||
* :ref:`FilterChain <envoy_api_msg_listener.FilterChain>` with the most specific
|
||||
@ -350,20 +350,20 @@ export interface Listener__Output {
|
||||
* will be removed, as filter chain matching can be used to select a filter chain based on the
|
||||
* restored destination address.
|
||||
*/
|
||||
'use_original_dst': (_google_protobuf_BoolValue__Output);
|
||||
'use_original_dst'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Soft limit on size of the listener’s new connection read and write buffers.
|
||||
* If unspecified, an implementation defined default is applied (1MiB).
|
||||
*/
|
||||
'per_connection_buffer_limit_bytes': (_google_protobuf_UInt32Value__Output);
|
||||
'per_connection_buffer_limit_bytes'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Listener metadata.
|
||||
*/
|
||||
'metadata': (_envoy_api_v2_core_Metadata__Output);
|
||||
'metadata'?: (_envoy_api_v2_core_Metadata__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
'deprecated_v1': (_envoy_api_v2_Listener_DeprecatedV1__Output);
|
||||
'deprecated_v1'?: (_envoy_api_v2_Listener_DeprecatedV1__Output);
|
||||
/**
|
||||
* The type of draining to perform at a listener-wide level.
|
||||
*/
|
||||
@ -396,7 +396,7 @@ export interface Listener__Output {
|
||||
* When this flag is not set (default), the socket is not modified, i.e. the transparent option
|
||||
* is neither set nor reset.
|
||||
*/
|
||||
'transparent': (_google_protobuf_BoolValue__Output);
|
||||
'transparent'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Whether the listener should set the *IP_FREEBIND* socket option. When this
|
||||
* flag is set to true, listeners can be bound to an IP address that is not
|
||||
@ -405,7 +405,7 @@ export interface Listener__Output {
|
||||
* (default), the socket is not modified, i.e. the option is neither enabled
|
||||
* nor disabled.
|
||||
*/
|
||||
'freebind': (_google_protobuf_BoolValue__Output);
|
||||
'freebind'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Whether the listener should accept TCP Fast Open (TFO) connections.
|
||||
* When this flag is set to a value greater than 0, the option TCP_FASTOPEN is enabled on
|
||||
@ -422,7 +422,7 @@ export interface Listener__Output {
|
||||
* On macOS, only values of 0, 1, and unset are valid; other values may result in an error.
|
||||
* To set the queue length on macOS, set the net.inet.tcp.fastopen_backlog kernel parameter.
|
||||
*/
|
||||
'tcp_fast_open_queue_length': (_google_protobuf_UInt32Value__Output);
|
||||
'tcp_fast_open_queue_length'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Additional socket options that may not be present in Envoy source code or
|
||||
* precompiled binaries.
|
||||
@ -434,7 +434,7 @@ export interface Listener__Output {
|
||||
* `continue_on_listener_filters_timeout` is set to true. Specify 0 to disable the
|
||||
* timeout. If not specified, a default timeout of 15s is used.
|
||||
*/
|
||||
'listener_filters_timeout': (_google_protobuf_Duration__Output);
|
||||
'listener_filters_timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Specifies the intended direction of the traffic relative to the local Envoy.
|
||||
*/
|
||||
@ -457,7 +457,7 @@ export interface Listener__Output {
|
||||
* <envoy_api_field_listener.UdpListenerConfig.udp_listener_name>` = "raw_udp_listener" for
|
||||
* creating a packet-oriented UDP listener. If not present, treat it as "raw_udp_listener".
|
||||
*/
|
||||
'udp_listener_config': (_envoy_api_v2_listener_UdpListenerConfig__Output);
|
||||
'udp_listener_config'?: (_envoy_api_v2_listener_UdpListenerConfig__Output);
|
||||
/**
|
||||
* Used to represent an API listener, which is used in non-proxy clients. The type of API
|
||||
* exposed to the non-proxy application depends on the type of API listener.
|
||||
@ -476,13 +476,13 @@ export interface Listener__Output {
|
||||
* socket listener and the various types of API listener. That way, a given Listener message
|
||||
* can structurally only contain the fields of the relevant type.]
|
||||
*/
|
||||
'api_listener': (_envoy_config_listener_v2_ApiListener__Output);
|
||||
'api_listener'?: (_envoy_config_listener_v2_ApiListener__Output);
|
||||
/**
|
||||
* The listener's connection balancer configuration, currently only applicable to TCP listeners.
|
||||
* If no configuration is specified, Envoy will not attempt to balance active connections between
|
||||
* worker threads.
|
||||
*/
|
||||
'connection_balance_config': (_envoy_api_v2_Listener_ConnectionBalanceConfig__Output);
|
||||
'connection_balance_config'?: (_envoy_api_v2_Listener_ConnectionBalanceConfig__Output);
|
||||
/**
|
||||
* When this flag is set to true, listeners set the *SO_REUSEPORT* socket option and
|
||||
* create one socket for each worker thread. This makes inbound connections
|
||||
|
||||
@ -25,8 +25,8 @@ export interface _envoy_api_v2_LoadBalancingPolicy_Policy__Output {
|
||||
* Optional config for the LB policy.
|
||||
* No more than one of these two fields may be populated.
|
||||
*/
|
||||
'config': (_google_protobuf_Struct__Output);
|
||||
'typed_config': (_google_protobuf_Any__Output);
|
||||
'config'?: (_google_protobuf_Struct__Output);
|
||||
'typed_config'?: (_google_protobuf_Any__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -31,7 +31,7 @@ export interface Resource__Output {
|
||||
/**
|
||||
* The resource being tracked.
|
||||
*/
|
||||
'resource': (_google_protobuf_Any__Output);
|
||||
'resource'?: (_google_protobuf_Any__Output);
|
||||
/**
|
||||
* The resource's name, to distinguish it from others of the same type of resource.
|
||||
*/
|
||||
|
||||
@ -155,7 +155,7 @@ export interface RouteConfiguration__Output {
|
||||
* option. Users may wish to override the default behavior in certain cases (for example when
|
||||
* using CDS with a static route table).
|
||||
*/
|
||||
'validate_clusters': (_google_protobuf_BoolValue__Output);
|
||||
'validate_clusters'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Specifies a list of HTTP headers that should be removed from each request
|
||||
* routed by the HTTP connection manager.
|
||||
@ -169,7 +169,7 @@ export interface RouteConfiguration__Output {
|
||||
* generate a routing table for a given RouteConfiguration, with *vhds* derived configuration
|
||||
* taking precedence.
|
||||
*/
|
||||
'vhds': (_envoy_api_v2_Vhds__Output);
|
||||
'vhds'?: (_envoy_api_v2_Vhds__Output);
|
||||
/**
|
||||
* By default, headers that should be added/removed are evaluated from most to least specific:
|
||||
*
|
||||
|
||||
@ -21,5 +21,5 @@ export interface UpstreamBindConfig__Output {
|
||||
/**
|
||||
* The address Envoy should bind to when establishing upstream connections.
|
||||
*/
|
||||
'source_address': (_envoy_api_v2_core_Address__Output);
|
||||
'source_address'?: (_envoy_api_v2_core_Address__Output);
|
||||
}
|
||||
|
||||
@ -13,5 +13,5 @@ export interface UpstreamConnectionOptions__Output {
|
||||
/**
|
||||
* If set then set SO_KEEPALIVE on the socket to enable TCP Keepalives.
|
||||
*/
|
||||
'tcp_keepalive': (_envoy_api_v2_core_TcpKeepalive__Output);
|
||||
'tcp_keepalive'?: (_envoy_api_v2_core_TcpKeepalive__Output);
|
||||
}
|
||||
|
||||
@ -13,5 +13,5 @@ export interface Vhds__Output {
|
||||
/**
|
||||
* Configuration source specifier for VHDS.
|
||||
*/
|
||||
'config_source': (_envoy_api_v2_core_ConfigSource__Output);
|
||||
'config_source'?: (_envoy_api_v2_core_ConfigSource__Output);
|
||||
}
|
||||
|
||||
@ -193,7 +193,7 @@ export interface CertificateValidationContext__Output {
|
||||
* See :ref:`the TLS overview <arch_overview_ssl_enabling_verification>` for a list of common
|
||||
* system CA locations.
|
||||
*/
|
||||
'trusted_ca': (_envoy_api_v2_core_DataSource__Output);
|
||||
'trusted_ca'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
/**
|
||||
* An optional list of hex-encoded SHA-256 hashes. If specified, Envoy will verify that
|
||||
* the SHA-256 of the DER-encoded presented certificate matches one of the specified values.
|
||||
@ -270,11 +270,11 @@ export interface CertificateValidationContext__Output {
|
||||
/**
|
||||
* [#not-implemented-hide:] Must present a signed time-stamped OCSP response.
|
||||
*/
|
||||
'require_ocsp_staple': (_google_protobuf_BoolValue__Output);
|
||||
'require_ocsp_staple'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:] Must present signed certificate time-stamp.
|
||||
*/
|
||||
'require_signed_certificate_timestamp': (_google_protobuf_BoolValue__Output);
|
||||
'require_signed_certificate_timestamp'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* An optional `certificate revocation list
|
||||
* <https://en.wikipedia.org/wiki/Certificate_revocation_list>`_
|
||||
@ -282,7 +282,7 @@ export interface CertificateValidationContext__Output {
|
||||
* certificate has not been revoked by this CRL. If this DataSource contains
|
||||
* multiple CRLs, all of them will be used.
|
||||
*/
|
||||
'crl': (_envoy_api_v2_core_DataSource__Output);
|
||||
'crl'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
/**
|
||||
* If specified, Envoy will not reject expired certificates.
|
||||
*/
|
||||
|
||||
@ -20,11 +20,11 @@ export interface _envoy_api_v2_auth_CommonTlsContext_CombinedCertificateValidati
|
||||
/**
|
||||
* How to validate peer certificates.
|
||||
*/
|
||||
'default_validation_context': (_envoy_api_v2_auth_CertificateValidationContext__Output);
|
||||
'default_validation_context'?: (_envoy_api_v2_auth_CertificateValidationContext__Output);
|
||||
/**
|
||||
* Config for fetching validation context via SDS API.
|
||||
*/
|
||||
'validation_context_sds_secret_config': (_envoy_api_v2_auth_SdsSecretConfig__Output);
|
||||
'validation_context_sds_secret_config'?: (_envoy_api_v2_auth_SdsSecretConfig__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -91,7 +91,7 @@ export interface CommonTlsContext__Output {
|
||||
/**
|
||||
* TLS protocol versions, cipher suites etc.
|
||||
*/
|
||||
'tls_params': (_envoy_api_v2_auth_TlsParameters__Output);
|
||||
'tls_params'?: (_envoy_api_v2_auth_TlsParameters__Output);
|
||||
/**
|
||||
* :ref:`Multiple TLS certificates <arch_overview_ssl_cert_select>` can be associated with the
|
||||
* same context to allow both RSA and ECDSA certificates.
|
||||
|
||||
@ -60,17 +60,17 @@ export interface DownstreamTlsContext__Output {
|
||||
/**
|
||||
* Common TLS context settings.
|
||||
*/
|
||||
'common_tls_context': (_envoy_api_v2_auth_CommonTlsContext__Output);
|
||||
'common_tls_context'?: (_envoy_api_v2_auth_CommonTlsContext__Output);
|
||||
/**
|
||||
* If specified, Envoy will reject connections without a valid client
|
||||
* certificate.
|
||||
*/
|
||||
'require_client_certificate': (_google_protobuf_BoolValue__Output);
|
||||
'require_client_certificate'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* If specified, Envoy will reject connections without a valid and matching SNI.
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
'require_sni': (_google_protobuf_BoolValue__Output);
|
||||
'require_sni'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* TLS session ticket key settings.
|
||||
*/
|
||||
@ -85,7 +85,7 @@ export interface DownstreamTlsContext__Output {
|
||||
* <https://tools.ietf.org/html/rfc5077#section-5.6>`
|
||||
* only seconds could be specified (fractional seconds are going to be ignored).
|
||||
*/
|
||||
'session_timeout': (_google_protobuf_Duration__Output);
|
||||
'session_timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Config for controlling stateless TLS session resumption: setting this to true will cause the TLS
|
||||
* server to not issue TLS session tickets for the purposes of stateless TLS session resumption.
|
||||
|
||||
@ -13,5 +13,5 @@ export interface GenericSecret__Output {
|
||||
/**
|
||||
* Secret of generic type and is available to filters.
|
||||
*/
|
||||
'secret': (_envoy_api_v2_core_DataSource__Output);
|
||||
'secret'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
}
|
||||
|
||||
@ -19,5 +19,5 @@ export interface SdsSecretConfig__Output {
|
||||
* SDS. When only name is specified, then secret will be loaded from static resources.
|
||||
*/
|
||||
'name': (string);
|
||||
'sds_config': (_envoy_api_v2_core_ConfigSource__Output);
|
||||
'sds_config'?: (_envoy_api_v2_core_ConfigSource__Output);
|
||||
}
|
||||
|
||||
@ -47,20 +47,20 @@ export interface TlsCertificate__Output {
|
||||
/**
|
||||
* The TLS certificate chain.
|
||||
*/
|
||||
'certificate_chain': (_envoy_api_v2_core_DataSource__Output);
|
||||
'certificate_chain'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
/**
|
||||
* The TLS private key.
|
||||
*/
|
||||
'private_key': (_envoy_api_v2_core_DataSource__Output);
|
||||
'private_key'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
/**
|
||||
* The password to decrypt the TLS private key. If this field is not set, it is assumed that the
|
||||
* TLS private key is not password encrypted.
|
||||
*/
|
||||
'password': (_envoy_api_v2_core_DataSource__Output);
|
||||
'password'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
'ocsp_staple': (_envoy_api_v2_core_DataSource__Output);
|
||||
'ocsp_staple'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
@ -74,5 +74,5 @@ export interface TlsCertificate__Output {
|
||||
* <envoy_api_field_auth.TlsCertificate.private_key_provider>` fields will result in an
|
||||
* error.
|
||||
*/
|
||||
'private_key_provider': (_envoy_api_v2_auth_PrivateKeyProvider__Output);
|
||||
'private_key_provider'?: (_envoy_api_v2_auth_PrivateKeyProvider__Output);
|
||||
}
|
||||
|
||||
@ -45,7 +45,7 @@ export interface UpstreamTlsContext__Output {
|
||||
* :ref:`trusted_ca<envoy_api_field_auth.CertificateValidationContext.trusted_ca>` to enable
|
||||
* verification.
|
||||
*/
|
||||
'common_tls_context': (_envoy_api_v2_auth_CommonTlsContext__Output);
|
||||
'common_tls_context'?: (_envoy_api_v2_auth_CommonTlsContext__Output);
|
||||
/**
|
||||
* SNI string to use when creating TLS backend connections.
|
||||
*/
|
||||
@ -64,5 +64,5 @@ export interface UpstreamTlsContext__Output {
|
||||
*
|
||||
* Defaults to 1, setting this to 0 disables session resumption.
|
||||
*/
|
||||
'max_session_keys': (_google_protobuf_UInt32Value__Output);
|
||||
'max_session_keys'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
@ -30,14 +30,14 @@ export interface _envoy_api_v2_cluster_CircuitBreakers_Thresholds_RetryBudget__O
|
||||
*
|
||||
* This parameter is optional. Defaults to 20%.
|
||||
*/
|
||||
'budget_percent': (_envoy_type_Percent__Output);
|
||||
'budget_percent'?: (_envoy_type_Percent__Output);
|
||||
/**
|
||||
* Specifies the minimum retry concurrency allowed for the retry budget. The limit on the
|
||||
* number of active retries may never go below this number.
|
||||
*
|
||||
* This parameter is optional. Defaults to 3.
|
||||
*/
|
||||
'min_retry_concurrency': (_google_protobuf_UInt32Value__Output);
|
||||
'min_retry_concurrency'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -117,22 +117,22 @@ export interface _envoy_api_v2_cluster_CircuitBreakers_Thresholds__Output {
|
||||
* The maximum number of connections that Envoy will make to the upstream
|
||||
* cluster. If not specified, the default is 1024.
|
||||
*/
|
||||
'max_connections': (_google_protobuf_UInt32Value__Output);
|
||||
'max_connections'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The maximum number of pending requests that Envoy will allow to the
|
||||
* upstream cluster. If not specified, the default is 1024.
|
||||
*/
|
||||
'max_pending_requests': (_google_protobuf_UInt32Value__Output);
|
||||
'max_pending_requests'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The maximum number of parallel requests that Envoy will make to the
|
||||
* upstream cluster. If not specified, the default is 1024.
|
||||
*/
|
||||
'max_requests': (_google_protobuf_UInt32Value__Output);
|
||||
'max_requests'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The maximum number of parallel retries that Envoy will allow to the
|
||||
* upstream cluster. If not specified, the default is 3.
|
||||
*/
|
||||
'max_retries': (_google_protobuf_UInt32Value__Output);
|
||||
'max_retries'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Specifies a limit on concurrent retries in relation to the number of active requests. This
|
||||
* parameter is optional.
|
||||
@ -142,7 +142,7 @@ export interface _envoy_api_v2_cluster_CircuitBreakers_Thresholds__Output {
|
||||
* If this field is set, the retry budget will override any configured retry circuit
|
||||
* breaker.
|
||||
*/
|
||||
'retry_budget': (_envoy_api_v2_cluster_CircuitBreakers_Thresholds_RetryBudget__Output);
|
||||
'retry_budget'?: (_envoy_api_v2_cluster_CircuitBreakers_Thresholds_RetryBudget__Output);
|
||||
/**
|
||||
* If track_remaining is true, then stats will be published that expose
|
||||
* the number of resources remaining until the circuit breakers open. If
|
||||
@ -161,7 +161,7 @@ export interface _envoy_api_v2_cluster_CircuitBreakers_Thresholds__Output {
|
||||
* :ref:`Circuit Breaking <arch_overview_circuit_break_cluster_maximum_connection_pools>` for
|
||||
* more details.
|
||||
*/
|
||||
'max_connection_pools': (_google_protobuf_UInt32Value__Output);
|
||||
'max_connection_pools'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -25,5 +25,5 @@ export interface Filter__Output {
|
||||
* Filter specific configuration which depends on the filter being
|
||||
* instantiated. See the supported filters for further documentation.
|
||||
*/
|
||||
'typed_config': (_google_protobuf_Any__Output);
|
||||
'typed_config'?: (_google_protobuf_Any__Output);
|
||||
}
|
||||
|
||||
@ -162,43 +162,43 @@ export interface OutlierDetection__Output {
|
||||
* to 5xx error codes before a consecutive 5xx ejection
|
||||
* occurs. Defaults to 5.
|
||||
*/
|
||||
'consecutive_5xx': (_google_protobuf_UInt32Value__Output);
|
||||
'consecutive_5xx'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The time interval between ejection analysis sweeps. This can result in
|
||||
* both new ejections as well as hosts being returned to service. Defaults
|
||||
* to 10000ms or 10s.
|
||||
*/
|
||||
'interval': (_google_protobuf_Duration__Output);
|
||||
'interval'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* The base time that a host is ejected for. The real time is equal to the
|
||||
* base time multiplied by the number of times the host has been ejected.
|
||||
* Defaults to 30000ms or 30s.
|
||||
*/
|
||||
'base_ejection_time': (_google_protobuf_Duration__Output);
|
||||
'base_ejection_time'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* The maximum % of an upstream cluster that can be ejected due to outlier
|
||||
* detection. Defaults to 10% but will eject at least one host regardless of the value.
|
||||
*/
|
||||
'max_ejection_percent': (_google_protobuf_UInt32Value__Output);
|
||||
'max_ejection_percent'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The % chance that a host will be actually ejected when an outlier status
|
||||
* is detected through consecutive 5xx. This setting can be used to disable
|
||||
* ejection or to ramp it up slowly. Defaults to 100.
|
||||
*/
|
||||
'enforcing_consecutive_5xx': (_google_protobuf_UInt32Value__Output);
|
||||
'enforcing_consecutive_5xx'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The % chance that a host will be actually ejected when an outlier status
|
||||
* is detected through success rate statistics. This setting can be used to
|
||||
* disable ejection or to ramp it up slowly. Defaults to 100.
|
||||
*/
|
||||
'enforcing_success_rate': (_google_protobuf_UInt32Value__Output);
|
||||
'enforcing_success_rate'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The number of hosts in a cluster that must have enough request volume to
|
||||
* detect success rate outliers. If the number of hosts is less than this
|
||||
* setting, outlier detection via success rate statistics is not performed
|
||||
* for any host in the cluster. Defaults to 5.
|
||||
*/
|
||||
'success_rate_minimum_hosts': (_google_protobuf_UInt32Value__Output);
|
||||
'success_rate_minimum_hosts'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The minimum number of total requests that must be collected in one
|
||||
* interval (as defined by the interval duration above) to include this host
|
||||
@ -206,7 +206,7 @@ export interface OutlierDetection__Output {
|
||||
* setting, outlier detection via success rate statistics is not performed
|
||||
* for that host. Defaults to 100.
|
||||
*/
|
||||
'success_rate_request_volume': (_google_protobuf_UInt32Value__Output);
|
||||
'success_rate_request_volume'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* This factor is used to determine the ejection threshold for success rate
|
||||
* outlier ejection. The ejection threshold is the difference between the
|
||||
@ -216,18 +216,18 @@ export interface OutlierDetection__Output {
|
||||
* double. That is, if the desired factor is 1.9, the runtime value should
|
||||
* be 1900. Defaults to 1900.
|
||||
*/
|
||||
'success_rate_stdev_factor': (_google_protobuf_UInt32Value__Output);
|
||||
'success_rate_stdev_factor'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The number of consecutive gateway failures (502, 503, 504 status codes)
|
||||
* before a consecutive gateway failure ejection occurs. Defaults to 5.
|
||||
*/
|
||||
'consecutive_gateway_failure': (_google_protobuf_UInt32Value__Output);
|
||||
'consecutive_gateway_failure'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The % chance that a host will be actually ejected when an outlier status
|
||||
* is detected through consecutive gateway failures. This setting can be
|
||||
* used to disable ejection or to ramp it up slowly. Defaults to 0.
|
||||
*/
|
||||
'enforcing_consecutive_gateway_failure': (_google_protobuf_UInt32Value__Output);
|
||||
'enforcing_consecutive_gateway_failure'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Determines whether to distinguish local origin failures from external errors. If set to true
|
||||
* the following configuration parameters are taken into account:
|
||||
@ -244,7 +244,7 @@ export interface OutlierDetection__Output {
|
||||
* :ref:`split_external_local_origin_errors<envoy_api_field_cluster.OutlierDetection.split_external_local_origin_errors>`
|
||||
* is set to true.
|
||||
*/
|
||||
'consecutive_local_origin_failure': (_google_protobuf_UInt32Value__Output);
|
||||
'consecutive_local_origin_failure'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The % chance that a host will be actually ejected when an outlier status
|
||||
* is detected through consecutive locally originated failures. This setting can be
|
||||
@ -253,7 +253,7 @@ export interface OutlierDetection__Output {
|
||||
* :ref:`split_external_local_origin_errors<envoy_api_field_cluster.OutlierDetection.split_external_local_origin_errors>`
|
||||
* is set to true.
|
||||
*/
|
||||
'enforcing_consecutive_local_origin_failure': (_google_protobuf_UInt32Value__Output);
|
||||
'enforcing_consecutive_local_origin_failure'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The % chance that a host will be actually ejected when an outlier status
|
||||
* is detected through success rate statistics for locally originated errors.
|
||||
@ -262,13 +262,13 @@ export interface OutlierDetection__Output {
|
||||
* :ref:`split_external_local_origin_errors<envoy_api_field_cluster.OutlierDetection.split_external_local_origin_errors>`
|
||||
* is set to true.
|
||||
*/
|
||||
'enforcing_local_origin_success_rate': (_google_protobuf_UInt32Value__Output);
|
||||
'enforcing_local_origin_success_rate'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The failure percentage to use when determining failure percentage-based outlier detection. If
|
||||
* the failure percentage of a given host is greater than or equal to this value, it will be
|
||||
* ejected. Defaults to 85.
|
||||
*/
|
||||
'failure_percentage_threshold': (_google_protobuf_UInt32Value__Output);
|
||||
'failure_percentage_threshold'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The % chance that a host will be actually ejected when an outlier status is detected through
|
||||
* failure percentage statistics. This setting can be used to disable ejection or to ramp it up
|
||||
@ -277,24 +277,24 @@ export interface OutlierDetection__Output {
|
||||
* [#next-major-version: setting this without setting failure_percentage_threshold should be
|
||||
* invalid in v4.]
|
||||
*/
|
||||
'enforcing_failure_percentage': (_google_protobuf_UInt32Value__Output);
|
||||
'enforcing_failure_percentage'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The % chance that a host will be actually ejected when an outlier status is detected through
|
||||
* local-origin failure percentage statistics. This setting can be used to disable ejection or to
|
||||
* ramp it up slowly. Defaults to 0.
|
||||
*/
|
||||
'enforcing_failure_percentage_local_origin': (_google_protobuf_UInt32Value__Output);
|
||||
'enforcing_failure_percentage_local_origin'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The minimum number of hosts in a cluster in order to perform failure percentage-based ejection.
|
||||
* If the total number of hosts in the cluster is less than this value, failure percentage-based
|
||||
* ejection will not be performed. Defaults to 5.
|
||||
*/
|
||||
'failure_percentage_minimum_hosts': (_google_protobuf_UInt32Value__Output);
|
||||
'failure_percentage_minimum_hosts'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The minimum number of total requests that must be collected in one interval (as defined by the
|
||||
* interval duration above) to perform failure percentage-based ejection for this host. If the
|
||||
* volume is lower than this setting, failure percentage-based ejection will not be performed for
|
||||
* this host. Defaults to 50.
|
||||
*/
|
||||
'failure_percentage_request_volume': (_google_protobuf_UInt32Value__Output);
|
||||
'failure_percentage_request_volume'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
@ -108,7 +108,7 @@ export interface ApiConfigSource__Output {
|
||||
/**
|
||||
* For REST APIs, the delay between successive polls.
|
||||
*/
|
||||
'refresh_delay': (_google_protobuf_Duration__Output);
|
||||
'refresh_delay'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Multiple gRPC services be provided for GRPC. If > 1 cluster is defined,
|
||||
* services will be cycled through if any kind of failure occurs.
|
||||
@ -117,12 +117,12 @@ export interface ApiConfigSource__Output {
|
||||
/**
|
||||
* For REST APIs, the request timeout. If not set, a default value of 1s will be used.
|
||||
*/
|
||||
'request_timeout': (_google_protobuf_Duration__Output);
|
||||
'request_timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* For GRPC APIs, the rate limit settings. If present, discovery requests made by Envoy will be
|
||||
* rate limited.
|
||||
*/
|
||||
'rate_limit_settings': (_envoy_api_v2_core_RateLimitSettings__Output);
|
||||
'rate_limit_settings'?: (_envoy_api_v2_core_RateLimitSettings__Output);
|
||||
/**
|
||||
* Skip the node identifier in subsequent discovery requests for streaming gRPC config types.
|
||||
*/
|
||||
|
||||
@ -31,7 +31,7 @@ export interface BackoffStrategy__Output {
|
||||
* be greater than zero and less than or equal to :ref:`max_interval
|
||||
* <envoy_api_field_core.BackoffStrategy.max_interval>`.
|
||||
*/
|
||||
'base_interval': (_google_protobuf_Duration__Output);
|
||||
'base_interval'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Specifies the maximum interval between retries. This parameter is optional,
|
||||
* but must be greater than or equal to the :ref:`base_interval
|
||||
@ -39,5 +39,5 @@ export interface BackoffStrategy__Output {
|
||||
* is 10 times the :ref:`base_interval
|
||||
* <envoy_api_field_core.BackoffStrategy.base_interval>`.
|
||||
*/
|
||||
'max_interval': (_google_protobuf_Duration__Output);
|
||||
'max_interval'?: (_google_protobuf_Duration__Output);
|
||||
}
|
||||
|
||||
@ -30,7 +30,7 @@ export interface BindConfig__Output {
|
||||
/**
|
||||
* The address to bind to when creating a socket.
|
||||
*/
|
||||
'source_address': (_envoy_api_v2_core_SocketAddress__Output);
|
||||
'source_address'?: (_envoy_api_v2_core_SocketAddress__Output);
|
||||
/**
|
||||
* Whether to set the *IP_FREEBIND* option when creating the socket. When this
|
||||
* flag is set to true, allows the :ref:`source_address
|
||||
@ -40,7 +40,7 @@ export interface BindConfig__Output {
|
||||
* flag is not set (default), the socket is not modified, i.e. the option is
|
||||
* neither enabled nor disabled.
|
||||
*/
|
||||
'freebind': (_google_protobuf_BoolValue__Output);
|
||||
'freebind'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Additional socket options that may not be present in Envoy source code or
|
||||
* precompiled binaries.
|
||||
|
||||
@ -27,10 +27,10 @@ export interface BuildVersion__Output {
|
||||
/**
|
||||
* SemVer version of extension.
|
||||
*/
|
||||
'version': (_envoy_type_SemanticVersion__Output);
|
||||
'version'?: (_envoy_type_SemanticVersion__Output);
|
||||
/**
|
||||
* Free-form build information.
|
||||
* Envoy defines several well known keys in the source/common/common/version.h file
|
||||
*/
|
||||
'metadata': (_google_protobuf_Struct__Output);
|
||||
'metadata'?: (_google_protobuf_Struct__Output);
|
||||
}
|
||||
|
||||
@ -29,5 +29,5 @@ export interface CidrRange__Output {
|
||||
/**
|
||||
* Length of prefix, e.g. 0, 32.
|
||||
*/
|
||||
'prefix_len': (_google_protobuf_UInt32Value__Output);
|
||||
'prefix_len'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
@ -118,7 +118,7 @@ export interface ConfigSource__Output {
|
||||
* means no timeout - Envoy will wait indefinitely for the first xDS config (unless another
|
||||
* timeout applies). The default is 15s.
|
||||
*/
|
||||
'initial_fetch_timeout': (_google_protobuf_Duration__Output);
|
||||
'initial_fetch_timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:]
|
||||
* When set, the client will access the resources from the same server it got the
|
||||
|
||||
@ -67,7 +67,7 @@ export interface Extension__Output {
|
||||
* of other extensions and the Envoy API.
|
||||
* This field is not set when extension did not provide version information.
|
||||
*/
|
||||
'version': (_envoy_api_v2_core_BuildVersion__Output);
|
||||
'version'?: (_envoy_api_v2_core_BuildVersion__Output);
|
||||
/**
|
||||
* Indicates that the extension is present but was disabled via dynamic configuration.
|
||||
*/
|
||||
|
||||
@ -13,5 +13,5 @@ export interface GrpcProtocolOptions {
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
export interface GrpcProtocolOptions__Output {
|
||||
'http2_protocol_options': (_envoy_api_v2_core_Http2ProtocolOptions__Output);
|
||||
'http2_protocol_options'?: (_envoy_api_v2_core_Http2ProtocolOptions__Output);
|
||||
}
|
||||
|
||||
@ -193,7 +193,7 @@ export interface _envoy_api_v2_core_GrpcService_GoogleGrpc__Output {
|
||||
* :ref:`channel_credentials <envoy_api_field_core.GrpcService.GoogleGrpc.channel_credentials>`.
|
||||
*/
|
||||
'target_uri': (string);
|
||||
'channel_credentials': (_envoy_api_v2_core_GrpcService_GoogleGrpc_ChannelCredentials__Output);
|
||||
'channel_credentials'?: (_envoy_api_v2_core_GrpcService_GoogleGrpc_ChannelCredentials__Output);
|
||||
/**
|
||||
* A set of call credentials that can be composed with `channel credentials
|
||||
* <https://grpc.io/docs/guides/auth.html#credential-types>`_.
|
||||
@ -221,7 +221,7 @@ export interface _envoy_api_v2_core_GrpcService_GoogleGrpc__Output {
|
||||
* Additional configuration for site-specific customizations of the Google
|
||||
* gRPC library.
|
||||
*/
|
||||
'config': (_google_protobuf_Struct__Output);
|
||||
'config'?: (_google_protobuf_Struct__Output);
|
||||
}
|
||||
|
||||
export interface _envoy_api_v2_core_GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials {
|
||||
@ -297,15 +297,15 @@ export interface _envoy_api_v2_core_GrpcService_GoogleGrpc_SslCredentials__Outpu
|
||||
/**
|
||||
* PEM encoded server root certificates.
|
||||
*/
|
||||
'root_certs': (_envoy_api_v2_core_DataSource__Output);
|
||||
'root_certs'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
/**
|
||||
* PEM encoded client private key.
|
||||
*/
|
||||
'private_key': (_envoy_api_v2_core_DataSource__Output);
|
||||
'private_key'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
/**
|
||||
* PEM encoded client certificate chain.
|
||||
*/
|
||||
'cert_chain': (_envoy_api_v2_core_DataSource__Output);
|
||||
'cert_chain'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -470,7 +470,7 @@ export interface GrpcService__Output {
|
||||
* The timeout for the gRPC request. This is the timeout for a specific
|
||||
* request.
|
||||
*/
|
||||
'timeout': (_google_protobuf_Duration__Output);
|
||||
'timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Additional metadata to include in streams initiated to the GrpcService.
|
||||
* This can be used for scenarios in which additional ad hoc authorization
|
||||
|
||||
@ -25,10 +25,10 @@ export interface HeaderValueOption__Output {
|
||||
/**
|
||||
* Header name/value pair that this option applies to.
|
||||
*/
|
||||
'header': (_envoy_api_v2_core_HeaderValue__Output);
|
||||
'header'?: (_envoy_api_v2_core_HeaderValue__Output);
|
||||
/**
|
||||
* Should the value be appended? If true (default), the value is appended to
|
||||
* existing values.
|
||||
*/
|
||||
'append': (_google_protobuf_BoolValue__Output);
|
||||
'append'?: (_google_protobuf_BoolValue__Output);
|
||||
}
|
||||
|
||||
@ -186,11 +186,11 @@ export interface _envoy_api_v2_core_HealthCheck_HttpHealthCheck__Output {
|
||||
/**
|
||||
* [#not-implemented-hide:] HTTP specific payload.
|
||||
*/
|
||||
'send': (_envoy_api_v2_core_HealthCheck_Payload__Output);
|
||||
'send'?: (_envoy_api_v2_core_HealthCheck_Payload__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:] HTTP specific response.
|
||||
*/
|
||||
'receive': (_envoy_api_v2_core_HealthCheck_Payload__Output);
|
||||
'receive'?: (_envoy_api_v2_core_HealthCheck_Payload__Output);
|
||||
/**
|
||||
* An optional service name parameter which is used to validate the identity of
|
||||
* the health checked cluster. See the :ref:`architecture overview
|
||||
@ -237,7 +237,7 @@ export interface _envoy_api_v2_core_HealthCheck_HttpHealthCheck__Output {
|
||||
* <envoy_api_msg_type.matcher.StringMatcher>`. See the :ref:`architecture overview
|
||||
* <arch_overview_health_checking_identity>` for more information.
|
||||
*/
|
||||
'service_name_matcher': (_envoy_type_matcher_StringMatcher__Output);
|
||||
'service_name_matcher'?: (_envoy_type_matcher_StringMatcher__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -307,7 +307,7 @@ export interface _envoy_api_v2_core_HealthCheck_TcpHealthCheck__Output {
|
||||
/**
|
||||
* Empty payloads imply a connect-only health check.
|
||||
*/
|
||||
'send': (_envoy_api_v2_core_HealthCheck_Payload__Output);
|
||||
'send'?: (_envoy_api_v2_core_HealthCheck_Payload__Output);
|
||||
/**
|
||||
* When checking the response, “fuzzy” matching is performed such that each
|
||||
* binary block must be found, and in the order specified, but not
|
||||
@ -485,36 +485,36 @@ export interface HealthCheck__Output {
|
||||
* The time to wait for a health check response. If the timeout is reached the
|
||||
* health check attempt will be considered a failure.
|
||||
*/
|
||||
'timeout': (_google_protobuf_Duration__Output);
|
||||
'timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* The interval between health checks.
|
||||
*/
|
||||
'interval': (_google_protobuf_Duration__Output);
|
||||
'interval'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* An optional jitter amount in milliseconds. If specified, during every
|
||||
* interval Envoy will add interval_jitter to the wait time.
|
||||
*/
|
||||
'interval_jitter': (_google_protobuf_Duration__Output);
|
||||
'interval_jitter'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* The number of unhealthy health checks required before a host is marked
|
||||
* unhealthy. Note that for *http* health checking if a host responds with 503
|
||||
* this threshold is ignored and the host is considered unhealthy immediately.
|
||||
*/
|
||||
'unhealthy_threshold': (_google_protobuf_UInt32Value__Output);
|
||||
'unhealthy_threshold'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The number of healthy health checks required before a host is marked
|
||||
* healthy. Note that during startup, only a single successful health check is
|
||||
* required to mark a host healthy.
|
||||
*/
|
||||
'healthy_threshold': (_google_protobuf_UInt32Value__Output);
|
||||
'healthy_threshold'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:] Non-serving port for health checking.
|
||||
*/
|
||||
'alt_port': (_google_protobuf_UInt32Value__Output);
|
||||
'alt_port'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Reuse health check connection between health checks. Default is true.
|
||||
*/
|
||||
'reuse_connection': (_google_protobuf_BoolValue__Output);
|
||||
'reuse_connection'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* HTTP health check.
|
||||
*/
|
||||
@ -537,7 +537,7 @@ export interface HealthCheck__Output {
|
||||
*
|
||||
* The default value for "no traffic interval" is 60 seconds.
|
||||
*/
|
||||
'no_traffic_interval': (_google_protobuf_Duration__Output);
|
||||
'no_traffic_interval'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Custom health check.
|
||||
*/
|
||||
@ -549,7 +549,7 @@ export interface HealthCheck__Output {
|
||||
*
|
||||
* The default value for "unhealthy interval" is the same as "interval".
|
||||
*/
|
||||
'unhealthy_interval': (_google_protobuf_Duration__Output);
|
||||
'unhealthy_interval'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* The "unhealthy edge interval" is a special health check interval that is used for the first
|
||||
* health check right after a host is marked as unhealthy. For subsequent health checks
|
||||
@ -558,7 +558,7 @@ export interface HealthCheck__Output {
|
||||
*
|
||||
* The default value for "unhealthy edge interval" is the same as "unhealthy interval".
|
||||
*/
|
||||
'unhealthy_edge_interval': (_google_protobuf_Duration__Output);
|
||||
'unhealthy_edge_interval'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* The "healthy edge interval" is a special health check interval that is used for the first
|
||||
* health check right after a host is marked as healthy. For subsequent health checks
|
||||
@ -566,7 +566,7 @@ export interface HealthCheck__Output {
|
||||
*
|
||||
* The default value for "healthy edge interval" is the same as the default interval.
|
||||
*/
|
||||
'healthy_edge_interval': (_google_protobuf_Duration__Output);
|
||||
'healthy_edge_interval'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Specifies the path to the :ref:`health check event log <arch_overview_health_check_logging>`.
|
||||
* If empty, no event log will be written.
|
||||
@ -592,16 +592,16 @@ export interface HealthCheck__Output {
|
||||
* checking after for a random time in ms between 0 and initial_jitter. This only
|
||||
* applies to the first health check.
|
||||
*/
|
||||
'initial_jitter': (_google_protobuf_Duration__Output);
|
||||
'initial_jitter'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* This allows overriding the cluster TLS settings, just for health check connections.
|
||||
*/
|
||||
'tls_options': (_envoy_api_v2_core_HealthCheck_TlsOptions__Output);
|
||||
'tls_options'?: (_envoy_api_v2_core_HealthCheck_TlsOptions__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:]
|
||||
* The gRPC service for the health check event service.
|
||||
* If empty, health check events won't be sent to a remote endpoint.
|
||||
*/
|
||||
'event_service': (_envoy_api_v2_core_EventServiceConfig__Output);
|
||||
'event_service'?: (_envoy_api_v2_core_EventServiceConfig__Output);
|
||||
'health_checker': "http_health_check"|"tcp_health_check"|"grpc_health_check"|"custom_health_check";
|
||||
}
|
||||
|
||||
@ -85,7 +85,7 @@ export interface Http1ProtocolOptions__Output {
|
||||
* envoy as their HTTP proxy. In Unix, for example, this is typically done by setting the
|
||||
* *http_proxy* environment variable.
|
||||
*/
|
||||
'allow_absolute_url': (_google_protobuf_BoolValue__Output);
|
||||
'allow_absolute_url'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Handle incoming HTTP/1.0 and HTTP 0.9 requests.
|
||||
* This is off by default, and not fully standards compliant. There is support for pre-HTTP/1.1
|
||||
@ -103,7 +103,7 @@ export interface Http1ProtocolOptions__Output {
|
||||
* Describes how the keys for response headers should be formatted. By default, all header keys
|
||||
* are lower cased.
|
||||
*/
|
||||
'header_key_format': (_envoy_api_v2_core_Http1ProtocolOptions_HeaderKeyFormat__Output);
|
||||
'header_key_format'?: (_envoy_api_v2_core_Http1ProtocolOptions_HeaderKeyFormat__Output);
|
||||
/**
|
||||
* Enables trailers for HTTP/1. By default the HTTP/1 codec drops proxied trailers.
|
||||
*
|
||||
|
||||
@ -25,11 +25,11 @@ export interface _envoy_api_v2_core_Http2ProtocolOptions_SettingsParameter__Outp
|
||||
/**
|
||||
* The 16 bit parameter identifier.
|
||||
*/
|
||||
'identifier': (_google_protobuf_UInt32Value__Output);
|
||||
'identifier'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The 32 bit parameter value.
|
||||
*/
|
||||
'value': (_google_protobuf_UInt32Value__Output);
|
||||
'value'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -188,7 +188,7 @@ export interface Http2ProtocolOptions__Output {
|
||||
* range from 0 to 4294967295 (2^32 - 1) and defaults to 4096. 0 effectively disables header
|
||||
* compression.
|
||||
*/
|
||||
'hpack_table_size': (_google_protobuf_UInt32Value__Output);
|
||||
'hpack_table_size'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* `Maximum concurrent streams <https://httpwg.org/specs/rfc7540.html#rfc.section.5.1.2>`_
|
||||
* allowed for peer on one HTTP/2 connection. Valid values range from 1 to 2147483647 (2^31 - 1)
|
||||
@ -198,7 +198,7 @@ export interface Http2ProtocolOptions__Output {
|
||||
* on a single connection. If the limit is reached, Envoy may queue requests or establish
|
||||
* additional connections (as allowed per circuit breaker limits).
|
||||
*/
|
||||
'max_concurrent_streams': (_google_protobuf_UInt32Value__Output);
|
||||
'max_concurrent_streams'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* `Initial stream-level flow-control window
|
||||
* <https://httpwg.org/specs/rfc7540.html#rfc.section.6.9.2>`_ size. Valid values range from 65535
|
||||
@ -212,12 +212,12 @@ export interface Http2ProtocolOptions__Output {
|
||||
* HTTP/2 codec buffers. Once the buffer reaches this pointer, watermark callbacks will fire to
|
||||
* stop the flow of data to the codec buffers.
|
||||
*/
|
||||
'initial_stream_window_size': (_google_protobuf_UInt32Value__Output);
|
||||
'initial_stream_window_size'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Similar to *initial_stream_window_size*, but for connection-level flow-control
|
||||
* window. Currently, this has the same minimum/maximum/default as *initial_stream_window_size*.
|
||||
*/
|
||||
'initial_connection_window_size': (_google_protobuf_UInt32Value__Output);
|
||||
'initial_connection_window_size'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Allows proxying Websocket and other upgrades over H2 connect.
|
||||
*/
|
||||
@ -238,7 +238,7 @@ export interface Http2ProtocolOptions__Output {
|
||||
* to flood mitigation. The default limit is 10000.
|
||||
* [#comment:TODO: implement same limits for upstream outbound frames as well.]
|
||||
*/
|
||||
'max_outbound_frames': (_google_protobuf_UInt32Value__Output);
|
||||
'max_outbound_frames'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Limit the number of pending outbound downstream frames of types PING, SETTINGS and RST_STREAM,
|
||||
* preventing high memory utilization when receiving continuous stream of these frames. Exceeding
|
||||
@ -247,7 +247,7 @@ export interface Http2ProtocolOptions__Output {
|
||||
* mitigation. The default limit is 1000.
|
||||
* [#comment:TODO: implement same limits for upstream outbound frames as well.]
|
||||
*/
|
||||
'max_outbound_control_frames': (_google_protobuf_UInt32Value__Output);
|
||||
'max_outbound_control_frames'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Limit the number of consecutive inbound frames of types HEADERS, CONTINUATION and DATA with an
|
||||
* empty payload and no end stream flag. Those frames have no legitimate use and are abusive, but
|
||||
@ -257,7 +257,7 @@ export interface Http2ProtocolOptions__Output {
|
||||
* and no end stream flag. The default limit is 1.
|
||||
* [#comment:TODO: implement same limits for upstream inbound frames as well.]
|
||||
*/
|
||||
'max_consecutive_inbound_frames_with_empty_payload': (_google_protobuf_UInt32Value__Output);
|
||||
'max_consecutive_inbound_frames_with_empty_payload'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Limit the number of inbound PRIORITY frames allowed per each opened stream. If the number
|
||||
* of PRIORITY frames received over the lifetime of connection exceeds the value calculated
|
||||
@ -269,7 +269,7 @@ export interface Http2ProtocolOptions__Output {
|
||||
* the number of connections terminated due to flood mitigation. The default limit is 100.
|
||||
* [#comment:TODO: implement same limits for upstream inbound frames as well.]
|
||||
*/
|
||||
'max_inbound_priority_frames_per_stream': (_google_protobuf_UInt32Value__Output);
|
||||
'max_inbound_priority_frames_per_stream'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Limit the number of inbound WINDOW_UPDATE frames allowed per DATA frame sent. If the number
|
||||
* of WINDOW_UPDATE frames received over the lifetime of connection exceeds the value calculated
|
||||
@ -284,7 +284,7 @@ export interface Http2ProtocolOptions__Output {
|
||||
* but more complex implementations that try to estimate available bandwidth require at least 2.
|
||||
* [#comment:TODO: implement same limits for upstream inbound frames as well.]
|
||||
*/
|
||||
'max_inbound_window_update_frames_per_data_frame_sent': (_google_protobuf_UInt32Value__Output);
|
||||
'max_inbound_window_update_frames_per_data_frame_sent'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Allows invalid HTTP messaging and headers. When this option is disabled (default), then
|
||||
* the whole HTTP/2 connection is terminated upon receiving invalid HEADERS frame. However,
|
||||
|
||||
@ -96,13 +96,13 @@ export interface HttpProtocolOptions__Output {
|
||||
* Disabling this timeout has a highly likelihood of yielding connection leaks due to lost TCP
|
||||
* FIN packets, etc.
|
||||
*/
|
||||
'idle_timeout': (_google_protobuf_Duration__Output);
|
||||
'idle_timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* The maximum number of headers. If unconfigured, the default
|
||||
* maximum number of request headers allowed is 100. Requests that exceed this limit will receive
|
||||
* a 431 response for HTTP/1.x and cause a stream reset for HTTP/2.
|
||||
*/
|
||||
'max_headers_count': (_google_protobuf_UInt32Value__Output);
|
||||
'max_headers_count'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The maximum duration of a connection. The duration is defined as a period since a connection
|
||||
* was established. If not set, there is no max duration. When max_connection_duration is reached
|
||||
@ -111,12 +111,12 @@ export interface HttpProtocolOptions__Output {
|
||||
* <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.drain_timeout>`.
|
||||
* Note: not implemented for upstream connections.
|
||||
*/
|
||||
'max_connection_duration': (_google_protobuf_Duration__Output);
|
||||
'max_connection_duration'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Total duration to keep alive an HTTP request/response stream. If the time limit is reached the stream will be
|
||||
* reset independent of any other timeouts. If not specified, this value is not set.
|
||||
*/
|
||||
'max_stream_duration': (_google_protobuf_Duration__Output);
|
||||
'max_stream_duration'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Action to take when a client request with a header name containing underscore characters is received.
|
||||
* If this setting is not specified, the value defaults to ALLOW.
|
||||
|
||||
@ -68,7 +68,7 @@ export interface HttpUri__Output {
|
||||
/**
|
||||
* Sets the maximum duration in milliseconds that a response can take to arrive upon request.
|
||||
*/
|
||||
'timeout': (_google_protobuf_Duration__Output);
|
||||
'timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Specify how `uri` is to be fetched. Today, this requires an explicit
|
||||
* cluster, but in the future we may support dynamic cluster creation or
|
||||
|
||||
@ -31,7 +31,7 @@ export interface Metadata {
|
||||
* Key is the reverse DNS filter name, e.g. com.acme.widget. The envoy.*
|
||||
* namespace is reserved for Envoy's built-in filters.
|
||||
*/
|
||||
'filter_metadata'?: (_google_protobuf_Struct);
|
||||
'filter_metadata'?: ({[key: string]: _google_protobuf_Struct});
|
||||
}
|
||||
|
||||
/**
|
||||
@ -63,5 +63,5 @@ export interface Metadata__Output {
|
||||
* Key is the reverse DNS filter name, e.g. com.acme.widget. The envoy.*
|
||||
* namespace is reserved for Envoy's built-in filters.
|
||||
*/
|
||||
'filter_metadata': (_google_protobuf_Struct__Output);
|
||||
'filter_metadata'?: ({[key: string]: _google_protobuf_Struct__Output});
|
||||
}
|
||||
|
||||
@ -124,11 +124,11 @@ export interface Node__Output {
|
||||
* Opaque metadata extending the node identifier. Envoy will pass this
|
||||
* directly to the management server.
|
||||
*/
|
||||
'metadata': (_google_protobuf_Struct__Output);
|
||||
'metadata'?: (_google_protobuf_Struct__Output);
|
||||
/**
|
||||
* Locality specifying where the Envoy instance is running.
|
||||
*/
|
||||
'locality': (_envoy_api_v2_core_Locality__Output);
|
||||
'locality'?: (_envoy_api_v2_core_Locality__Output);
|
||||
/**
|
||||
* This is motivated by informing a management server during canary which
|
||||
* version of Envoy is being tested in a heterogeneous fleet. This will be set
|
||||
|
||||
@ -27,10 +27,10 @@ export interface RateLimitSettings__Output {
|
||||
* Maximum number of tokens to be used for rate limiting discovery request calls. If not set, a
|
||||
* default value of 100 will be used.
|
||||
*/
|
||||
'max_tokens': (_google_protobuf_UInt32Value__Output);
|
||||
'max_tokens'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Rate at which tokens will be filled per second. If not set, a default fill rate of 10 tokens
|
||||
* per second will be used.
|
||||
*/
|
||||
'fill_rate': (_google_protobuf_DoubleValue__Output);
|
||||
'fill_rate'?: (_google_protobuf_DoubleValue__Output);
|
||||
}
|
||||
|
||||
@ -28,7 +28,7 @@ export interface RemoteDataSource__Output {
|
||||
/**
|
||||
* The HTTP URI to fetch the remote data.
|
||||
*/
|
||||
'http_uri': (_envoy_api_v2_core_HttpUri__Output);
|
||||
'http_uri'?: (_envoy_api_v2_core_HttpUri__Output);
|
||||
/**
|
||||
* SHA256 string for verifying data.
|
||||
*/
|
||||
@ -36,5 +36,5 @@ export interface RemoteDataSource__Output {
|
||||
/**
|
||||
* Retry policy for fetching remote data.
|
||||
*/
|
||||
'retry_policy': (_envoy_api_v2_core_RetryPolicy__Output);
|
||||
'retry_policy'?: (_envoy_api_v2_core_RetryPolicy__Output);
|
||||
}
|
||||
|
||||
@ -29,10 +29,10 @@ export interface RetryPolicy__Output {
|
||||
* This parameter is optional, in which case the default base interval is 1000 milliseconds. The
|
||||
* default maximum interval is 10 times the base interval.
|
||||
*/
|
||||
'retry_back_off': (_envoy_api_v2_core_BackoffStrategy__Output);
|
||||
'retry_back_off'?: (_envoy_api_v2_core_BackoffStrategy__Output);
|
||||
/**
|
||||
* Specifies the allowed number of retries. This parameter is optional and
|
||||
* defaults to 1.
|
||||
*/
|
||||
'num_retries': (_google_protobuf_UInt32Value__Output);
|
||||
'num_retries'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
@ -25,7 +25,7 @@ export interface RuntimeFeatureFlag__Output {
|
||||
/**
|
||||
* Default value if runtime value is not available.
|
||||
*/
|
||||
'default_value': (_google_protobuf_BoolValue__Output);
|
||||
'default_value'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Runtime key to get value for comparison. This value is used if defined. The boolean value must
|
||||
* be represented via its
|
||||
|
||||
@ -41,7 +41,7 @@ export interface RuntimeFractionalPercent__Output {
|
||||
/**
|
||||
* Default value if the runtime value's for the numerator/denominator keys are not available.
|
||||
*/
|
||||
'default_value': (_envoy_type_FractionalPercent__Output);
|
||||
'default_value'?: (_envoy_type_FractionalPercent__Output);
|
||||
/**
|
||||
* Runtime key for a YAML representation of a FractionalPercent.
|
||||
*/
|
||||
|
||||
@ -28,16 +28,16 @@ export interface TcpKeepalive__Output {
|
||||
* the connection is dead. Default is to use the OS level configuration (unless
|
||||
* overridden, Linux defaults to 9.)
|
||||
*/
|
||||
'keepalive_probes': (_google_protobuf_UInt32Value__Output);
|
||||
'keepalive_probes'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The number of seconds a connection needs to be idle before keep-alive probes
|
||||
* start being sent. Default is to use the OS level configuration (unless
|
||||
* overridden, Linux defaults to 7200s (i.e., 2 hours.)
|
||||
*/
|
||||
'keepalive_time': (_google_protobuf_UInt32Value__Output);
|
||||
'keepalive_time'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The number of seconds between keep-alive probes. Default is to use the OS
|
||||
* level configuration (unless overridden, Linux defaults to 75s.)
|
||||
*/
|
||||
'keepalive_interval': (_google_protobuf_UInt32Value__Output);
|
||||
'keepalive_interval'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
@ -98,7 +98,7 @@ export interface Endpoint__Output {
|
||||
* in the Address). For LOGICAL or STRICT DNS, it is expected to be hostname,
|
||||
* and will be resolved via DNS.
|
||||
*/
|
||||
'address': (_envoy_api_v2_core_Address__Output);
|
||||
'address'?: (_envoy_api_v2_core_Address__Output);
|
||||
/**
|
||||
* The optional health check configuration is used as configuration for the
|
||||
* health checker to contact the health checked host.
|
||||
@ -108,7 +108,7 @@ export interface Endpoint__Output {
|
||||
* This takes into effect only for upstream clusters with
|
||||
* :ref:`active health checking <arch_overview_health_checking>` enabled.
|
||||
*/
|
||||
'health_check_config': (_envoy_api_v2_endpoint_Endpoint_HealthCheckConfig__Output);
|
||||
'health_check_config'?: (_envoy_api_v2_endpoint_Endpoint_HealthCheckConfig__Output);
|
||||
/**
|
||||
* The hostname associated with this endpoint. This hostname is not used for routing or address
|
||||
* resolution. If provided, it will be associated with the endpoint, and can be used for features
|
||||
|
||||
@ -66,7 +66,7 @@ export interface LbEndpoint__Output {
|
||||
* :ref:`RouteAction <envoy_api_msg_route.RouteAction>` metadata_match field
|
||||
* to subset the endpoints considered in cluster load balancing.
|
||||
*/
|
||||
'metadata': (_envoy_api_v2_core_Metadata__Output);
|
||||
'metadata'?: (_envoy_api_v2_core_Metadata__Output);
|
||||
/**
|
||||
* The optional load balancing weight of the upstream host; at least 1.
|
||||
* Envoy uses the load balancing weight in some of the built in load
|
||||
@ -78,7 +78,7 @@ export interface LbEndpoint__Output {
|
||||
* weight in a locality. The sum of the weights of all endpoints in the
|
||||
* endpoint's locality must not exceed uint32_t maximal value (4294967295).
|
||||
*/
|
||||
'load_balancing_weight': (_google_protobuf_UInt32Value__Output);
|
||||
'load_balancing_weight'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
|
||||
@ -68,7 +68,7 @@ export interface LocalityLbEndpoints__Output {
|
||||
/**
|
||||
* Identifies location of where the upstream hosts run.
|
||||
*/
|
||||
'locality': (_envoy_api_v2_core_Locality__Output);
|
||||
'locality'?: (_envoy_api_v2_core_Locality__Output);
|
||||
/**
|
||||
* The group of endpoints belonging to the locality specified.
|
||||
*/
|
||||
@ -86,7 +86,7 @@ export interface LocalityLbEndpoints__Output {
|
||||
* specified when locality weighted load balancing is enabled, the locality is
|
||||
* assigned no load.
|
||||
*/
|
||||
'load_balancing_weight': (_google_protobuf_UInt32Value__Output);
|
||||
'load_balancing_weight'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Optional: the priority for this LocalityLbEndpoints. If unspecified this will
|
||||
* default to the highest priority (0).
|
||||
@ -107,5 +107,5 @@ export interface LocalityLbEndpoints__Output {
|
||||
* to determine where to route the requests.
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
'proximity': (_google_protobuf_UInt32Value__Output);
|
||||
'proximity'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
@ -71,7 +71,7 @@ export interface FilterChain__Output {
|
||||
/**
|
||||
* The criteria to use when matching a connection to this filter chain.
|
||||
*/
|
||||
'filter_chain_match': (_envoy_api_v2_listener_FilterChainMatch__Output);
|
||||
'filter_chain_match'?: (_envoy_api_v2_listener_FilterChainMatch__Output);
|
||||
/**
|
||||
* The TLS context for this filter chain.
|
||||
*
|
||||
@ -80,7 +80,7 @@ export interface FilterChain__Output {
|
||||
* **This field is deprecated**. Use `transport_socket` with name `tls` instead. If both are
|
||||
* set, `transport_socket` takes priority.
|
||||
*/
|
||||
'tls_context': (_envoy_api_v2_auth_DownstreamTlsContext__Output);
|
||||
'tls_context'?: (_envoy_api_v2_auth_DownstreamTlsContext__Output);
|
||||
/**
|
||||
* A list of individual network filters that make up the filter chain for
|
||||
* connections established with the listener. Order matters as the filters are
|
||||
@ -96,11 +96,11 @@ export interface FilterChain__Output {
|
||||
* absent or set to false, Envoy will use the physical peer address of the
|
||||
* connection as the remote address.
|
||||
*/
|
||||
'use_proxy_proto': (_google_protobuf_BoolValue__Output);
|
||||
'use_proxy_proto'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:] filter chain metadata.
|
||||
*/
|
||||
'metadata': (_envoy_api_v2_core_Metadata__Output);
|
||||
'metadata'?: (_envoy_api_v2_core_Metadata__Output);
|
||||
/**
|
||||
* Optional custom transport socket implementation to use for downstream connections.
|
||||
* To setup TLS, set a transport socket with name `tls` and
|
||||
@ -108,7 +108,7 @@ export interface FilterChain__Output {
|
||||
* If no transport socket configuration is specified, new connections
|
||||
* will be set up with plaintext.
|
||||
*/
|
||||
'transport_socket': (_envoy_api_v2_core_TransportSocket__Output);
|
||||
'transport_socket'?: (_envoy_api_v2_core_TransportSocket__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:] The unique name (or empty) by which this filter chain is known. If no
|
||||
* name is provided, Envoy will allocate an internal UUID for the filter chain. If the filter
|
||||
|
||||
@ -187,7 +187,7 @@ export interface FilterChainMatch__Output {
|
||||
/**
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
'suffix_len': (_google_protobuf_UInt32Value__Output);
|
||||
'suffix_len'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The criteria is satisfied if the source IP address of the downstream
|
||||
* connection is contained in at least one of the specified subnets. If the
|
||||
@ -205,7 +205,7 @@ export interface FilterChainMatch__Output {
|
||||
* Optional destination port to consider when use_original_dst is set on the
|
||||
* listener in determining a filter chain match.
|
||||
*/
|
||||
'destination_port': (_google_protobuf_UInt32Value__Output);
|
||||
'destination_port'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* If non-empty, a transport protocol to consider when determining a filter chain match.
|
||||
* This value will be compared against the transport protocol of a new connection, when
|
||||
|
||||
@ -38,7 +38,7 @@ export interface ListenerFilter__Output {
|
||||
* See :ref:`ListenerFilterChainMatchPredicate <envoy_api_msg_listener.ListenerFilterChainMatchPredicate>`
|
||||
* for further examples.
|
||||
*/
|
||||
'filter_disabled': (_envoy_api_v2_listener_ListenerFilterChainMatchPredicate__Output);
|
||||
'filter_disabled'?: (_envoy_api_v2_listener_ListenerFilterChainMatchPredicate__Output);
|
||||
/**
|
||||
* Filter specific configuration which depends on the filter being instantiated.
|
||||
* See the supported filters for further documentation.
|
||||
|
||||
@ -118,7 +118,7 @@ export interface CorsPolicy__Output {
|
||||
/**
|
||||
* Specifies whether the resource allows credentials.
|
||||
*/
|
||||
'allow_credentials': (_google_protobuf_BoolValue__Output);
|
||||
'allow_credentials'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Specifies if the CORS filter is enabled. Defaults to true. Only effective on route.
|
||||
*
|
||||
@ -159,7 +159,7 @@ export interface CorsPolicy__Output {
|
||||
* Envoy will lookup the runtime key to get the percentage of requests for which it will evaluate
|
||||
* and track the request's *Origin* to determine if it's valid but will not enforce any policies.
|
||||
*/
|
||||
'shadow_enabled': (_envoy_api_v2_core_RuntimeFractionalPercent__Output);
|
||||
'shadow_enabled'?: (_envoy_api_v2_core_RuntimeFractionalPercent__Output);
|
||||
/**
|
||||
* Specifies string patterns that match allowed origins. An origin is allowed if any of the
|
||||
* string matchers match.
|
||||
|
||||
@ -35,5 +35,5 @@ export interface Decorator__Output {
|
||||
/**
|
||||
* Whether the decorated details should be propagated to the other party. The default is true.
|
||||
*/
|
||||
'propagate': (_google_protobuf_BoolValue__Output);
|
||||
'propagate'?: (_google_protobuf_BoolValue__Output);
|
||||
}
|
||||
|
||||
@ -35,5 +35,5 @@ export interface DirectResponseAction__Output {
|
||||
* :ref:`envoy_api_msg_route.Route`, :ref:`envoy_api_msg_RouteConfiguration` or
|
||||
* :ref:`envoy_api_msg_route.VirtualHost`.
|
||||
*/
|
||||
'body': (_envoy_api_v2_core_DataSource__Output);
|
||||
'body'?: (_envoy_api_v2_core_DataSource__Output);
|
||||
}
|
||||
|
||||
@ -13,5 +13,5 @@ export interface FilterAction {
|
||||
* A filter-defined action type.
|
||||
*/
|
||||
export interface FilterAction__Output {
|
||||
'action': (_google_protobuf_Any__Output);
|
||||
'action'?: (_google_protobuf_Any__Output);
|
||||
}
|
||||
|
||||
@ -44,14 +44,14 @@ export interface HedgePolicy__Output {
|
||||
* Defaults to 1.
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
'initial_requests': (_google_protobuf_UInt32Value__Output);
|
||||
'initial_requests'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Specifies a probability that an additional upstream request should be sent
|
||||
* on top of what is specified by initial_requests.
|
||||
* Defaults to 0.
|
||||
* [#not-implemented-hide:]
|
||||
*/
|
||||
'additional_request_chance': (_envoy_type_FractionalPercent__Output);
|
||||
'additional_request_chance'?: (_envoy_type_FractionalPercent__Output);
|
||||
/**
|
||||
* Indicates that a hedged request should be sent when the per-try timeout
|
||||
* is hit. This will only occur if the retry policy also indicates that a
|
||||
|
||||
@ -73,7 +73,7 @@ export interface QueryParameterMatcher__Output {
|
||||
* ..attention::
|
||||
* This field is deprecated. Use a `safe_regex` match inside the `string_match` field.
|
||||
*/
|
||||
'regex': (_google_protobuf_BoolValue__Output);
|
||||
'regex'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Specifies whether a query parameter value should match against a string.
|
||||
*/
|
||||
|
||||
@ -183,7 +183,7 @@ export interface _envoy_api_v2_route_RateLimit_Action_HeaderValueMatch__Output {
|
||||
* descriptor entry when the request does not match the headers. The
|
||||
* default value is true.
|
||||
*/
|
||||
'expect_match': (_google_protobuf_BoolValue__Output);
|
||||
'expect_match'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Specifies a set of headers that the rate limit action should match
|
||||
* on. The action will check the request’s headers against all the
|
||||
@ -324,7 +324,7 @@ export interface RateLimit__Output {
|
||||
*
|
||||
* The filter supports a range of 0 - 10 inclusively for stage numbers.
|
||||
*/
|
||||
'stage': (_google_protobuf_UInt32Value__Output);
|
||||
'stage'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* The key to be set in runtime to disable this rate limit configuration.
|
||||
*/
|
||||
|
||||
@ -31,14 +31,14 @@ export interface _envoy_api_v2_route_RetryPolicy_RetryBackOff__Output {
|
||||
* See :ref:`config_http_filters_router_x-envoy-max-retries` for a discussion of Envoy's
|
||||
* back-off algorithm.
|
||||
*/
|
||||
'base_interval': (_google_protobuf_Duration__Output);
|
||||
'base_interval'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Specifies the maximum interval between retries. This parameter is optional, but must be
|
||||
* greater than or equal to the `base_interval` if set. The default is 10 times the
|
||||
* `base_interval`. See :ref:`config_http_filters_router_x-envoy-max-retries` for a discussion
|
||||
* of Envoy's back-off algorithm.
|
||||
*/
|
||||
'max_interval': (_google_protobuf_Duration__Output);
|
||||
'max_interval'?: (_google_protobuf_Duration__Output);
|
||||
}
|
||||
|
||||
export interface _envoy_api_v2_route_RetryPolicy_RetryHostPredicate {
|
||||
@ -159,7 +159,7 @@ export interface RetryPolicy__Output {
|
||||
* defaults to 1. These are the same conditions documented for
|
||||
* :ref:`config_http_filters_router_x-envoy-max-retries`.
|
||||
*/
|
||||
'num_retries': (_google_protobuf_UInt32Value__Output);
|
||||
'num_retries'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Specifies a non-zero upstream timeout per retry attempt. This parameter is optional. The
|
||||
* same conditions documented for
|
||||
@ -173,13 +173,13 @@ export interface RetryPolicy__Output {
|
||||
* retry policy, a request that times out will not be retried as the total timeout budget
|
||||
* would have been exhausted.
|
||||
*/
|
||||
'per_try_timeout': (_google_protobuf_Duration__Output);
|
||||
'per_try_timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Specifies an implementation of a RetryPriority which is used to determine the
|
||||
* distribution of load across priorities used for retries. Refer to
|
||||
* :ref:`retry plugin configuration <arch_overview_http_retry_plugins>` for more details.
|
||||
*/
|
||||
'retry_priority': (_envoy_api_v2_route_RetryPolicy_RetryPriority__Output);
|
||||
'retry_priority'?: (_envoy_api_v2_route_RetryPolicy_RetryPriority__Output);
|
||||
/**
|
||||
* Specifies a collection of RetryHostPredicates that will be consulted when selecting a host
|
||||
* for retries. If any of the predicates reject the host, host selection will be reattempted.
|
||||
@ -204,7 +204,7 @@ export interface RetryPolicy__Output {
|
||||
* the base interval. The documentation for :ref:`config_http_filters_router_x-envoy-max-retries`
|
||||
* describes Envoy's back-off algorithm.
|
||||
*/
|
||||
'retry_back_off': (_envoy_api_v2_route_RetryPolicy_RetryBackOff__Output);
|
||||
'retry_back_off'?: (_envoy_api_v2_route_RetryPolicy_RetryBackOff__Output);
|
||||
/**
|
||||
* HTTP response headers that trigger a retry if present in the response. A retry will be
|
||||
* triggered if any of the header matches match the upstream response headers.
|
||||
|
||||
@ -59,7 +59,7 @@ export interface Route {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>` for
|
||||
* if and how it is utilized.
|
||||
*/
|
||||
'per_filter_config'?: (_google_protobuf_Struct);
|
||||
'per_filter_config'?: ({[key: string]: _google_protobuf_Struct});
|
||||
/**
|
||||
* Specifies a set of headers that will be added to requests matching this
|
||||
* route. Headers specified at this level are applied before headers from the
|
||||
@ -95,7 +95,7 @@ export interface Route {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>` for
|
||||
* if and how it is utilized.
|
||||
*/
|
||||
'typed_per_filter_config'?: (_google_protobuf_Any);
|
||||
'typed_per_filter_config'?: ({[key: string]: _google_protobuf_Any});
|
||||
/**
|
||||
* Name for the route.
|
||||
*/
|
||||
@ -134,7 +134,7 @@ export interface Route__Output {
|
||||
/**
|
||||
* Route matching parameters.
|
||||
*/
|
||||
'match': (_envoy_api_v2_route_RouteMatch__Output);
|
||||
'match'?: (_envoy_api_v2_route_RouteMatch__Output);
|
||||
/**
|
||||
* Route request to some upstream cluster.
|
||||
*/
|
||||
@ -150,11 +150,11 @@ export interface Route__Output {
|
||||
* For instance, if the metadata is intended for the Router filter,
|
||||
* the filter name should be specified as *envoy.filters.http.router*.
|
||||
*/
|
||||
'metadata': (_envoy_api_v2_core_Metadata__Output);
|
||||
'metadata'?: (_envoy_api_v2_core_Metadata__Output);
|
||||
/**
|
||||
* Decorator for the matched route.
|
||||
*/
|
||||
'decorator': (_envoy_api_v2_route_Decorator__Output);
|
||||
'decorator'?: (_envoy_api_v2_route_Decorator__Output);
|
||||
/**
|
||||
* Return an arbitrary HTTP response directly, without proxying.
|
||||
*/
|
||||
@ -166,7 +166,7 @@ export interface Route__Output {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>` for
|
||||
* if and how it is utilized.
|
||||
*/
|
||||
'per_filter_config': (_google_protobuf_Struct__Output);
|
||||
'per_filter_config'?: ({[key: string]: _google_protobuf_Struct__Output});
|
||||
/**
|
||||
* Specifies a set of headers that will be added to requests matching this
|
||||
* route. Headers specified at this level are applied before headers from the
|
||||
@ -202,7 +202,7 @@ export interface Route__Output {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>` for
|
||||
* if and how it is utilized.
|
||||
*/
|
||||
'typed_per_filter_config': (_google_protobuf_Any__Output);
|
||||
'typed_per_filter_config'?: ({[key: string]: _google_protobuf_Any__Output});
|
||||
/**
|
||||
* Name for the route.
|
||||
*/
|
||||
@ -211,13 +211,13 @@ export interface Route__Output {
|
||||
* Presence of the object defines whether the connection manager's tracing configuration
|
||||
* is overridden by this route specific instance.
|
||||
*/
|
||||
'tracing': (_envoy_api_v2_route_Tracing__Output);
|
||||
'tracing'?: (_envoy_api_v2_route_Tracing__Output);
|
||||
/**
|
||||
* The maximum bytes which will be buffered for retries and shadowing.
|
||||
* If set, the bytes actually buffered will be the minimum value of this and the
|
||||
* listener per_connection_buffer_limit_bytes.
|
||||
*/
|
||||
'per_request_buffer_limit_bytes': (_google_protobuf_UInt32Value__Output);
|
||||
'per_request_buffer_limit_bytes'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:]
|
||||
* If true, a filter will define the action (e.g., it could dynamically generate the
|
||||
|
||||
@ -105,7 +105,7 @@ export interface _envoy_api_v2_route_RouteAction_HashPolicy_Cookie__Output {
|
||||
* not present. If the TTL is present and zero, the generated cookie will
|
||||
* be a session cookie.
|
||||
*/
|
||||
'ttl': (_google_protobuf_Duration__Output);
|
||||
'ttl'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* The name of the path for the cookie. If no path is specified here, no path
|
||||
* will be set for the cookie.
|
||||
@ -378,11 +378,11 @@ export interface _envoy_api_v2_route_RouteAction_RequestMirrorPolicy__Output {
|
||||
* number is <= the value of the numerator N, or if the key is not present, the default
|
||||
* value, the request will be mirrored.
|
||||
*/
|
||||
'runtime_fraction': (_envoy_api_v2_core_RuntimeFractionalPercent__Output);
|
||||
'runtime_fraction'?: (_envoy_api_v2_core_RuntimeFractionalPercent__Output);
|
||||
/**
|
||||
* Determines if the trace span should be sampled. Defaults to true.
|
||||
*/
|
||||
'trace_sampled': (_google_protobuf_BoolValue__Output);
|
||||
'trace_sampled'?: (_google_protobuf_BoolValue__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -424,7 +424,7 @@ export interface _envoy_api_v2_route_RouteAction_UpgradeConfig__Output {
|
||||
/**
|
||||
* Determines if upgrades are available on this route. Defaults to true.
|
||||
*/
|
||||
'enabled': (_google_protobuf_BoolValue__Output);
|
||||
'enabled'?: (_google_protobuf_BoolValue__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -751,7 +751,7 @@ export interface RouteAction__Output {
|
||||
* <envoy_api_field_route.RouteAction.weighted_clusters>`, metadata will be merged, with values
|
||||
* provided there taking precedence. The filter name should be specified as *envoy.lb*.
|
||||
*/
|
||||
'metadata_match': (_envoy_api_v2_core_Metadata__Output);
|
||||
'metadata_match'?: (_envoy_api_v2_core_Metadata__Output);
|
||||
/**
|
||||
* Indicates that during forwarding, the matched prefix (or path) should be
|
||||
* swapped with this value. This option allows application URLs to be rooted
|
||||
@ -812,13 +812,13 @@ export interface RouteAction__Output {
|
||||
* :ref:`config_http_filters_router_x-envoy-upstream-rq-per-try-timeout-ms`, and the
|
||||
* :ref:`retry overview <arch_overview_http_routing_retry>`.
|
||||
*/
|
||||
'timeout': (_google_protobuf_Duration__Output);
|
||||
'timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Indicates that the route has a retry policy. Note that if this is set,
|
||||
* it'll take precedence over the virtual host level retry policy entirely
|
||||
* (e.g.: policies are not merged, most internal one becomes the enforced policy).
|
||||
*/
|
||||
'retry_policy': (_envoy_api_v2_route_RetryPolicy__Output);
|
||||
'retry_policy'?: (_envoy_api_v2_route_RetryPolicy__Output);
|
||||
/**
|
||||
* Indicates that the route has a request mirroring policy.
|
||||
*
|
||||
@ -826,7 +826,7 @@ export interface RouteAction__Output {
|
||||
* This field has been deprecated in favor of `request_mirror_policies` which supports one or
|
||||
* more mirroring policies.
|
||||
*/
|
||||
'request_mirror_policy': (_envoy_api_v2_route_RouteAction_RequestMirrorPolicy__Output);
|
||||
'request_mirror_policy'?: (_envoy_api_v2_route_RouteAction_RequestMirrorPolicy__Output);
|
||||
/**
|
||||
* Optionally specifies the :ref:`routing priority <arch_overview_http_routing_priority>`.
|
||||
*/
|
||||
@ -842,7 +842,7 @@ export interface RouteAction__Output {
|
||||
* :ref:`rate_limits <envoy_api_field_route.VirtualHost.rate_limits>` are not applied to the
|
||||
* request.
|
||||
*/
|
||||
'include_vh_rate_limits': (_google_protobuf_BoolValue__Output);
|
||||
'include_vh_rate_limits'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Specifies a list of hash policies to use for ring hash load balancing. Each
|
||||
* hash policy is evaluated individually and the combined result is used to
|
||||
@ -861,7 +861,7 @@ export interface RouteAction__Output {
|
||||
/**
|
||||
* Indicates that the route has a CORS policy.
|
||||
*/
|
||||
'cors': (_envoy_api_v2_route_CorsPolicy__Output);
|
||||
'cors'?: (_envoy_api_v2_route_CorsPolicy__Output);
|
||||
/**
|
||||
* The HTTP status code to use when configured cluster is not found.
|
||||
* The default response code is 503 Service Unavailable.
|
||||
@ -888,7 +888,7 @@ export interface RouteAction__Output {
|
||||
* :ref:`config_http_filters_router_x-envoy-upstream-rq-per-try-timeout-ms`, and the
|
||||
* :ref:`retry overview <arch_overview_http_routing_retry>`.
|
||||
*/
|
||||
'max_grpc_timeout': (_google_protobuf_Duration__Output);
|
||||
'max_grpc_timeout'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Specifies the idle timeout for the route. If not specified, there is no per-route idle timeout,
|
||||
* although the connection manager wide :ref:`stream_idle_timeout
|
||||
@ -909,7 +909,7 @@ export interface RouteAction__Output {
|
||||
* upstream response header has been received, otherwise a stream reset
|
||||
* occurs.
|
||||
*/
|
||||
'idle_timeout': (_google_protobuf_Duration__Output);
|
||||
'idle_timeout'?: (_google_protobuf_Duration__Output);
|
||||
'upgrade_configs': (_envoy_api_v2_route_RouteAction_UpgradeConfig__Output)[];
|
||||
'internal_redirect_action': (keyof typeof _envoy_api_v2_route_RouteAction_InternalRedirectAction);
|
||||
/**
|
||||
@ -917,7 +917,7 @@ export interface RouteAction__Output {
|
||||
* it'll take precedence over the virtual host level hedge policy entirely
|
||||
* (e.g.: policies are not merged, most internal one becomes the enforced policy).
|
||||
*/
|
||||
'hedge_policy': (_envoy_api_v2_route_HedgePolicy__Output);
|
||||
'hedge_policy'?: (_envoy_api_v2_route_HedgePolicy__Output);
|
||||
/**
|
||||
* If present, Envoy will adjust the timeout provided by the `grpc-timeout` header by subtracting
|
||||
* the provided duration from the header. This is useful in allowing Envoy to set its global
|
||||
@ -927,7 +927,7 @@ export interface RouteAction__Output {
|
||||
* ensures that the offset will only ever decrease the timeout and never set it to 0 (meaning
|
||||
* infinity).
|
||||
*/
|
||||
'grpc_timeout_offset': (_google_protobuf_Duration__Output);
|
||||
'grpc_timeout_offset'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Indicates that during forwarding, the host header will be swapped with the content of given
|
||||
* downstream or :ref:`custom <config_http_conn_man_headers_custom_request_headers>` header.
|
||||
@ -959,7 +959,7 @@ export interface RouteAction__Output {
|
||||
*
|
||||
* If not specified, at most one redirect will be followed.
|
||||
*/
|
||||
'max_internal_redirects': (_google_protobuf_UInt32Value__Output);
|
||||
'max_internal_redirects'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Indicates that during forwarding, portions of the path that match the
|
||||
* pattern should be rewritten, even allowing the substitution of capture
|
||||
@ -990,7 +990,7 @@ export interface RouteAction__Output {
|
||||
* would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
|
||||
* ``/aaa/yyy/bbb``.
|
||||
*/
|
||||
'regex_rewrite': (_envoy_type_matcher_RegexMatchAndSubstitute__Output);
|
||||
'regex_rewrite'?: (_envoy_type_matcher_RegexMatchAndSubstitute__Output);
|
||||
/**
|
||||
* [#not-implemented-hide:]
|
||||
* Specifies the configuration for retry policy extension. Note that if this is set, it'll take
|
||||
@ -998,7 +998,7 @@ export interface RouteAction__Output {
|
||||
* most internal one becomes the enforced policy). :ref:`Retry policy <envoy_api_field_route.VirtualHost.retry_policy>`
|
||||
* should not be set if this field is used.
|
||||
*/
|
||||
'retry_policy_typed_config': (_google_protobuf_Any__Output);
|
||||
'retry_policy_typed_config'?: (_google_protobuf_Any__Output);
|
||||
'cluster_specifier': "cluster"|"cluster_header"|"weighted_clusters";
|
||||
'host_rewrite_specifier': "host_rewrite"|"auto_host_rewrite"|"auto_host_rewrite_header";
|
||||
}
|
||||
|
||||
@ -30,12 +30,12 @@ export interface _envoy_api_v2_route_RouteMatch_TlsContextMatchOptions__Output {
|
||||
* If specified, the route will match against whether or not a certificate is presented.
|
||||
* If not specified, certificate presentation status (true or false) will not be considered when route matching.
|
||||
*/
|
||||
'presented': (_google_protobuf_BoolValue__Output);
|
||||
'presented'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* If specified, the route will match against whether or not a certificate is validated.
|
||||
* If not specified, certificate validation status (true or false) will not be considered when route matching.
|
||||
*/
|
||||
'validated': (_google_protobuf_BoolValue__Output);
|
||||
'validated'?: (_google_protobuf_BoolValue__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -179,7 +179,7 @@ export interface RouteMatch__Output {
|
||||
* Indicates that prefix/path matching should be case insensitive. The default
|
||||
* is true.
|
||||
*/
|
||||
'case_sensitive': (_google_protobuf_BoolValue__Output);
|
||||
'case_sensitive'?: (_google_protobuf_BoolValue__Output);
|
||||
/**
|
||||
* Specifies a set of headers that the route should match on. The router will
|
||||
* check the request’s headers against all the specified headers in the route
|
||||
@ -201,7 +201,7 @@ export interface RouteMatch__Output {
|
||||
* that the content-type header has a application/grpc or one of the various
|
||||
* application/grpc+ values.
|
||||
*/
|
||||
'grpc': (_envoy_api_v2_route_RouteMatch_GrpcRouteMatchOptions__Output);
|
||||
'grpc'?: (_envoy_api_v2_route_RouteMatch_GrpcRouteMatchOptions__Output);
|
||||
/**
|
||||
* Indicates that the route should additionally match on a runtime key. Every time the route
|
||||
* is considered for a match, it must also fall under the percentage of matches indicated by
|
||||
@ -220,7 +220,7 @@ export interface RouteMatch__Output {
|
||||
* instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
|
||||
* whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.
|
||||
*/
|
||||
'runtime_fraction': (_envoy_api_v2_core_RuntimeFractionalPercent__Output);
|
||||
'runtime_fraction'?: (_envoy_api_v2_core_RuntimeFractionalPercent__Output);
|
||||
/**
|
||||
* If specified, the route is a regular expression rule meaning that the
|
||||
* regex must match the *:path* header once the query string is removed. The entire path
|
||||
@ -242,6 +242,6 @@ export interface RouteMatch__Output {
|
||||
*
|
||||
* [#next-major-version: unify with RBAC]
|
||||
*/
|
||||
'tls_context': (_envoy_api_v2_route_RouteMatch_TlsContextMatchOptions__Output);
|
||||
'tls_context'?: (_envoy_api_v2_route_RouteMatch_TlsContextMatchOptions__Output);
|
||||
'path_specifier': "prefix"|"path"|"regex"|"safe_regex";
|
||||
}
|
||||
|
||||
@ -52,7 +52,7 @@ export interface Tracing__Output {
|
||||
* <config_http_conn_man_runtime>`.
|
||||
* Default: 100%
|
||||
*/
|
||||
'client_sampling': (_envoy_type_FractionalPercent__Output);
|
||||
'client_sampling'?: (_envoy_type_FractionalPercent__Output);
|
||||
/**
|
||||
* Target percentage of requests managed by this HTTP connection manager that will be randomly
|
||||
* selected for trace generation, if not requested by the client or not forced. This field is
|
||||
@ -60,7 +60,7 @@ export interface Tracing__Output {
|
||||
* :ref:`HTTP Connection Manager <config_http_conn_man_runtime>`.
|
||||
* Default: 100%
|
||||
*/
|
||||
'random_sampling': (_envoy_type_FractionalPercent__Output);
|
||||
'random_sampling'?: (_envoy_type_FractionalPercent__Output);
|
||||
/**
|
||||
* Target percentage of requests managed by this HTTP connection manager that will be traced
|
||||
* after all other sampling checks have been applied (client-directed, force tracing, random
|
||||
@ -71,7 +71,7 @@ export interface Tracing__Output {
|
||||
* :ref:`HTTP Connection Manager <config_http_conn_man_runtime>`.
|
||||
* Default: 100%
|
||||
*/
|
||||
'overall_sampling': (_envoy_type_FractionalPercent__Output);
|
||||
'overall_sampling'?: (_envoy_type_FractionalPercent__Output);
|
||||
/**
|
||||
* A list of custom tags with unique tag name to create tags for the active span.
|
||||
* It will take effect after merging with the :ref:`corresponding configuration
|
||||
|
||||
@ -119,7 +119,7 @@ export interface VirtualHost {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>`
|
||||
* for if and how it is utilized.
|
||||
*/
|
||||
'per_filter_config'?: (_google_protobuf_Struct);
|
||||
'per_filter_config'?: ({[key: string]: _google_protobuf_Struct});
|
||||
/**
|
||||
* Specifies a list of HTTP headers that should be removed from each request
|
||||
* handled by this virtual host.
|
||||
@ -145,7 +145,7 @@ export interface VirtualHost {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>`
|
||||
* for if and how it is utilized.
|
||||
*/
|
||||
'typed_per_filter_config'?: (_google_protobuf_Any);
|
||||
'typed_per_filter_config'?: ({[key: string]: _google_protobuf_Any});
|
||||
/**
|
||||
* Indicates the retry policy for all routes in this virtual host. Note that setting a
|
||||
* route level entry will take precedence over this config and it'll be treated
|
||||
@ -252,7 +252,7 @@ export interface VirtualHost__Output {
|
||||
/**
|
||||
* Indicates that the virtual host has a CORS policy.
|
||||
*/
|
||||
'cors': (_envoy_api_v2_route_CorsPolicy__Output);
|
||||
'cors'?: (_envoy_api_v2_route_CorsPolicy__Output);
|
||||
/**
|
||||
* Specifies a list of HTTP headers that should be added to each response
|
||||
* handled by this virtual host. Headers specified at this level are applied
|
||||
@ -274,7 +274,7 @@ export interface VirtualHost__Output {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>`
|
||||
* for if and how it is utilized.
|
||||
*/
|
||||
'per_filter_config': (_google_protobuf_Struct__Output);
|
||||
'per_filter_config'?: ({[key: string]: _google_protobuf_Struct__Output});
|
||||
/**
|
||||
* Specifies a list of HTTP headers that should be removed from each request
|
||||
* handled by this virtual host.
|
||||
@ -300,25 +300,25 @@ export interface VirtualHost__Output {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>`
|
||||
* for if and how it is utilized.
|
||||
*/
|
||||
'typed_per_filter_config': (_google_protobuf_Any__Output);
|
||||
'typed_per_filter_config'?: ({[key: string]: _google_protobuf_Any__Output});
|
||||
/**
|
||||
* Indicates the retry policy for all routes in this virtual host. Note that setting a
|
||||
* route level entry will take precedence over this config and it'll be treated
|
||||
* independently (e.g.: values are not inherited).
|
||||
*/
|
||||
'retry_policy': (_envoy_api_v2_route_RetryPolicy__Output);
|
||||
'retry_policy'?: (_envoy_api_v2_route_RetryPolicy__Output);
|
||||
/**
|
||||
* Indicates the hedge policy for all routes in this virtual host. Note that setting a
|
||||
* route level entry will take precedence over this config and it'll be treated
|
||||
* independently (e.g.: values are not inherited).
|
||||
*/
|
||||
'hedge_policy': (_envoy_api_v2_route_HedgePolicy__Output);
|
||||
'hedge_policy'?: (_envoy_api_v2_route_HedgePolicy__Output);
|
||||
/**
|
||||
* The maximum bytes which will be buffered for retries and shadowing.
|
||||
* If set and a route-specific limit is not set, the bytes actually buffered will be the minimum
|
||||
* value of this and the listener per_connection_buffer_limit_bytes.
|
||||
*/
|
||||
'per_request_buffer_limit_bytes': (_google_protobuf_UInt32Value__Output);
|
||||
'per_request_buffer_limit_bytes'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Decides whether the :ref:`x-envoy-attempt-count
|
||||
* <config_http_filters_router_x-envoy-attempt-count>` header should be included
|
||||
@ -337,5 +337,5 @@ export interface VirtualHost__Output {
|
||||
* inherited). :ref:`Retry policy <envoy_api_field_route.VirtualHost.retry_policy>` should not be
|
||||
* set if this field is used.
|
||||
*/
|
||||
'retry_policy_typed_config': (_google_protobuf_Any__Output);
|
||||
'retry_policy_typed_config'?: (_google_protobuf_Any__Output);
|
||||
}
|
||||
|
||||
@ -67,7 +67,7 @@ export interface _envoy_api_v2_route_WeightedCluster_ClusterWeight {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>`
|
||||
* for if and how it is utilized.
|
||||
*/
|
||||
'per_filter_config'?: (_google_protobuf_Struct);
|
||||
'per_filter_config'?: ({[key: string]: _google_protobuf_Struct});
|
||||
/**
|
||||
* The per_filter_config field can be used to provide weighted cluster-specific
|
||||
* configurations for filters. The key should match the filter name, such as
|
||||
@ -75,7 +75,7 @@ export interface _envoy_api_v2_route_WeightedCluster_ClusterWeight {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>`
|
||||
* for if and how it is utilized.
|
||||
*/
|
||||
'typed_per_filter_config'?: (_google_protobuf_Any);
|
||||
'typed_per_filter_config'?: ({[key: string]: _google_protobuf_Any});
|
||||
}
|
||||
|
||||
/**
|
||||
@ -93,7 +93,7 @@ export interface _envoy_api_v2_route_WeightedCluster_ClusterWeight__Output {
|
||||
* the choice of an upstream cluster is determined by its weight. The sum of weights across all
|
||||
* entries in the clusters array must add up to the total_weight, which defaults to 100.
|
||||
*/
|
||||
'weight': (_google_protobuf_UInt32Value__Output);
|
||||
'weight'?: (_google_protobuf_UInt32Value__Output);
|
||||
/**
|
||||
* Optional endpoint metadata match criteria used by the subset load balancer. Only endpoints in
|
||||
* the upstream cluster with metadata matching what is set in this field will be considered for
|
||||
@ -101,7 +101,7 @@ export interface _envoy_api_v2_route_WeightedCluster_ClusterWeight__Output {
|
||||
* :ref:`RouteAction.metadata_match <envoy_api_field_route.RouteAction.metadata_match>`, with
|
||||
* values here taking precedence. The filter name should be specified as *envoy.lb*.
|
||||
*/
|
||||
'metadata_match': (_envoy_api_v2_core_Metadata__Output);
|
||||
'metadata_match'?: (_envoy_api_v2_core_Metadata__Output);
|
||||
/**
|
||||
* Specifies a list of headers to be added to requests when this cluster is selected
|
||||
* through the enclosing :ref:`envoy_api_msg_route.RouteAction`.
|
||||
@ -139,7 +139,7 @@ export interface _envoy_api_v2_route_WeightedCluster_ClusterWeight__Output {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>`
|
||||
* for if and how it is utilized.
|
||||
*/
|
||||
'per_filter_config': (_google_protobuf_Struct__Output);
|
||||
'per_filter_config'?: ({[key: string]: _google_protobuf_Struct__Output});
|
||||
/**
|
||||
* The per_filter_config field can be used to provide weighted cluster-specific
|
||||
* configurations for filters. The key should match the filter name, such as
|
||||
@ -147,7 +147,7 @@ export interface _envoy_api_v2_route_WeightedCluster_ClusterWeight__Output {
|
||||
* specific; see the :ref:`HTTP filter documentation <config_http_filters>`
|
||||
* for if and how it is utilized.
|
||||
*/
|
||||
'typed_per_filter_config': (_google_protobuf_Any__Output);
|
||||
'typed_per_filter_config'?: ({[key: string]: _google_protobuf_Any__Output});
|
||||
}
|
||||
|
||||
/**
|
||||
@ -209,5 +209,5 @@ export interface WeightedCluster__Output {
|
||||
* Specifies the total weight across all clusters. The sum of all cluster weights must equal this
|
||||
* value, which must be greater than 0. Defaults to 100.
|
||||
*/
|
||||
'total_weight': (_google_protobuf_UInt32Value__Output);
|
||||
'total_weight'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
@ -47,7 +47,7 @@ export interface AccessLog__Output {
|
||||
/**
|
||||
* Filter which is used to determine if the access log needs to be written.
|
||||
*/
|
||||
'filter': (_envoy_config_filter_accesslog_v2_AccessLogFilter__Output);
|
||||
'filter'?: (_envoy_config_filter_accesslog_v2_AccessLogFilter__Output);
|
||||
'config'?: (_google_protobuf_Struct__Output);
|
||||
'typed_config'?: (_google_protobuf_Any__Output);
|
||||
/**
|
||||
|
||||
@ -44,5 +44,5 @@ export interface ComparisonFilter__Output {
|
||||
/**
|
||||
* Value to compare against.
|
||||
*/
|
||||
'value': (_envoy_api_v2_core_RuntimeUInt32__Output);
|
||||
'value'?: (_envoy_api_v2_core_RuntimeUInt32__Output);
|
||||
}
|
||||
|
||||
@ -19,5 +19,5 @@ export interface DurationFilter__Output {
|
||||
/**
|
||||
* Comparison.
|
||||
*/
|
||||
'comparison': (_envoy_config_filter_accesslog_v2_ComparisonFilter__Output);
|
||||
'comparison'?: (_envoy_config_filter_accesslog_v2_ComparisonFilter__Output);
|
||||
}
|
||||
|
||||
@ -21,5 +21,5 @@ export interface HeaderFilter__Output {
|
||||
* Only requests with a header which matches the specified HeaderMatcher will pass the filter
|
||||
* check.
|
||||
*/
|
||||
'header': (_envoy_api_v2_route_HeaderMatcher__Output);
|
||||
'header'?: (_envoy_api_v2_route_HeaderMatcher__Output);
|
||||
}
|
||||
|
||||
@ -44,7 +44,7 @@ export interface RuntimeFilter__Output {
|
||||
/**
|
||||
* The default sampling percentage. If not specified, defaults to 0% with denominator of 100.
|
||||
*/
|
||||
'percent_sampled': (_envoy_type_FractionalPercent__Output);
|
||||
'percent_sampled'?: (_envoy_type_FractionalPercent__Output);
|
||||
/**
|
||||
* By default, sampling pivots on the header
|
||||
* :ref:`x-request-id<config_http_conn_man_headers_x-request-id>` being present. If
|
||||
|
||||
@ -19,5 +19,5 @@ export interface StatusCodeFilter__Output {
|
||||
/**
|
||||
* Comparison.
|
||||
*/
|
||||
'comparison': (_envoy_config_filter_accesslog_v2_ComparisonFilter__Output);
|
||||
'comparison'?: (_envoy_config_filter_accesslog_v2_ComparisonFilter__Output);
|
||||
}
|
||||
|
||||
@ -35,5 +35,5 @@ export interface ApiListener__Output {
|
||||
* and http_connection_manager.proto depends on rds.proto, which is in the same directory as
|
||||
* lds.proto, so lds.proto cannot depend on this file.]
|
||||
*/
|
||||
'api_listener': (_google_protobuf_Any__Output);
|
||||
'api_listener'?: (_google_protobuf_Any__Output);
|
||||
}
|
||||
|
||||
@ -49,7 +49,7 @@ export interface RegexMatchAndSubstitute__Output {
|
||||
* used in the pattern to extract portions of the subject string, and then
|
||||
* referenced in the substitution string.
|
||||
*/
|
||||
'pattern': (_envoy_type_matcher_RegexMatcher__Output);
|
||||
'pattern'?: (_envoy_type_matcher_RegexMatcher__Output);
|
||||
/**
|
||||
* The string that should be substituted into matching portions of the
|
||||
* subject string during a substitution operation to produce a new string.
|
||||
|
||||
@ -35,7 +35,7 @@ export interface _envoy_type_matcher_RegexMatcher_GoogleRE2__Output {
|
||||
* This field is deprecated; regexp validation should be performed on the management server
|
||||
* instead of being done by each individual client.
|
||||
*/
|
||||
'max_program_size': (_google_protobuf_UInt32Value__Output);
|
||||
'max_program_size'?: (_google_protobuf_UInt32Value__Output);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -122,11 +122,11 @@ export interface _envoy_type_tracing_v2_CustomTag_Metadata__Output {
|
||||
/**
|
||||
* Specify what kind of metadata to obtain tag value from.
|
||||
*/
|
||||
'kind': (_envoy_type_metadata_v2_MetadataKind__Output);
|
||||
'kind'?: (_envoy_type_metadata_v2_MetadataKind__Output);
|
||||
/**
|
||||
* Metadata key to define the path to retrieve the tag value.
|
||||
*/
|
||||
'metadata_key': (_envoy_type_metadata_v2_MetadataKey__Output);
|
||||
'metadata_key'?: (_envoy_type_metadata_v2_MetadataKey__Output);
|
||||
/**
|
||||
* When no valid metadata is found,
|
||||
* the tag value would be populated with this default value if specified,
|
||||
|
||||
@ -46,7 +46,7 @@ export interface DescriptorProto__Output {
|
||||
'enumType': (_google_protobuf_EnumDescriptorProto__Output)[];
|
||||
'extensionRange': (_google_protobuf_DescriptorProto_ExtensionRange__Output)[];
|
||||
'extension': (_google_protobuf_FieldDescriptorProto__Output)[];
|
||||
'options': (_google_protobuf_MessageOptions__Output);
|
||||
'options'?: (_google_protobuf_MessageOptions__Output);
|
||||
'oneofDecl': (_google_protobuf_OneofDescriptorProto__Output)[];
|
||||
'reservedRange': (_google_protobuf_DescriptorProto_ReservedRange__Output)[];
|
||||
'reservedName': (string)[];
|
||||
|
||||
@ -12,5 +12,5 @@ export interface EnumDescriptorProto {
|
||||
export interface EnumDescriptorProto__Output {
|
||||
'name': (string);
|
||||
'value': (_google_protobuf_EnumValueDescriptorProto__Output)[];
|
||||
'options': (_google_protobuf_EnumOptions__Output);
|
||||
'options'?: (_google_protobuf_EnumOptions__Output);
|
||||
}
|
||||
|
||||
@ -14,5 +14,5 @@ export interface EnumOptions__Output {
|
||||
'allowAlias': (boolean);
|
||||
'deprecated': (boolean);
|
||||
'uninterpretedOption': (_google_protobuf_UninterpretedOption__Output)[];
|
||||
'.udpa.annotations.enum_migrate': (_udpa_annotations_MigrateAnnotation__Output);
|
||||
'.udpa.annotations.enum_migrate'?: (_udpa_annotations_MigrateAnnotation__Output);
|
||||
}
|
||||
|
||||
@ -11,5 +11,5 @@ export interface EnumValueDescriptorProto {
|
||||
export interface EnumValueDescriptorProto__Output {
|
||||
'name': (string);
|
||||
'number': (number);
|
||||
'options': (_google_protobuf_EnumValueOptions__Output);
|
||||
'options'?: (_google_protobuf_EnumValueOptions__Output);
|
||||
}
|
||||
|
||||
@ -14,5 +14,5 @@ export interface EnumValueOptions__Output {
|
||||
'deprecated': (boolean);
|
||||
'uninterpretedOption': (_google_protobuf_UninterpretedOption__Output)[];
|
||||
'.envoy.annotations.disallowed_by_default_enum': (boolean);
|
||||
'.udpa.annotations.enum_value_migrate': (_udpa_annotations_MigrateAnnotation__Output);
|
||||
'.udpa.annotations.enum_value_migrate'?: (_udpa_annotations_MigrateAnnotation__Output);
|
||||
}
|
||||
|
||||
@ -54,7 +54,7 @@ export interface FieldDescriptorProto__Output {
|
||||
'type': (keyof typeof _google_protobuf_FieldDescriptorProto_Type);
|
||||
'typeName': (string);
|
||||
'defaultValue': (string);
|
||||
'options': (_google_protobuf_FieldOptions__Output);
|
||||
'options'?: (_google_protobuf_FieldOptions__Output);
|
||||
'oneofIndex': (number);
|
||||
'jsonName': (string);
|
||||
}
|
||||
|
||||
@ -42,8 +42,8 @@ export interface FieldOptions__Output {
|
||||
'jstype': (keyof typeof _google_protobuf_FieldOptions_JSType);
|
||||
'weak': (boolean);
|
||||
'uninterpretedOption': (_google_protobuf_UninterpretedOption__Output)[];
|
||||
'.validate.rules': (_validate_FieldRules__Output);
|
||||
'.validate.rules'?: (_validate_FieldRules__Output);
|
||||
'.udpa.annotations.sensitive': (boolean);
|
||||
'.udpa.annotations.field_migrate': (_udpa_annotations_FieldMigrateAnnotation__Output);
|
||||
'.udpa.annotations.field_migrate'?: (_udpa_annotations_FieldMigrateAnnotation__Output);
|
||||
'.envoy.annotations.disallowed_by_default': (boolean);
|
||||
}
|
||||
|
||||
@ -30,8 +30,8 @@ export interface FileDescriptorProto__Output {
|
||||
'enumType': (_google_protobuf_EnumDescriptorProto__Output)[];
|
||||
'service': (_google_protobuf_ServiceDescriptorProto__Output)[];
|
||||
'extension': (_google_protobuf_FieldDescriptorProto__Output)[];
|
||||
'options': (_google_protobuf_FileOptions__Output);
|
||||
'sourceCodeInfo': (_google_protobuf_SourceCodeInfo__Output);
|
||||
'options'?: (_google_protobuf_FileOptions__Output);
|
||||
'sourceCodeInfo'?: (_google_protobuf_SourceCodeInfo__Output);
|
||||
'publicDependency': (number)[];
|
||||
'weakDependency': (number)[];
|
||||
'syntax': (string);
|
||||
|
||||
@ -48,6 +48,6 @@ export interface FileOptions__Output {
|
||||
'objcClassPrefix': (string);
|
||||
'csharpNamespace': (string);
|
||||
'uninterpretedOption': (_google_protobuf_UninterpretedOption__Output)[];
|
||||
'.udpa.annotations.file_migrate': (_udpa_annotations_FileMigrateAnnotation__Output);
|
||||
'.udpa.annotations.file_status': (_udpa_annotations_StatusAnnotation__Output);
|
||||
'.udpa.annotations.file_migrate'?: (_udpa_annotations_FileMigrateAnnotation__Output);
|
||||
'.udpa.annotations.file_status'?: (_udpa_annotations_StatusAnnotation__Output);
|
||||
}
|
||||
|
||||
@ -20,5 +20,5 @@ export interface MessageOptions__Output {
|
||||
'mapEntry': (boolean);
|
||||
'uninterpretedOption': (_google_protobuf_UninterpretedOption__Output)[];
|
||||
'.validate.disabled': (boolean);
|
||||
'.udpa.annotations.message_migrate': (_udpa_annotations_MigrateAnnotation__Output);
|
||||
'.udpa.annotations.message_migrate'?: (_udpa_annotations_MigrateAnnotation__Output);
|
||||
}
|
||||
|
||||
@ -15,7 +15,7 @@ export interface MethodDescriptorProto__Output {
|
||||
'name': (string);
|
||||
'inputType': (string);
|
||||
'outputType': (string);
|
||||
'options': (_google_protobuf_MethodOptions__Output);
|
||||
'options'?: (_google_protobuf_MethodOptions__Output);
|
||||
'clientStreaming': (boolean);
|
||||
'serverStreaming': (boolean);
|
||||
}
|
||||
|
||||
@ -12,5 +12,5 @@ export interface MethodOptions {
|
||||
export interface MethodOptions__Output {
|
||||
'deprecated': (boolean);
|
||||
'uninterpretedOption': (_google_protobuf_UninterpretedOption__Output)[];
|
||||
'.google.api.http': (_google_api_HttpRule__Output);
|
||||
'.google.api.http'?: (_google_api_HttpRule__Output);
|
||||
}
|
||||
|
||||
@ -9,5 +9,5 @@ export interface OneofDescriptorProto {
|
||||
|
||||
export interface OneofDescriptorProto__Output {
|
||||
'name': (string);
|
||||
'options': (_google_protobuf_OneofOptions__Output);
|
||||
'options'?: (_google_protobuf_OneofOptions__Output);
|
||||
}
|
||||
|
||||
@ -12,5 +12,5 @@ export interface ServiceDescriptorProto {
|
||||
export interface ServiceDescriptorProto__Output {
|
||||
'name': (string);
|
||||
'method': (_google_protobuf_MethodDescriptorProto__Output)[];
|
||||
'options': (_google_protobuf_ServiceOptions__Output);
|
||||
'options'?: (_google_protobuf_ServiceOptions__Output);
|
||||
}
|
||||
|
||||
@ -3,9 +3,9 @@
|
||||
import { Value as _google_protobuf_Value, Value__Output as _google_protobuf_Value__Output } from '../../google/protobuf/Value';
|
||||
|
||||
export interface Struct {
|
||||
'fields'?: (_google_protobuf_Value);
|
||||
'fields'?: ({[key: string]: _google_protobuf_Value});
|
||||
}
|
||||
|
||||
export interface Struct__Output {
|
||||
'fields': (_google_protobuf_Value__Output);
|
||||
'fields'?: ({[key: string]: _google_protobuf_Value__Output});
|
||||
}
|
||||
|
||||
@ -59,27 +59,27 @@ export interface DurationRules__Output {
|
||||
/**
|
||||
* Const specifies that this field must be exactly the specified value
|
||||
*/
|
||||
'const': (_google_protobuf_Duration__Output);
|
||||
'const'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Lt specifies that this field must be less than the specified value,
|
||||
* exclusive
|
||||
*/
|
||||
'lt': (_google_protobuf_Duration__Output);
|
||||
'lt'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Lt specifies that this field must be less than the specified value,
|
||||
* inclusive
|
||||
*/
|
||||
'lte': (_google_protobuf_Duration__Output);
|
||||
'lte'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Gt specifies that this field must be greater than the specified value,
|
||||
* exclusive
|
||||
*/
|
||||
'gt': (_google_protobuf_Duration__Output);
|
||||
'gt'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* Gte specifies that this field must be greater than the specified value,
|
||||
* inclusive
|
||||
*/
|
||||
'gte': (_google_protobuf_Duration__Output);
|
||||
'gte'?: (_google_protobuf_Duration__Output);
|
||||
/**
|
||||
* In specifies that this field must be equal to one of the specified
|
||||
* values
|
||||
|
||||
@ -90,7 +90,7 @@ export interface FieldRules__Output {
|
||||
* Complex Field Types
|
||||
*/
|
||||
'enum'?: (_validate_EnumRules__Output);
|
||||
'message': (_validate_MessageRules__Output);
|
||||
'message'?: (_validate_MessageRules__Output);
|
||||
'repeated'?: (_validate_RepeatedRules__Output);
|
||||
'map'?: (_validate_MapRules__Output);
|
||||
/**
|
||||
|
||||
@ -56,11 +56,11 @@ export interface MapRules__Output {
|
||||
/**
|
||||
* Keys specifies the constraints to be applied to each key in the field.
|
||||
*/
|
||||
'keys': (_validate_FieldRules__Output);
|
||||
'keys'?: (_validate_FieldRules__Output);
|
||||
/**
|
||||
* Values specifies the constraints to be applied to the value of each key
|
||||
* in the field. Message values will still have their validations evaluated
|
||||
* unless skip is specified here.
|
||||
*/
|
||||
'values': (_validate_FieldRules__Output);
|
||||
'values'?: (_validate_FieldRules__Output);
|
||||
}
|
||||
|
||||
@ -56,5 +56,5 @@ export interface RepeatedRules__Output {
|
||||
* Repeated message fields will still execute validation against each item
|
||||
* unless skip is specified here.
|
||||
*/
|
||||
'items': (_validate_FieldRules__Output);
|
||||
'items'?: (_validate_FieldRules__Output);
|
||||
}
|
||||
|
||||
@ -66,27 +66,27 @@ export interface TimestampRules__Output {
|
||||
/**
|
||||
* Const specifies that this field must be exactly the specified value
|
||||
*/
|
||||
'const': (_google_protobuf_Timestamp__Output);
|
||||
'const'?: (_google_protobuf_Timestamp__Output);
|
||||
/**
|
||||
* Lt specifies that this field must be less than the specified value,
|
||||
* exclusive
|
||||
*/
|
||||
'lt': (_google_protobuf_Timestamp__Output);
|
||||
'lt'?: (_google_protobuf_Timestamp__Output);
|
||||
/**
|
||||
* Lte specifies that this field must be less than the specified value,
|
||||
* inclusive
|
||||
*/
|
||||
'lte': (_google_protobuf_Timestamp__Output);
|
||||
'lte'?: (_google_protobuf_Timestamp__Output);
|
||||
/**
|
||||
* Gt specifies that this field must be greater than the specified value,
|
||||
* exclusive
|
||||
*/
|
||||
'gt': (_google_protobuf_Timestamp__Output);
|
||||
'gt'?: (_google_protobuf_Timestamp__Output);
|
||||
/**
|
||||
* Gte specifies that this field must be greater than the specified value,
|
||||
* inclusive
|
||||
*/
|
||||
'gte': (_google_protobuf_Timestamp__Output);
|
||||
'gte'?: (_google_protobuf_Timestamp__Output);
|
||||
/**
|
||||
* LtNow specifies that this must be less than the current time. LtNow
|
||||
* can only be used with the Within rule.
|
||||
@ -102,5 +102,5 @@ export interface TimestampRules__Output {
|
||||
* current time. This constraint can be used alone or with the LtNow and
|
||||
* GtNow rules.
|
||||
*/
|
||||
'within': (_google_protobuf_Duration__Output);
|
||||
'within'?: (_google_protobuf_Duration__Output);
|
||||
}
|
||||
|
||||
@ -134,21 +134,13 @@ function getStructFromJson(obj: any): Struct {
|
||||
if (typeof obj !== 'object' || obj === null) {
|
||||
throw new Error('Invalid JSON object for Struct field');
|
||||
}
|
||||
const result = Object.keys(obj).map((key) => validateValue(key));
|
||||
if (result.length === 1) {
|
||||
return {
|
||||
fields: result[0],
|
||||
};
|
||||
} else {
|
||||
return {
|
||||
fields: {
|
||||
kind: 'listValue',
|
||||
listValue: {
|
||||
values: result,
|
||||
},
|
||||
},
|
||||
};
|
||||
const fields: { [key: string]: Value } = {};
|
||||
for (const [fieldName, value] of Object.entries(obj)) {
|
||||
fields[fieldName] = validateValue(value);
|
||||
}
|
||||
return {
|
||||
fields,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -14,6 +14,7 @@ set(protobuf_BUILD_TESTS OFF CACHE BOOL "Build protobuf tests")
|
||||
set(protobuf_WITH_ZLIB OFF CACHE BOOL "Build protobuf with zlib.")
|
||||
|
||||
set(CMAKE_EXE_LINKER_FLAGS "-static-libstdc++")
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-stack-protector")
|
||||
|
||||
add_executable(grpc_node_plugin
|
||||
src/node_generator.cc
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "grpc-tools",
|
||||
"version": "1.9.0",
|
||||
"version": "1.9.1",
|
||||
"author": "Google Inc.",
|
||||
"description": "Tools for developing with gRPC on Node.js",
|
||||
"homepage": "https://grpc.io/",
|
||||
|
||||
@ -44,6 +44,7 @@
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/lodash.camelcase": "^4.3.4",
|
||||
"@types/mocha": "^5.2.7",
|
||||
"@types/node": "^10.12.5",
|
||||
"clang-format": "^1.2.2",
|
||||
"gts": "^1.1.0",
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user