diff --git a/api_names_out.yaml b/api_names_out.yaml index e054536ee..33a7fc22c 100644 --- a/api_names_out.yaml +++ b/api_names_out.yaml @@ -130628,6 +130628,9 @@ "/privateca:v1beta1/AuditLogConfig/exemptedMembers": exempted_members "/privateca:v1beta1/AuditLogConfig/exemptedMembers/exempted_member": exempted_member "/privateca:v1beta1/AuditLogConfig/logType": log_type +"/privateca:v1beta1/BillingView": billing_view +"/privateca:v1beta1/BillingView/reportRequests": report_requests +"/privateca:v1beta1/BillingView/reportRequests/report_request": report_request "/privateca:v1beta1/Binding": binding "/privateca:v1beta1/Binding/bindingId": binding_id "/privateca:v1beta1/Binding/condition": condition @@ -130718,6 +130721,12 @@ "/privateca:v1beta1/Empty": empty "/privateca:v1beta1/EnableCertificateAuthorityRequest": enable_certificate_authority_request "/privateca:v1beta1/EnableCertificateAuthorityRequest/requestId": request_id +"/privateca:v1beta1/Exemplar": exemplar +"/privateca:v1beta1/Exemplar/attachments": attachments +"/privateca:v1beta1/Exemplar/attachments/attachment": attachment +"/privateca:v1beta1/Exemplar/attachments/attachment/attachment": attachment +"/privateca:v1beta1/Exemplar/timestamp": timestamp +"/privateca:v1beta1/Exemplar/value": value "/privateca:v1beta1/Expr": expr "/privateca:v1beta1/Expr/description": description "/privateca:v1beta1/Expr/expression": expression @@ -130732,6 +130741,143 @@ "/privateca:v1beta1/ExtendedKeyUsageOptions/timeStamping": time_stamping "/privateca:v1beta1/FetchCertificateAuthorityCsrResponse": fetch_certificate_authority_csr_response "/privateca:v1beta1/FetchCertificateAuthorityCsrResponse/pemCsr": pem_csr +"/privateca:v1beta1/GoogleApiServicecontrolV1AttributeValue": google_api_servicecontrol_v1_attribute_value +"/privateca:v1beta1/GoogleApiServicecontrolV1AttributeValue/boolValue": bool_value +"/privateca:v1beta1/GoogleApiServicecontrolV1AttributeValue/intValue": int_value +"/privateca:v1beta1/GoogleApiServicecontrolV1AttributeValue/stringValue": string_value +"/privateca:v1beta1/GoogleApiServicecontrolV1Attributes": google_api_servicecontrol_v1_attributes +"/privateca:v1beta1/GoogleApiServicecontrolV1Attributes/attributeMap": attribute_map +"/privateca:v1beta1/GoogleApiServicecontrolV1Attributes/attributeMap/attribute_map": attribute_map +"/privateca:v1beta1/GoogleApiServicecontrolV1Attributes/droppedAttributesCount": dropped_attributes_count +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution": google_api_servicecontrol_v1_distribution +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/bucketCounts": bucket_counts +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/bucketCounts/bucket_count": bucket_count +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/count": count +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/exemplars": exemplars +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/exemplars/exemplar": exemplar +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/explicitBuckets": explicit_buckets +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/exponentialBuckets": exponential_buckets +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/linearBuckets": linear_buckets +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/maximum": maximum +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/mean": mean +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/minimum": minimum +"/privateca:v1beta1/GoogleApiServicecontrolV1Distribution/sumOfSquaredDeviation": sum_of_squared_deviation +"/privateca:v1beta1/GoogleApiServicecontrolV1ExplicitBuckets": google_api_servicecontrol_v1_explicit_buckets +"/privateca:v1beta1/GoogleApiServicecontrolV1ExplicitBuckets/bounds": bounds +"/privateca:v1beta1/GoogleApiServicecontrolV1ExplicitBuckets/bounds/bound": bound +"/privateca:v1beta1/GoogleApiServicecontrolV1ExponentialBuckets": google_api_servicecontrol_v1_exponential_buckets +"/privateca:v1beta1/GoogleApiServicecontrolV1ExponentialBuckets/growthFactor": growth_factor +"/privateca:v1beta1/GoogleApiServicecontrolV1ExponentialBuckets/numFiniteBuckets": num_finite_buckets +"/privateca:v1beta1/GoogleApiServicecontrolV1ExponentialBuckets/scale": scale +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest": google_api_servicecontrol_v1_http_request +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/cacheFillBytes": cache_fill_bytes +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/cacheHit": cache_hit +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/cacheLookup": cache_lookup +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/cacheValidatedWithOriginServer": cache_validated_with_origin_server +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/latency": latency +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/protocol": protocol +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/referer": referer +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/remoteIp": remote_ip +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/requestMethod": request_method +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/requestSize": request_size +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/requestUrl": request_url +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/responseSize": response_size +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/serverIp": server_ip +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/status": status +"/privateca:v1beta1/GoogleApiServicecontrolV1HttpRequest/userAgent": user_agent +"/privateca:v1beta1/GoogleApiServicecontrolV1LinearBuckets": google_api_servicecontrol_v1_linear_buckets +"/privateca:v1beta1/GoogleApiServicecontrolV1LinearBuckets/numFiniteBuckets": num_finite_buckets +"/privateca:v1beta1/GoogleApiServicecontrolV1LinearBuckets/offset": offset +"/privateca:v1beta1/GoogleApiServicecontrolV1LinearBuckets/width": width +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry": google_api_servicecontrol_v1_log_entry +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/httpRequest": http_request +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/insertId": insert_id +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/labels": labels +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/labels/label": label +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/name": name +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/operation": operation +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/protoPayload": proto_payload +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/protoPayload/proto_payload": proto_payload +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/severity": severity +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/sourceLocation": source_location +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/structPayload": struct_payload +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/structPayload/struct_payload": struct_payload +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/textPayload": text_payload +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/timestamp": timestamp +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntry/trace": trace +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntryOperation": google_api_servicecontrol_v1_log_entry_operation +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntryOperation/first": first +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntryOperation/id": id +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntryOperation/last": last +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntryOperation/producer": producer +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntrySourceLocation": google_api_servicecontrol_v1_log_entry_source_location +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntrySourceLocation/file": file +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntrySourceLocation/function": function +"/privateca:v1beta1/GoogleApiServicecontrolV1LogEntrySourceLocation/line": line +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue": google_api_servicecontrol_v1_metric_value +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue/boolValue": bool_value +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue/distributionValue": distribution_value +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue/doubleValue": double_value +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue/endTime": end_time +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue/int64Value": int64_value +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue/labels": labels +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue/labels/label": label +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue/moneyValue": money_value +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue/startTime": start_time +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValue/stringValue": string_value +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValueSet": google_api_servicecontrol_v1_metric_value_set +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValueSet/metricName": metric_name +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValueSet/metricValues": metric_values +"/privateca:v1beta1/GoogleApiServicecontrolV1MetricValueSet/metricValues/metric_value": metric_value +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation": google_api_servicecontrol_v1_operation +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/consumerId": consumer_id +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/endTime": end_time +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/extensions": extensions +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/extensions/extension": extension +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/extensions/extension/extension": extension +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/importance": importance +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/labels": labels +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/labels/label": label +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/logEntries": log_entries +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/logEntries/log_entry": log_entry +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/metricValueSets": metric_value_sets +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/metricValueSets/metric_value_set": metric_value_set +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/operationId": operation_id +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/operationName": operation_name +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/quotaProperties": quota_properties +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/resources": resources +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/resources/resource": resource +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/startTime": start_time +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/traceSpans": trace_spans +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/traceSpans/trace_span": trace_span +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/userLabels": user_labels +"/privateca:v1beta1/GoogleApiServicecontrolV1Operation/userLabels/user_label": user_label +"/privateca:v1beta1/GoogleApiServicecontrolV1QuotaProperties": google_api_servicecontrol_v1_quota_properties +"/privateca:v1beta1/GoogleApiServicecontrolV1QuotaProperties/quotaMode": quota_mode +"/privateca:v1beta1/GoogleApiServicecontrolV1ReportRequest": google_api_servicecontrol_v1_report_request +"/privateca:v1beta1/GoogleApiServicecontrolV1ReportRequest/operations": operations +"/privateca:v1beta1/GoogleApiServicecontrolV1ReportRequest/operations/operation": operation +"/privateca:v1beta1/GoogleApiServicecontrolV1ReportRequest/serviceConfigId": service_config_id +"/privateca:v1beta1/GoogleApiServicecontrolV1ReportRequest/serviceName": service_name +"/privateca:v1beta1/GoogleApiServicecontrolV1ResourceInfo": google_api_servicecontrol_v1_resource_info +"/privateca:v1beta1/GoogleApiServicecontrolV1ResourceInfo/resourceContainer": resource_container +"/privateca:v1beta1/GoogleApiServicecontrolV1ResourceInfo/resourceLocation": resource_location +"/privateca:v1beta1/GoogleApiServicecontrolV1ResourceInfo/resourceName": resource_name +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan": google_api_servicecontrol_v1_trace_span +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/attributes": attributes +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/childSpanCount": child_span_count +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/displayName": display_name +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/endTime": end_time +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/name": name +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/parentSpanId": parent_span_id +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/sameProcessAsParentSpan": same_process_as_parent_span +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/spanId": span_id +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/spanKind": span_kind +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/startTime": start_time +"/privateca:v1beta1/GoogleApiServicecontrolV1TraceSpan/status": status +"/privateca:v1beta1/GoogleApiServicecontrolV1TruncatableString": google_api_servicecontrol_v1_truncatable_string +"/privateca:v1beta1/GoogleApiServicecontrolV1TruncatableString/truncatedByteCount": truncated_byte_count +"/privateca:v1beta1/GoogleApiServicecontrolV1TruncatableString/value": value "/privateca:v1beta1/IssuanceModes": issuance_modes "/privateca:v1beta1/IssuanceModes/allowConfigBasedIssuance": allow_config_based_issuance "/privateca:v1beta1/IssuanceModes/allowCsrBasedIssuance": allow_csr_based_issuance @@ -130798,6 +130944,10 @@ "/privateca:v1beta1/Location/metadata": metadata "/privateca:v1beta1/Location/metadata/metadatum": metadatum "/privateca:v1beta1/Location/name": name +"/privateca:v1beta1/Money": money +"/privateca:v1beta1/Money/currencyCode": currency_code +"/privateca:v1beta1/Money/nanos": nanos +"/privateca:v1beta1/Money/units": units "/privateca:v1beta1/ObjectId": object_id_prop "/privateca:v1beta1/ObjectId/objectIdPath": object_id_path "/privateca:v1beta1/ObjectId/objectIdPath/object_id_path": object_id_path @@ -130860,6 +131010,7 @@ "/privateca:v1beta1/RevokedCertificate/hexSerialNumber": hex_serial_number "/privateca:v1beta1/RevokedCertificate/revocationReason": revocation_reason "/privateca:v1beta1/ScheduleDeleteCertificateAuthorityRequest": schedule_delete_certificate_authority_request +"/privateca:v1beta1/ScheduleDeleteCertificateAuthorityRequest/ignoreActiveCertificates": ignore_active_certificates "/privateca:v1beta1/ScheduleDeleteCertificateAuthorityRequest/requestId": request_id "/privateca:v1beta1/SetIamPolicyRequest": set_iam_policy_request "/privateca:v1beta1/SetIamPolicyRequest/policy": policy diff --git a/generated/google-apis-privateca_v1beta1/CHANGELOG.md b/generated/google-apis-privateca_v1beta1/CHANGELOG.md index a830d370d..9d01154e7 100644 --- a/generated/google-apis-privateca_v1beta1/CHANGELOG.md +++ b/generated/google-apis-privateca_v1beta1/CHANGELOG.md @@ -1,5 +1,9 @@ # Release history for google-apis-privateca_v1beta1 +### v0.2.0 (2021-01-13) + +* Regenerated from discovery document revision 20201216 + ### v0.1.0 (2021-01-07) * Regenerated using generator version 0.1.1 diff --git a/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/classes.rb b/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/classes.rb index 1f09b3987..df54f9393 100644 --- a/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/classes.rb +++ b/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/classes.rb @@ -250,6 +250,28 @@ module Google end end + # Message for reporting billing requests through Eventstream. + class BillingView + include Google::Apis::Core::Hashable + + # Billing requests to be reported for cloud.eventstream.v2.ResourceEvent Each + # request contains billing operations to be reported under a service name. See + # go/billing-view-construction for documentation on constructing billing view + # report requests. + # Corresponds to the JSON property `reportRequests` + # @return [Array] + attr_accessor :report_requests + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @report_requests = args[:report_requests] if args.key?(:report_requests) + end + end + # Associates `members` with a `role`. class Binding include Google::Apis::Core::Hashable @@ -919,6 +941,47 @@ module Google end end + # Exemplars are example points that may be used to annotate aggregated + # distribution values. They are metadata that gives information about a + # particular value added to a Distribution bucket, such as a trace ID that was + # active when a value was added. They may contain further information, such as a + # example values and timestamps, origin, etc. + class Exemplar + include Google::Apis::Core::Hashable + + # Contextual information about the example value. Examples are: Trace: type. + # googleapis.com/google.monitoring.v3.SpanContext Literal string: type. + # googleapis.com/google.protobuf.StringValue Labels dropped during aggregation: + # type.googleapis.com/google.monitoring.v3.DroppedLabels There may be only a + # single attachment of any given message type in a single exemplar, and this is + # enforced by the system. + # Corresponds to the JSON property `attachments` + # @return [Array>] + attr_accessor :attachments + + # The observation (sampling) time of the above value. + # Corresponds to the JSON property `timestamp` + # @return [String] + attr_accessor :timestamp + + # Value of the exemplar point. This value determines to which bucket the + # exemplar belongs. + # Corresponds to the JSON property `value` + # @return [Float] + attr_accessor :value + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @attachments = args[:attachments] if args.key?(:attachments) + @timestamp = args[:timestamp] if args.key?(:timestamp) + @value = args[:value] if args.key?(:value) + end + end + # Represents a textual expression in the Common Expression Language (CEL) syntax. # CEL is a C-like expression language. The syntax and semantics of CEL are # documented at https://github.com/google/cel-spec. Example (Comparison): title: @@ -1054,6 +1117,1013 @@ module Google end end + # The allowed types for [VALUE] in a `[KEY]:[VALUE]` attribute. + class GoogleApiServicecontrolV1AttributeValue + include Google::Apis::Core::Hashable + + # A Boolean value represented by `true` or `false`. + # Corresponds to the JSON property `boolValue` + # @return [Boolean] + attr_accessor :bool_value + alias_method :bool_value?, :bool_value + + # A 64-bit signed integer. + # Corresponds to the JSON property `intValue` + # @return [Fixnum] + attr_accessor :int_value + + # Represents a string that might be shortened to a specified length. + # Corresponds to the JSON property `stringValue` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1TruncatableString] + attr_accessor :string_value + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bool_value = args[:bool_value] if args.key?(:bool_value) + @int_value = args[:int_value] if args.key?(:int_value) + @string_value = args[:string_value] if args.key?(:string_value) + end + end + + # A set of attributes, each in the format `[KEY]:[VALUE]`. + class GoogleApiServicecontrolV1Attributes + include Google::Apis::Core::Hashable + + # The set of attributes. Each attribute's key can be up to 128 bytes long. The + # value can be a string up to 256 bytes, a signed 64-bit integer, or the Boolean + # values `true` and `false`. For example: "/instance_id": "my-instance" "/http/ + # user_agent": "" "/http/request_bytes": 300 "abc.com/myattribute": true + # Corresponds to the JSON property `attributeMap` + # @return [Hash] + attr_accessor :attribute_map + + # The number of attributes that were discarded. Attributes can be discarded + # because their keys are too long or because there are too many attributes. If + # this value is 0 then all attributes are valid. + # Corresponds to the JSON property `droppedAttributesCount` + # @return [Fixnum] + attr_accessor :dropped_attributes_count + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @attribute_map = args[:attribute_map] if args.key?(:attribute_map) + @dropped_attributes_count = args[:dropped_attributes_count] if args.key?(:dropped_attributes_count) + end + end + + # Distribution represents a frequency distribution of double-valued sample + # points. It contains the size of the population of sample points plus + # additional optional information: - the arithmetic mean of the samples - the + # minimum and maximum of the samples - the sum-squared-deviation of the samples, + # used to compute variance - a histogram of the values of the sample points + class GoogleApiServicecontrolV1Distribution + include Google::Apis::Core::Hashable + + # The number of samples in each histogram bucket. `bucket_counts` are optional. + # If present, they must sum to the `count` value. The buckets are defined below + # in `bucket_option`. There are N buckets. `bucket_counts[0]` is the number of + # samples in the underflow bucket. `bucket_counts[1]` to `bucket_counts[N-1]` + # are the numbers of samples in each of the finite buckets. And `bucket_counts[N] + # is the number of samples in the overflow bucket. See the comments of ` + # bucket_option` below for more details. Any suffix of trailing zeros may be + # omitted. + # Corresponds to the JSON property `bucketCounts` + # @return [Array] + attr_accessor :bucket_counts + + # The total number of samples in the distribution. Must be >= 0. + # Corresponds to the JSON property `count` + # @return [Fixnum] + attr_accessor :count + + # Example points. Must be in increasing order of `value` field. + # Corresponds to the JSON property `exemplars` + # @return [Array] + attr_accessor :exemplars + + # Describing buckets with arbitrary user-provided width. + # Corresponds to the JSON property `explicitBuckets` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ExplicitBuckets] + attr_accessor :explicit_buckets + + # Describing buckets with exponentially growing width. + # Corresponds to the JSON property `exponentialBuckets` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ExponentialBuckets] + attr_accessor :exponential_buckets + + # Describing buckets with constant width. + # Corresponds to the JSON property `linearBuckets` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LinearBuckets] + attr_accessor :linear_buckets + + # The maximum of the population of values. Ignored if `count` is zero. + # Corresponds to the JSON property `maximum` + # @return [Float] + attr_accessor :maximum + + # The arithmetic mean of the samples in the distribution. If `count` is zero + # then this field must be zero. + # Corresponds to the JSON property `mean` + # @return [Float] + attr_accessor :mean + + # The minimum of the population of values. Ignored if `count` is zero. + # Corresponds to the JSON property `minimum` + # @return [Float] + attr_accessor :minimum + + # The sum of squared deviations from the mean: Sum[i=1..count]((x_i - mean)^2) + # where each x_i is a sample values. If `count` is zero then this field must be + # zero, otherwise validation of the request fails. + # Corresponds to the JSON property `sumOfSquaredDeviation` + # @return [Float] + attr_accessor :sum_of_squared_deviation + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bucket_counts = args[:bucket_counts] if args.key?(:bucket_counts) + @count = args[:count] if args.key?(:count) + @exemplars = args[:exemplars] if args.key?(:exemplars) + @explicit_buckets = args[:explicit_buckets] if args.key?(:explicit_buckets) + @exponential_buckets = args[:exponential_buckets] if args.key?(:exponential_buckets) + @linear_buckets = args[:linear_buckets] if args.key?(:linear_buckets) + @maximum = args[:maximum] if args.key?(:maximum) + @mean = args[:mean] if args.key?(:mean) + @minimum = args[:minimum] if args.key?(:minimum) + @sum_of_squared_deviation = args[:sum_of_squared_deviation] if args.key?(:sum_of_squared_deviation) + end + end + + # Describing buckets with arbitrary user-provided width. + class GoogleApiServicecontrolV1ExplicitBuckets + include Google::Apis::Core::Hashable + + # 'bound' is a list of strictly increasing boundaries between buckets. Note that + # a list of length N-1 defines N buckets because of fenceposting. See comments + # on `bucket_options` for details. The i'th finite bucket covers the interval [ + # bound[i-1], bound[i]) where i ranges from 1 to bound_size() - 1. Note that + # there are no finite buckets at all if 'bound' only contains a single element; + # in that special case the single bound defines the boundary between the + # underflow and overflow buckets. bucket number lower bound upper bound i == 0 ( + # underflow) -inf bound[i] 0 < i < bound_size() bound[i-1] bound[i] i == + # bound_size() (overflow) bound[i-1] +inf + # Corresponds to the JSON property `bounds` + # @return [Array] + attr_accessor :bounds + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bounds = args[:bounds] if args.key?(:bounds) + end + end + + # Describing buckets with exponentially growing width. + class GoogleApiServicecontrolV1ExponentialBuckets + include Google::Apis::Core::Hashable + + # The i'th exponential bucket covers the interval [scale * growth_factor^(i-1), + # scale * growth_factor^i) where i ranges from 1 to num_finite_buckets inclusive. + # Must be larger than 1.0. + # Corresponds to the JSON property `growthFactor` + # @return [Float] + attr_accessor :growth_factor + + # The number of finite buckets. With the underflow and overflow buckets, the + # total number of buckets is `num_finite_buckets` + 2. See comments on ` + # bucket_options` for details. + # Corresponds to the JSON property `numFiniteBuckets` + # @return [Fixnum] + attr_accessor :num_finite_buckets + + # The i'th exponential bucket covers the interval [scale * growth_factor^(i-1), + # scale * growth_factor^i) where i ranges from 1 to num_finite_buckets inclusive. + # Must be > 0. + # Corresponds to the JSON property `scale` + # @return [Float] + attr_accessor :scale + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @growth_factor = args[:growth_factor] if args.key?(:growth_factor) + @num_finite_buckets = args[:num_finite_buckets] if args.key?(:num_finite_buckets) + @scale = args[:scale] if args.key?(:scale) + end + end + + # A common proto for logging HTTP requests. Only contains semantics defined by + # the HTTP specification. Product-specific logging information MUST be defined + # in a separate message. + class GoogleApiServicecontrolV1HttpRequest + include Google::Apis::Core::Hashable + + # The number of HTTP response bytes inserted into cache. Set only when a cache + # fill was attempted. + # Corresponds to the JSON property `cacheFillBytes` + # @return [Fixnum] + attr_accessor :cache_fill_bytes + + # Whether or not an entity was served from cache (with or without validation). + # Corresponds to the JSON property `cacheHit` + # @return [Boolean] + attr_accessor :cache_hit + alias_method :cache_hit?, :cache_hit + + # Whether or not a cache lookup was attempted. + # Corresponds to the JSON property `cacheLookup` + # @return [Boolean] + attr_accessor :cache_lookup + alias_method :cache_lookup?, :cache_lookup + + # Whether or not the response was validated with the origin server before being + # served from cache. This field is only meaningful if `cache_hit` is True. + # Corresponds to the JSON property `cacheValidatedWithOriginServer` + # @return [Boolean] + attr_accessor :cache_validated_with_origin_server + alias_method :cache_validated_with_origin_server?, :cache_validated_with_origin_server + + # The request processing latency on the server, from the time the request was + # received until the response was sent. + # Corresponds to the JSON property `latency` + # @return [String] + attr_accessor :latency + + # Protocol used for the request. Examples: "HTTP/1.1", "HTTP/2", "websocket" + # Corresponds to the JSON property `protocol` + # @return [String] + attr_accessor :protocol + + # The referer URL of the request, as defined in [HTTP/1.1 Header Field + # Definitions](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). + # Corresponds to the JSON property `referer` + # @return [String] + attr_accessor :referer + + # The IP address (IPv4 or IPv6) of the client that issued the HTTP request. + # Examples: `"192.168.1.1"`, `"FE80::0202:B3FF:FE1E:8329"`. + # Corresponds to the JSON property `remoteIp` + # @return [String] + attr_accessor :remote_ip + + # The request method. Examples: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`. + # Corresponds to the JSON property `requestMethod` + # @return [String] + attr_accessor :request_method + + # The size of the HTTP request message in bytes, including the request headers + # and the request body. + # Corresponds to the JSON property `requestSize` + # @return [Fixnum] + attr_accessor :request_size + + # The scheme (http, https), the host name, the path, and the query portion of + # the URL that was requested. Example: `"http://example.com/some/info?color=red"` + # . + # Corresponds to the JSON property `requestUrl` + # @return [String] + attr_accessor :request_url + + # The size of the HTTP response message sent back to the client, in bytes, + # including the response headers and the response body. + # Corresponds to the JSON property `responseSize` + # @return [Fixnum] + attr_accessor :response_size + + # The IP address (IPv4 or IPv6) of the origin server that the request was sent + # to. + # Corresponds to the JSON property `serverIp` + # @return [String] + attr_accessor :server_ip + + # The response code indicating the status of the response. Examples: 200, 404. + # Corresponds to the JSON property `status` + # @return [Fixnum] + attr_accessor :status + + # The user agent sent by the client. Example: `"Mozilla/4.0 (compatible; MSIE 6. + # 0; Windows 98; Q312461; .NET CLR 1.0.3705)"`. + # Corresponds to the JSON property `userAgent` + # @return [String] + attr_accessor :user_agent + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @cache_fill_bytes = args[:cache_fill_bytes] if args.key?(:cache_fill_bytes) + @cache_hit = args[:cache_hit] if args.key?(:cache_hit) + @cache_lookup = args[:cache_lookup] if args.key?(:cache_lookup) + @cache_validated_with_origin_server = args[:cache_validated_with_origin_server] if args.key?(:cache_validated_with_origin_server) + @latency = args[:latency] if args.key?(:latency) + @protocol = args[:protocol] if args.key?(:protocol) + @referer = args[:referer] if args.key?(:referer) + @remote_ip = args[:remote_ip] if args.key?(:remote_ip) + @request_method = args[:request_method] if args.key?(:request_method) + @request_size = args[:request_size] if args.key?(:request_size) + @request_url = args[:request_url] if args.key?(:request_url) + @response_size = args[:response_size] if args.key?(:response_size) + @server_ip = args[:server_ip] if args.key?(:server_ip) + @status = args[:status] if args.key?(:status) + @user_agent = args[:user_agent] if args.key?(:user_agent) + end + end + + # Describing buckets with constant width. + class GoogleApiServicecontrolV1LinearBuckets + include Google::Apis::Core::Hashable + + # The number of finite buckets. With the underflow and overflow buckets, the + # total number of buckets is `num_finite_buckets` + 2. See comments on ` + # bucket_options` for details. + # Corresponds to the JSON property `numFiniteBuckets` + # @return [Fixnum] + attr_accessor :num_finite_buckets + + # The i'th linear bucket covers the interval [offset + (i-1) * width, offset + i + # * width) where i ranges from 1 to num_finite_buckets, inclusive. + # Corresponds to the JSON property `offset` + # @return [Float] + attr_accessor :offset + + # The i'th linear bucket covers the interval [offset + (i-1) * width, offset + i + # * width) where i ranges from 1 to num_finite_buckets, inclusive. Must be + # strictly positive. + # Corresponds to the JSON property `width` + # @return [Float] + attr_accessor :width + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @num_finite_buckets = args[:num_finite_buckets] if args.key?(:num_finite_buckets) + @offset = args[:offset] if args.key?(:offset) + @width = args[:width] if args.key?(:width) + end + end + + # An individual log entry. + class GoogleApiServicecontrolV1LogEntry + include Google::Apis::Core::Hashable + + # A common proto for logging HTTP requests. Only contains semantics defined by + # the HTTP specification. Product-specific logging information MUST be defined + # in a separate message. + # Corresponds to the JSON property `httpRequest` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1HttpRequest] + attr_accessor :http_request + + # A unique ID for the log entry used for deduplication. If omitted, the + # implementation will generate one based on operation_id. + # Corresponds to the JSON property `insertId` + # @return [String] + attr_accessor :insert_id + + # A set of user-defined (key, value) data that provides additional information + # about the log entry. + # Corresponds to the JSON property `labels` + # @return [Hash] + attr_accessor :labels + + # Required. The log to which this log entry belongs. Examples: `"syslog"`, `" + # book_log"`. + # Corresponds to the JSON property `name` + # @return [String] + attr_accessor :name + + # Additional information about a potentially long-running operation with which a + # log entry is associated. + # Corresponds to the JSON property `operation` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LogEntryOperation] + attr_accessor :operation + + # The log entry payload, represented as a protocol buffer that is expressed as a + # JSON object. The only accepted type currently is AuditLog. + # Corresponds to the JSON property `protoPayload` + # @return [Hash] + attr_accessor :proto_payload + + # The severity of the log entry. The default value is `LogSeverity.DEFAULT`. + # Corresponds to the JSON property `severity` + # @return [String] + attr_accessor :severity + + # Additional information about the source code location that produced the log + # entry. + # Corresponds to the JSON property `sourceLocation` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LogEntrySourceLocation] + attr_accessor :source_location + + # The log entry payload, represented as a structure that is expressed as a JSON + # object. + # Corresponds to the JSON property `structPayload` + # @return [Hash] + attr_accessor :struct_payload + + # The log entry payload, represented as a Unicode string (UTF-8). + # Corresponds to the JSON property `textPayload` + # @return [String] + attr_accessor :text_payload + + # The time the event described by the log entry occurred. If omitted, defaults + # to operation start time. + # Corresponds to the JSON property `timestamp` + # @return [String] + attr_accessor :timestamp + + # Optional. Resource name of the trace associated with the log entry, if any. If + # this field contains a relative resource name, you can assume the name is + # relative to `//tracing.googleapis.com`. Example: `projects/my-projectid/traces/ + # 06796866738c859f2f19b7cfb3214824` + # Corresponds to the JSON property `trace` + # @return [String] + attr_accessor :trace + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @http_request = args[:http_request] if args.key?(:http_request) + @insert_id = args[:insert_id] if args.key?(:insert_id) + @labels = args[:labels] if args.key?(:labels) + @name = args[:name] if args.key?(:name) + @operation = args[:operation] if args.key?(:operation) + @proto_payload = args[:proto_payload] if args.key?(:proto_payload) + @severity = args[:severity] if args.key?(:severity) + @source_location = args[:source_location] if args.key?(:source_location) + @struct_payload = args[:struct_payload] if args.key?(:struct_payload) + @text_payload = args[:text_payload] if args.key?(:text_payload) + @timestamp = args[:timestamp] if args.key?(:timestamp) + @trace = args[:trace] if args.key?(:trace) + end + end + + # Additional information about a potentially long-running operation with which a + # log entry is associated. + class GoogleApiServicecontrolV1LogEntryOperation + include Google::Apis::Core::Hashable + + # Optional. Set this to True if this is the first log entry in the operation. + # Corresponds to the JSON property `first` + # @return [Boolean] + attr_accessor :first + alias_method :first?, :first + + # Optional. An arbitrary operation identifier. Log entries with the same + # identifier are assumed to be part of the same operation. + # Corresponds to the JSON property `id` + # @return [String] + attr_accessor :id + + # Optional. Set this to True if this is the last log entry in the operation. + # Corresponds to the JSON property `last` + # @return [Boolean] + attr_accessor :last + alias_method :last?, :last + + # Optional. An arbitrary producer identifier. The combination of `id` and ` + # producer` must be globally unique. Examples for `producer`: `"MyDivision. + # MyBigCompany.com"`, `"github.com/MyProject/MyApplication"`. + # Corresponds to the JSON property `producer` + # @return [String] + attr_accessor :producer + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @first = args[:first] if args.key?(:first) + @id = args[:id] if args.key?(:id) + @last = args[:last] if args.key?(:last) + @producer = args[:producer] if args.key?(:producer) + end + end + + # Additional information about the source code location that produced the log + # entry. + class GoogleApiServicecontrolV1LogEntrySourceLocation + include Google::Apis::Core::Hashable + + # Optional. Source file name. Depending on the runtime environment, this might + # be a simple name or a fully-qualified name. + # Corresponds to the JSON property `file` + # @return [String] + attr_accessor :file + + # Optional. Human-readable name of the function or method being invoked, with + # optional context such as the class or package name. This information may be + # used in contexts such as the logs viewer, where a file and line number are + # less meaningful. The format can vary by language. For example: `qual.if.ied. + # Class.method` (Java), `dir/package.func` (Go), `function` (Python). + # Corresponds to the JSON property `function` + # @return [String] + attr_accessor :function + + # Optional. Line within the source file. 1-based; 0 indicates no line number + # available. + # Corresponds to the JSON property `line` + # @return [Fixnum] + attr_accessor :line + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @file = args[:file] if args.key?(:file) + @function = args[:function] if args.key?(:function) + @line = args[:line] if args.key?(:line) + end + end + + # Represents a single metric value. + class GoogleApiServicecontrolV1MetricValue + include Google::Apis::Core::Hashable + + # A boolean value. + # Corresponds to the JSON property `boolValue` + # @return [Boolean] + attr_accessor :bool_value + alias_method :bool_value?, :bool_value + + # Distribution represents a frequency distribution of double-valued sample + # points. It contains the size of the population of sample points plus + # additional optional information: - the arithmetic mean of the samples - the + # minimum and maximum of the samples - the sum-squared-deviation of the samples, + # used to compute variance - a histogram of the values of the sample points + # Corresponds to the JSON property `distributionValue` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1Distribution] + attr_accessor :distribution_value + + # A double precision floating point value. + # Corresponds to the JSON property `doubleValue` + # @return [Float] + attr_accessor :double_value + + # The end of the time period over which this metric value's measurement applies. + # If not specified, google.api.servicecontrol.v1.Operation.end_time will be used. + # Corresponds to the JSON property `endTime` + # @return [String] + attr_accessor :end_time + + # A signed 64-bit integer value. + # Corresponds to the JSON property `int64Value` + # @return [Fixnum] + attr_accessor :int64_value + + # The labels describing the metric value. See comments on google.api. + # servicecontrol.v1.Operation.labels for the overriding relationship. Note that + # this map must not contain monitored resource labels. + # Corresponds to the JSON property `labels` + # @return [Hash] + attr_accessor :labels + + # Represents an amount of money with its currency type. + # Corresponds to the JSON property `moneyValue` + # @return [Google::Apis::PrivatecaV1beta1::Money] + attr_accessor :money_value + + # The start of the time period over which this metric value's measurement + # applies. The time period has different semantics for different metric types ( + # cumulative, delta, and gauge). See the metric definition documentation in the + # service configuration for details. If not specified, google.api.servicecontrol. + # v1.Operation.start_time will be used. + # Corresponds to the JSON property `startTime` + # @return [String] + attr_accessor :start_time + + # A text string value. + # Corresponds to the JSON property `stringValue` + # @return [String] + attr_accessor :string_value + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @bool_value = args[:bool_value] if args.key?(:bool_value) + @distribution_value = args[:distribution_value] if args.key?(:distribution_value) + @double_value = args[:double_value] if args.key?(:double_value) + @end_time = args[:end_time] if args.key?(:end_time) + @int64_value = args[:int64_value] if args.key?(:int64_value) + @labels = args[:labels] if args.key?(:labels) + @money_value = args[:money_value] if args.key?(:money_value) + @start_time = args[:start_time] if args.key?(:start_time) + @string_value = args[:string_value] if args.key?(:string_value) + end + end + + # Represents a set of metric values in the same metric. Each metric value in the + # set should have a unique combination of start time, end time, and label values. + class GoogleApiServicecontrolV1MetricValueSet + include Google::Apis::Core::Hashable + + # The metric name defined in the service configuration. + # Corresponds to the JSON property `metricName` + # @return [String] + attr_accessor :metric_name + + # The values in this metric. + # Corresponds to the JSON property `metricValues` + # @return [Array] + attr_accessor :metric_values + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @metric_name = args[:metric_name] if args.key?(:metric_name) + @metric_values = args[:metric_values] if args.key?(:metric_values) + end + end + + # Represents information regarding an operation. + class GoogleApiServicecontrolV1Operation + include Google::Apis::Core::Hashable + + # Identity of the consumer who is using the service. This field should be filled + # in for the operations initiated by a consumer, but not for service-initiated + # operations that are not related to a specific consumer. - This can be in one + # of the following formats: - project:PROJECT_ID, - project`_`number: + # PROJECT_NUMBER, - projects/PROJECT_ID or PROJECT_NUMBER, - folders/ + # FOLDER_NUMBER, - organizations/ORGANIZATION_NUMBER, - api`_`key:API_KEY. + # Corresponds to the JSON property `consumerId` + # @return [String] + attr_accessor :consumer_id + + # End time of the operation. Required when the operation is used in + # ServiceController.Report, but optional when the operation is used in + # ServiceController.Check. + # Corresponds to the JSON property `endTime` + # @return [String] + attr_accessor :end_time + + # Unimplemented. + # Corresponds to the JSON property `extensions` + # @return [Array>] + attr_accessor :extensions + + # DO NOT USE. This is an experimental field. + # Corresponds to the JSON property `importance` + # @return [String] + attr_accessor :importance + + # Labels describing the operation. Only the following labels are allowed: - + # Labels describing monitored resources as defined in the service configuration. + # - Default labels of metric values. When specified, labels defined in the + # metric value override these default. - The following labels defined by Google + # Cloud Platform: - `cloud.googleapis.com/location` describing the location + # where the operation happened, - `servicecontrol.googleapis.com/user_agent` + # describing the user agent of the API request, - `servicecontrol.googleapis.com/ + # service_agent` describing the service used to handle the API request (e.g. ESP) + # , - `servicecontrol.googleapis.com/platform` describing the platform where the + # API is served, such as App Engine, Compute Engine, or Kubernetes Engine. + # Corresponds to the JSON property `labels` + # @return [Hash] + attr_accessor :labels + + # Represents information to be logged. + # Corresponds to the JSON property `logEntries` + # @return [Array] + attr_accessor :log_entries + + # Represents information about this operation. Each MetricValueSet corresponds + # to a metric defined in the service configuration. The data type used in the + # MetricValueSet must agree with the data type specified in the metric + # definition. Within a single operation, it is not allowed to have more than one + # MetricValue instances that have the same metric names and identical label + # value combinations. If a request has such duplicated MetricValue instances, + # the entire request is rejected with an invalid argument error. + # Corresponds to the JSON property `metricValueSets` + # @return [Array] + attr_accessor :metric_value_sets + + # Identity of the operation. This must be unique within the scope of the service + # that generated the operation. If the service calls Check() and Report() on the + # same operation, the two calls should carry the same id. UUID version 4 is + # recommended, though not required. In scenarios where an operation is computed + # from existing information and an idempotent id is desirable for deduplication + # purpose, UUID version 5 is recommended. See RFC 4122 for details. + # Corresponds to the JSON property `operationId` + # @return [String] + attr_accessor :operation_id + + # Fully qualified name of the operation. Reserved for future use. + # Corresponds to the JSON property `operationName` + # @return [String] + attr_accessor :operation_name + + # Represents the properties needed for quota operations. + # Corresponds to the JSON property `quotaProperties` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1QuotaProperties] + attr_accessor :quota_properties + + # The resources that are involved in the operation. The maximum supported number + # of entries in this field is 100. + # Corresponds to the JSON property `resources` + # @return [Array] + attr_accessor :resources + + # Required. Start time of the operation. + # Corresponds to the JSON property `startTime` + # @return [String] + attr_accessor :start_time + + # Unimplemented. A list of Cloud Trace spans. The span names shall contain the + # id of the destination project which can be either the produce or the consumer + # project. + # Corresponds to the JSON property `traceSpans` + # @return [Array] + attr_accessor :trace_spans + + # User defined labels for the resource that this operation is associated with. + # Only a combination of 1000 user labels per consumer project are allowed. + # Corresponds to the JSON property `userLabels` + # @return [Hash] + attr_accessor :user_labels + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @consumer_id = args[:consumer_id] if args.key?(:consumer_id) + @end_time = args[:end_time] if args.key?(:end_time) + @extensions = args[:extensions] if args.key?(:extensions) + @importance = args[:importance] if args.key?(:importance) + @labels = args[:labels] if args.key?(:labels) + @log_entries = args[:log_entries] if args.key?(:log_entries) + @metric_value_sets = args[:metric_value_sets] if args.key?(:metric_value_sets) + @operation_id = args[:operation_id] if args.key?(:operation_id) + @operation_name = args[:operation_name] if args.key?(:operation_name) + @quota_properties = args[:quota_properties] if args.key?(:quota_properties) + @resources = args[:resources] if args.key?(:resources) + @start_time = args[:start_time] if args.key?(:start_time) + @trace_spans = args[:trace_spans] if args.key?(:trace_spans) + @user_labels = args[:user_labels] if args.key?(:user_labels) + end + end + + # Represents the properties needed for quota operations. + class GoogleApiServicecontrolV1QuotaProperties + include Google::Apis::Core::Hashable + + # Quota mode for this operation. + # Corresponds to the JSON property `quotaMode` + # @return [String] + attr_accessor :quota_mode + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @quota_mode = args[:quota_mode] if args.key?(:quota_mode) + end + end + + # Request message for the Report method. + class GoogleApiServicecontrolV1ReportRequest + include Google::Apis::Core::Hashable + + # Operations to be reported. Typically the service should report one operation + # per request. Putting multiple operations into a single request is allowed, but + # should be used only when multiple operations are natually available at the + # time of the report. There is no limit on the number of operations in the same + # ReportRequest, however the ReportRequest size should be no larger than 1MB. + # See ReportResponse.report_errors for partial failure behavior. + # Corresponds to the JSON property `operations` + # @return [Array] + attr_accessor :operations + + # Specifies which version of service config should be used to process the + # request. If unspecified or no matching version can be found, the latest one + # will be used. + # Corresponds to the JSON property `serviceConfigId` + # @return [String] + attr_accessor :service_config_id + + # The service name as specified in its service configuration. For example, `" + # pubsub.googleapis.com"`. See [google.api.Service](https://cloud.google.com/ + # service-management/reference/rpc/google.api#google.api.Service) for the + # definition of a service name. + # Corresponds to the JSON property `serviceName` + # @return [String] + attr_accessor :service_name + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @operations = args[:operations] if args.key?(:operations) + @service_config_id = args[:service_config_id] if args.key?(:service_config_id) + @service_name = args[:service_name] if args.key?(:service_name) + end + end + + # Describes a resource associated with this operation. + class GoogleApiServicecontrolV1ResourceInfo + include Google::Apis::Core::Hashable + + # The identifier of the parent of this resource instance. Must be in one of the + # following formats: - `projects/` - `folders/` - `organizations/` + # Corresponds to the JSON property `resourceContainer` + # @return [String] + attr_accessor :resource_container + + # The location of the resource. If not empty, the resource will be checked + # against location policy. The value must be a valid zone, region or multiregion. + # For example: "europe-west4" or "northamerica-northeast1-a" + # Corresponds to the JSON property `resourceLocation` + # @return [String] + attr_accessor :resource_location + + # Name of the resource. This is used for auditing purposes. + # Corresponds to the JSON property `resourceName` + # @return [String] + attr_accessor :resource_name + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @resource_container = args[:resource_container] if args.key?(:resource_container) + @resource_location = args[:resource_location] if args.key?(:resource_location) + @resource_name = args[:resource_name] if args.key?(:resource_name) + end + end + + # A span represents a single operation within a trace. Spans can be nested to + # form a trace tree. Often, a trace contains a root span that describes the end- + # to-end latency, and one or more subspans for its sub-operations. A trace can + # also contain multiple root spans, or none at all. Spans do not need to be + # contiguous—there may be gaps or overlaps between spans in a trace. + class GoogleApiServicecontrolV1TraceSpan + include Google::Apis::Core::Hashable + + # A set of attributes, each in the format `[KEY]:[VALUE]`. + # Corresponds to the JSON property `attributes` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1Attributes] + attr_accessor :attributes + + # An optional number of child spans that were generated while this span was + # active. If set, allows implementation to detect missing child spans. + # Corresponds to the JSON property `childSpanCount` + # @return [Fixnum] + attr_accessor :child_span_count + + # Represents a string that might be shortened to a specified length. + # Corresponds to the JSON property `displayName` + # @return [Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1TruncatableString] + attr_accessor :display_name + + # The end time of the span. On the client side, this is the time kept by the + # local machine where the span execution ends. On the server side, this is the + # time when the server application handler stops running. + # Corresponds to the JSON property `endTime` + # @return [String] + attr_accessor :end_time + + # The resource name of the span in the following format: projects/[PROJECT_ID]/ + # traces/[TRACE_ID]/spans/SPAN_ID is a unique identifier for a trace within a + # project; it is a 32-character hexadecimal encoding of a 16-byte array. [ + # SPAN_ID] is a unique identifier for a span within a trace; it is a 16- + # character hexadecimal encoding of an 8-byte array. + # Corresponds to the JSON property `name` + # @return [String] + attr_accessor :name + + # The [SPAN_ID] of this span's parent span. If this is a root span, then this + # field must be empty. + # Corresponds to the JSON property `parentSpanId` + # @return [String] + attr_accessor :parent_span_id + + # (Optional) Set this parameter to indicate whether this span is in the same + # process as its parent. If you do not set this parameter, Stackdriver Trace is + # unable to take advantage of this helpful information. + # Corresponds to the JSON property `sameProcessAsParentSpan` + # @return [Boolean] + attr_accessor :same_process_as_parent_span + alias_method :same_process_as_parent_span?, :same_process_as_parent_span + + # The [SPAN_ID] portion of the span's resource name. + # Corresponds to the JSON property `spanId` + # @return [String] + attr_accessor :span_id + + # Distinguishes between spans generated in a particular context. For example, + # two spans with the same name may be distinguished using `CLIENT` (caller) and ` + # SERVER` (callee) to identify an RPC call. + # Corresponds to the JSON property `spanKind` + # @return [String] + attr_accessor :span_kind + + # The start time of the span. On the client side, this is the time kept by the + # local machine where the span execution starts. On the server side, this is the + # time when the server's application handler starts running. + # Corresponds to the JSON property `startTime` + # @return [String] + attr_accessor :start_time + + # The `Status` type defines a logical error model that is suitable for different + # programming environments, including REST APIs and RPC APIs. It is used by [ + # gRPC](https://github.com/grpc). Each `Status` message contains three pieces of + # data: error code, error message, and error details. You can find out more + # about this error model and how to work with it in the [API Design Guide](https: + # //cloud.google.com/apis/design/errors). + # Corresponds to the JSON property `status` + # @return [Google::Apis::PrivatecaV1beta1::Status] + attr_accessor :status + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @attributes = args[:attributes] if args.key?(:attributes) + @child_span_count = args[:child_span_count] if args.key?(:child_span_count) + @display_name = args[:display_name] if args.key?(:display_name) + @end_time = args[:end_time] if args.key?(:end_time) + @name = args[:name] if args.key?(:name) + @parent_span_id = args[:parent_span_id] if args.key?(:parent_span_id) + @same_process_as_parent_span = args[:same_process_as_parent_span] if args.key?(:same_process_as_parent_span) + @span_id = args[:span_id] if args.key?(:span_id) + @span_kind = args[:span_kind] if args.key?(:span_kind) + @start_time = args[:start_time] if args.key?(:start_time) + @status = args[:status] if args.key?(:status) + end + end + + # Represents a string that might be shortened to a specified length. + class GoogleApiServicecontrolV1TruncatableString + include Google::Apis::Core::Hashable + + # The number of bytes removed from the original string. If this value is 0, then + # the string was not shortened. + # Corresponds to the JSON property `truncatedByteCount` + # @return [Fixnum] + attr_accessor :truncated_byte_count + + # The shortened string. For example, if the original string is 500 bytes long + # and the limit of the string is 128 bytes, then `value` contains the first 128 + # bytes of the 500-byte string. Truncation always happens on a UTF8 character + # boundary. If there are multi-byte characters in the string, then the length of + # the shortened string might be less than the size limit. + # Corresponds to the JSON property `value` + # @return [String] + attr_accessor :value + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @truncated_byte_count = args[:truncated_byte_count] if args.key?(:truncated_byte_count) + @value = args[:value] if args.key?(:value) + end + end + # IssuanceModes specifies the allowed ways in which Certificates may be # requested from this CertificateAuthority. class IssuanceModes @@ -1504,6 +2574,42 @@ module Google end end + # Represents an amount of money with its currency type. + class Money + include Google::Apis::Core::Hashable + + # The three-letter currency code defined in ISO 4217. + # Corresponds to the JSON property `currencyCode` + # @return [String] + attr_accessor :currency_code + + # Number of nano (10^-9) units of the amount. The value must be between -999,999, + # 999 and +999,999,999 inclusive. If `units` is positive, `nanos` must be + # positive or zero. If `units` is zero, `nanos` can be positive, zero, or + # negative. If `units` is negative, `nanos` must be negative or zero. For + # example $-1.75 is represented as `units`=-1 and `nanos`=-750,000,000. + # Corresponds to the JSON property `nanos` + # @return [Fixnum] + attr_accessor :nanos + + # The whole units of the amount. For example if `currencyCode` is `"USD"`, then + # 1 unit is one US dollar. + # Corresponds to the JSON property `units` + # @return [Fixnum] + attr_accessor :units + + def initialize(**args) + update!(**args) + end + + # Update properties of this object + def update!(**args) + @currency_code = args[:currency_code] if args.key?(:currency_code) + @nanos = args[:nanos] if args.key?(:nanos) + @units = args[:units] if args.key?(:units) + end + end + # An ObjectId specifies an object identifier (OID). These provide context and # describe types in ASN.1 messages. class ObjectIdProp @@ -2024,6 +3130,13 @@ module Google class ScheduleDeleteCertificateAuthorityRequest include Google::Apis::Core::Hashable + # Optional. This field allows the CA to be scheduled for deletion even if the CA + # has active certs. Active certs include both unrevoked and unexpired certs. + # Corresponds to the JSON property `ignoreActiveCertificates` + # @return [Boolean] + attr_accessor :ignore_active_certificates + alias_method :ignore_active_certificates?, :ignore_active_certificates + # Optional. An ID to identify requests. Specify a unique request ID so that if # you must retry your request, the server will know to ignore the request if it # has already been completed. The server will guarantee that for at least 60 @@ -2044,6 +3157,7 @@ module Google # Update properties of this object def update!(**args) + @ignore_active_certificates = args[:ignore_active_certificates] if args.key?(:ignore_active_certificates) @request_id = args[:request_id] if args.key?(:request_id) end end diff --git a/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/gem_version.rb b/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/gem_version.rb index 0bc3f46b0..f48fefe87 100644 --- a/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/gem_version.rb +++ b/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/gem_version.rb @@ -16,13 +16,13 @@ module Google module Apis module PrivatecaV1beta1 # Version of the google-apis-privateca_v1beta1 gem - GEM_VERSION = "0.1.0" + GEM_VERSION = "0.2.0" # Version of the code generator used to generate this client GENERATOR_VERSION = "0.1.1" # Revision of the discovery document this client was generated from - REVISION = "20201203" + REVISION = "20201216" end end end diff --git a/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/representations.rb b/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/representations.rb index 90db25557..5164ed60c 100644 --- a/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/representations.rb +++ b/generated/google-apis-privateca_v1beta1/lib/google/apis/privateca_v1beta1/representations.rb @@ -58,6 +58,12 @@ module Google include Google::Apis::Core::JsonObjectSupport end + class BillingView + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + class Binding class Representation < Google::Apis::Core::JsonRepresentation; end @@ -136,6 +142,12 @@ module Google include Google::Apis::Core::JsonObjectSupport end + class Exemplar + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + class Expr class Representation < Google::Apis::Core::JsonRepresentation; end @@ -154,6 +166,114 @@ module Google include Google::Apis::Core::JsonObjectSupport end + class GoogleApiServicecontrolV1AttributeValue + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1Attributes + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1Distribution + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1ExplicitBuckets + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1ExponentialBuckets + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1HttpRequest + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1LinearBuckets + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1LogEntry + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1LogEntryOperation + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1LogEntrySourceLocation + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1MetricValue + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1MetricValueSet + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1Operation + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1QuotaProperties + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1ReportRequest + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1ResourceInfo + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1TraceSpan + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + + class GoogleApiServicecontrolV1TruncatableString + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + class IssuanceModes class Representation < Google::Apis::Core::JsonRepresentation; end @@ -232,6 +352,12 @@ module Google include Google::Apis::Core::JsonObjectSupport end + class Money + class Representation < Google::Apis::Core::JsonRepresentation; end + + include Google::Apis::Core::JsonObjectSupport + end + class ObjectIdProp class Representation < Google::Apis::Core::JsonRepresentation; end @@ -431,6 +557,14 @@ module Google end end + class BillingView + # @private + class Representation < Google::Apis::Core::JsonRepresentation + collection :report_requests, as: 'reportRequests', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ReportRequest, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ReportRequest::Representation + + end + end + class Binding # @private class Representation < Google::Apis::Core::JsonRepresentation @@ -599,6 +733,15 @@ module Google end end + class Exemplar + # @private + class Representation < Google::Apis::Core::JsonRepresentation + collection :attachments, as: 'attachments' + property :timestamp, as: 'timestamp' + property :value, as: 'value' + end + end + class Expr # @private class Representation < Google::Apis::Core::JsonRepresentation @@ -628,6 +771,236 @@ module Google end end + class GoogleApiServicecontrolV1AttributeValue + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :bool_value, as: 'boolValue' + property :int_value, :numeric_string => true, as: 'intValue' + property :string_value, as: 'stringValue', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1TruncatableString, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1TruncatableString::Representation + + end + end + + class GoogleApiServicecontrolV1Attributes + # @private + class Representation < Google::Apis::Core::JsonRepresentation + hash :attribute_map, as: 'attributeMap', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1AttributeValue, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1AttributeValue::Representation + + property :dropped_attributes_count, as: 'droppedAttributesCount' + end + end + + class GoogleApiServicecontrolV1Distribution + # @private + class Representation < Google::Apis::Core::JsonRepresentation + collection :bucket_counts, as: 'bucketCounts' + property :count, :numeric_string => true, as: 'count' + collection :exemplars, as: 'exemplars', class: Google::Apis::PrivatecaV1beta1::Exemplar, decorator: Google::Apis::PrivatecaV1beta1::Exemplar::Representation + + property :explicit_buckets, as: 'explicitBuckets', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ExplicitBuckets, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ExplicitBuckets::Representation + + property :exponential_buckets, as: 'exponentialBuckets', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ExponentialBuckets, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ExponentialBuckets::Representation + + property :linear_buckets, as: 'linearBuckets', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LinearBuckets, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LinearBuckets::Representation + + property :maximum, as: 'maximum' + property :mean, as: 'mean' + property :minimum, as: 'minimum' + property :sum_of_squared_deviation, as: 'sumOfSquaredDeviation' + end + end + + class GoogleApiServicecontrolV1ExplicitBuckets + # @private + class Representation < Google::Apis::Core::JsonRepresentation + collection :bounds, as: 'bounds' + end + end + + class GoogleApiServicecontrolV1ExponentialBuckets + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :growth_factor, as: 'growthFactor' + property :num_finite_buckets, as: 'numFiniteBuckets' + property :scale, as: 'scale' + end + end + + class GoogleApiServicecontrolV1HttpRequest + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :cache_fill_bytes, :numeric_string => true, as: 'cacheFillBytes' + property :cache_hit, as: 'cacheHit' + property :cache_lookup, as: 'cacheLookup' + property :cache_validated_with_origin_server, as: 'cacheValidatedWithOriginServer' + property :latency, as: 'latency' + property :protocol, as: 'protocol' + property :referer, as: 'referer' + property :remote_ip, as: 'remoteIp' + property :request_method, as: 'requestMethod' + property :request_size, :numeric_string => true, as: 'requestSize' + property :request_url, as: 'requestUrl' + property :response_size, :numeric_string => true, as: 'responseSize' + property :server_ip, as: 'serverIp' + property :status, as: 'status' + property :user_agent, as: 'userAgent' + end + end + + class GoogleApiServicecontrolV1LinearBuckets + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :num_finite_buckets, as: 'numFiniteBuckets' + property :offset, as: 'offset' + property :width, as: 'width' + end + end + + class GoogleApiServicecontrolV1LogEntry + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :http_request, as: 'httpRequest', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1HttpRequest, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1HttpRequest::Representation + + property :insert_id, as: 'insertId' + hash :labels, as: 'labels' + property :name, as: 'name' + property :operation, as: 'operation', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LogEntryOperation, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LogEntryOperation::Representation + + hash :proto_payload, as: 'protoPayload' + property :severity, as: 'severity' + property :source_location, as: 'sourceLocation', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LogEntrySourceLocation, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LogEntrySourceLocation::Representation + + hash :struct_payload, as: 'structPayload' + property :text_payload, as: 'textPayload' + property :timestamp, as: 'timestamp' + property :trace, as: 'trace' + end + end + + class GoogleApiServicecontrolV1LogEntryOperation + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :first, as: 'first' + property :id, as: 'id' + property :last, as: 'last' + property :producer, as: 'producer' + end + end + + class GoogleApiServicecontrolV1LogEntrySourceLocation + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :file, as: 'file' + property :function, as: 'function' + property :line, :numeric_string => true, as: 'line' + end + end + + class GoogleApiServicecontrolV1MetricValue + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :bool_value, as: 'boolValue' + property :distribution_value, as: 'distributionValue', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1Distribution, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1Distribution::Representation + + property :double_value, as: 'doubleValue' + property :end_time, as: 'endTime' + property :int64_value, :numeric_string => true, as: 'int64Value' + hash :labels, as: 'labels' + property :money_value, as: 'moneyValue', class: Google::Apis::PrivatecaV1beta1::Money, decorator: Google::Apis::PrivatecaV1beta1::Money::Representation + + property :start_time, as: 'startTime' + property :string_value, as: 'stringValue' + end + end + + class GoogleApiServicecontrolV1MetricValueSet + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :metric_name, as: 'metricName' + collection :metric_values, as: 'metricValues', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1MetricValue, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1MetricValue::Representation + + end + end + + class GoogleApiServicecontrolV1Operation + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :consumer_id, as: 'consumerId' + property :end_time, as: 'endTime' + collection :extensions, as: 'extensions' + property :importance, as: 'importance' + hash :labels, as: 'labels' + collection :log_entries, as: 'logEntries', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LogEntry, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LogEntry::Representation + + collection :metric_value_sets, as: 'metricValueSets', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1MetricValueSet, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1MetricValueSet::Representation + + property :operation_id, as: 'operationId' + property :operation_name, as: 'operationName' + property :quota_properties, as: 'quotaProperties', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1QuotaProperties, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1QuotaProperties::Representation + + collection :resources, as: 'resources', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ResourceInfo, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ResourceInfo::Representation + + property :start_time, as: 'startTime' + collection :trace_spans, as: 'traceSpans', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1TraceSpan, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1TraceSpan::Representation + + hash :user_labels, as: 'userLabels' + end + end + + class GoogleApiServicecontrolV1QuotaProperties + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :quota_mode, as: 'quotaMode' + end + end + + class GoogleApiServicecontrolV1ReportRequest + # @private + class Representation < Google::Apis::Core::JsonRepresentation + collection :operations, as: 'operations', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1Operation, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1Operation::Representation + + property :service_config_id, as: 'serviceConfigId' + property :service_name, as: 'serviceName' + end + end + + class GoogleApiServicecontrolV1ResourceInfo + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :resource_container, as: 'resourceContainer' + property :resource_location, as: 'resourceLocation' + property :resource_name, as: 'resourceName' + end + end + + class GoogleApiServicecontrolV1TraceSpan + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :attributes, as: 'attributes', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1Attributes, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1Attributes::Representation + + property :child_span_count, as: 'childSpanCount' + property :display_name, as: 'displayName', class: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1TruncatableString, decorator: Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1TruncatableString::Representation + + property :end_time, as: 'endTime' + property :name, as: 'name' + property :parent_span_id, as: 'parentSpanId' + property :same_process_as_parent_span, as: 'sameProcessAsParentSpan' + property :span_id, as: 'spanId' + property :span_kind, as: 'spanKind' + property :start_time, as: 'startTime' + property :status, as: 'status', class: Google::Apis::PrivatecaV1beta1::Status, decorator: Google::Apis::PrivatecaV1beta1::Status::Representation + + end + end + + class GoogleApiServicecontrolV1TruncatableString + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :truncated_byte_count, as: 'truncatedByteCount' + property :value, as: 'value' + end + end + class IssuanceModes # @private class Representation < Google::Apis::Core::JsonRepresentation @@ -755,6 +1128,15 @@ module Google end end + class Money + # @private + class Representation < Google::Apis::Core::JsonRepresentation + property :currency_code, as: 'currencyCode' + property :nanos, as: 'nanos' + property :units, :numeric_string => true, as: 'units' + end + end + class ObjectIdProp # @private class Representation < Google::Apis::Core::JsonRepresentation @@ -879,6 +1261,7 @@ module Google class ScheduleDeleteCertificateAuthorityRequest # @private class Representation < Google::Apis::Core::JsonRepresentation + property :ignore_active_certificates, as: 'ignoreActiveCertificates' property :request_id, as: 'requestId' end end diff --git a/generated/google-apis-privateca_v1beta1/synth.metadata b/generated/google-apis-privateca_v1beta1/synth.metadata index 0232f5169..038bf1345 100644 --- a/generated/google-apis-privateca_v1beta1/synth.metadata +++ b/generated/google-apis-privateca_v1beta1/synth.metadata @@ -4,7 +4,7 @@ "git": { "name": ".", "remote": "https://github.com/googleapis/google-api-ruby-client.git", - "sha": "6090200f4cdab3152a40bef1456aafefadb3b667" + "sha": "754e6f59db65ed8e3b69965bdd5f4c024f4bc296" } } ]