google-apis-privateca_v1beta1 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d11c86afb2db9b141d766d3a8373a48c613642ddf13877754864e3cf3acbe2cc
-  data.tar.gz: 39df15ce6c01fd4e77ef634d4c62d9bca9f563fe5fdd8723a1fb260bd867e16e
+  metadata.gz: 0d6ef838c621410a07b73bd9f19e163f13cf61dbee6fff9ae31746959d764a73
+  data.tar.gz: e9b8a41edf32cceee6b5af2a5cea591cdb7058db22ee8744a32316d61dcbb8cd
 SHA512:
-  metadata.gz: 57acd6f195a9970f61fccb895469d08b24b31e1df83c51104cd87be5d6099078bf5ef93e7df589d89adea668841c3df6c8fd9eb00fe5c18a02122c4787029fa8
-  data.tar.gz: 13b63ad7b599e1f92f569d33baf3d48a2f3efcb459ce32003abc2537a1c93fb9c7fcbf13fa8ca06714be56755f53fd0cdd5db9a68890165d36030331f880538f
+  metadata.gz: 43c3fc6408f6a299ec95e0fd6de70f78f4a5f103f7747d0c5c18263a4dfefc18d53aaf4f6497410572aca1088c59d6570a8297cfc495b78d2d8e8bf93ac76603
+  data.tar.gz: a7091c33219363975c4e149f0733bea49d84435a94d2a4cf119e5ef3053c3f093ca0b106a40395ad5e0551b8e0e7be955663b1978d85424c4a52cd3061c64002

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Release history for google-apis-privateca_v1beta1
 
+### v0.2.0 (2021-01-21)
+
+* Regenerated from discovery document revision 20210119
+* Regenerated using generator version 0.1.2
+
 ### v0.1.0 (2021-01-07)
 
 * Regenerated using generator version 0.1.1

data/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<Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ReportRequest>]
+        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<Hash<String,Object>>]
+        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,1014 @@ 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<String,Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1AttributeValue>]
+        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<Fixnum>]
+        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<Google::Apis::PrivatecaV1beta1::Exemplar>]
+        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<Float>]
+        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<String,String>]
+        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<String,Object>]
+        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<String,Object>]
+        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<String,String>]
+        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<Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1MetricValue>]
+        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<Hash<String,Object>>]
+        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<String,String>]
+        attr_accessor :labels
+      
+        # Represents information to be logged.
+        # Corresponds to the JSON property `logEntries`
+        # @return [Array<Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1LogEntry>]
+        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<Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1MetricValueSet>]
+        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<Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1ResourceInfo>]
+        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<Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1TraceSpan>]
+        attr_accessor :trace_spans
+      
+        # Private Preview. This feature is only available for approved services. 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<String,String>]
+        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<Google::Apis::PrivatecaV1beta1::GoogleApiServicecontrolV1Operation>]
+        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 +2575,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 +3131,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 +3158,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