google-api-client 0.32.1 → 0.40.0

data/generated/google/apis/monitoring_v1/classes.rb

@@ -0,0 +1,1231 @@
+# Copyright 2015 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'date'
+require 'google/apis/core/base_service'
+require 'google/apis/core/json_representation'
+require 'google/apis/core/hashable'
+require 'google/apis/errors'
+
+module Google
+  module Apis
+    module MonitoringV1
+      
+      # Describes how to combine multiple time series to provide a different view of
+      # the data. Aggregation of time series is done in two steps. First, each time
+      # series in the set is aligned to the same time interval boundaries, then the
+      # set of time series is optionally reduced in number.Alignment consists of
+      # applying the per_series_aligner operation to each time series after its data
+      # has been divided into regular alignment_period time intervals. This process
+      # takes all of the data points in an alignment period, applies a mathematical
+      # transformation such as averaging, minimum, maximum, delta, etc., and converts
+      # them into a single data point per period.Reduction is when the aligned and
+      # transformed time series can optionally be combined, reducing the number of
+      # time series through similar mathematical transformations. Reduction involves
+      # applying a cross_series_reducer to all the time series, optionally sorting the
+      # time series into subsets with group_by_fields, and applying the reducer to
+      # each subset.The raw time series data can contain a huge amount of information
+      # from multiple sources. Alignment and reduction transforms this mass of data
+      # into a more manageable and representative collection of data, for example "the
+      # 95% latency across the average of all tasks in a cluster". This representative
+      # data can be more easily graphed and comprehended, and the individual time
+      # series data is still available for later drilldown. For more details, see
+      # Filtering and aggregation (https://cloud.google.com/monitoring/api/v3/
+      # aggregation).
+      class Aggregation
+        include Google::Apis::Core::Hashable
+      
+        # The alignment_period specifies a time interval, in seconds, that is used to
+        # divide the data in all the time series into consistent blocks of time. This
+        # will be done before the per-series aligner can be applied to the data.The
+        # value must be at least 60 seconds. If a per-series aligner other than
+        # ALIGN_NONE is specified, this field is required or an error is returned. If no
+        # per-series aligner is specified, or the aligner ALIGN_NONE is specified, then
+        # this field is ignored.
+        # Corresponds to the JSON property `alignmentPeriod`
+        # @return [String]
+        attr_accessor :alignment_period
+      
+        # The reduction operation to be used to combine time series into a single time
+        # series, where the value of each data point in the resulting series is a
+        # function of all the already aligned values in the input time series.Not all
+        # reducer operations can be applied to all time series. The valid choices depend
+        # on the metric_kind and the value_type of the original time series. Reduction
+        # can yield a time series with a different metric_kind or value_type than the
+        # input time series.Time series data must first be aligned (see
+        # per_series_aligner) in order to perform cross-time series reduction. If
+        # cross_series_reducer is specified, then per_series_aligner must be specified,
+        # and must not be ALIGN_NONE. An alignment_period must also be specified;
+        # otherwise, an error is returned.
+        # Corresponds to the JSON property `crossSeriesReducer`
+        # @return [String]
+        attr_accessor :cross_series_reducer
+      
+        # The set of fields to preserve when cross_series_reducer is specified. The
+        # group_by_fields determine how the time series are partitioned into subsets
+        # prior to applying the aggregation operation. Each subset contains time series
+        # that have the same value for each of the grouping fields. Each individual time
+        # series is a member of exactly one subset. The cross_series_reducer is applied
+        # to each subset of time series. It is not possible to reduce across different
+        # resource types, so this field implicitly contains resource.type. Fields not
+        # specified in group_by_fields are aggregated away. If group_by_fields is not
+        # specified and all the time series have the same resource type, then the time
+        # series are aggregated into a single output time series. If
+        # cross_series_reducer is not defined, this field is ignored.
+        # Corresponds to the JSON property `groupByFields`
+        # @return [Array<String>]
+        attr_accessor :group_by_fields
+      
+        # An Aligner describes how to bring the data points in a single time series into
+        # temporal alignment. Except for ALIGN_NONE, all alignments cause all the data
+        # points in an alignment_period to be mathematically grouped together, resulting
+        # in a single data point for each alignment_period with end timestamp at the end
+        # of the period.Not all alignment operations may be applied to all time series.
+        # The valid choices depend on the metric_kind and value_type of the original
+        # time series. Alignment can change the metric_kind or the value_type of the
+        # time series.Time series data must be aligned in order to perform cross-time
+        # series reduction. If cross_series_reducer is specified, then
+        # per_series_aligner must be specified and not equal to ALIGN_NONE and
+        # alignment_period must be specified; otherwise, an error is returned.
+        # Corresponds to the JSON property `perSeriesAligner`
+        # @return [String]
+        attr_accessor :per_series_aligner
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @alignment_period = args[:alignment_period] if args.key?(:alignment_period)
+          @cross_series_reducer = args[:cross_series_reducer] if args.key?(:cross_series_reducer)
+          @group_by_fields = args[:group_by_fields] if args.key?(:group_by_fields)
+          @per_series_aligner = args[:per_series_aligner] if args.key?(:per_series_aligner)
+        end
+      end
+      
+      # A chart axis.
+      class Axis
+        include Google::Apis::Core::Hashable
+      
+        # The label of the axis.
+        # Corresponds to the JSON property `label`
+        # @return [String]
+        attr_accessor :label
+      
+        # The axis scale. By default, a linear scale is used.
+        # Corresponds to the JSON property `scale`
+        # @return [String]
+        attr_accessor :scale
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @label = args[:label] if args.key?(:label)
+          @scale = args[:scale] if args.key?(:scale)
+        end
+      end
+      
+      # Options to control visual rendering of a chart.
+      class ChartOptions
+        include Google::Apis::Core::Hashable
+      
+        # The chart mode.
+        # Corresponds to the JSON property `mode`
+        # @return [String]
+        attr_accessor :mode
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @mode = args[:mode] if args.key?(:mode)
+        end
+      end
+      
+      # Defines the layout properties and content for a column.
+      class Column
+        include Google::Apis::Core::Hashable
+      
+        # The relative weight of this column. The column weight is used to adjust the
+        # width of columns on the screen (relative to peers). Greater the weight,
+        # greater the width of the column on the screen. If omitted, a value of 1 is
+        # used while rendering.
+        # Corresponds to the JSON property `weight`
+        # @return [Fixnum]
+        attr_accessor :weight
+      
+        # The display widgets arranged vertically in this column.
+        # Corresponds to the JSON property `widgets`
+        # @return [Array<Google::Apis::MonitoringV1::Widget>]
+        attr_accessor :widgets
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @weight = args[:weight] if args.key?(:weight)
+          @widgets = args[:widgets] if args.key?(:widgets)
+        end
+      end
+      
+      # A simplified layout that divides the available space into vertical columns and
+      # arranges a set of widgets vertically in each column.
+      class ColumnLayout
+        include Google::Apis::Core::Hashable
+      
+        # The columns of content to display.
+        # Corresponds to the JSON property `columns`
+        # @return [Array<Google::Apis::MonitoringV1::Column>]
+        attr_accessor :columns
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @columns = args[:columns] if args.key?(:columns)
+        end
+      end
+      
+      # A Google Stackdriver dashboard. Dashboards define the content and layout of
+      # pages in the Stackdriver web application.
+      class Dashboard
+        include Google::Apis::Core::Hashable
+      
+        # A simplified layout that divides the available space into vertical columns and
+        # arranges a set of widgets vertically in each column.
+        # Corresponds to the JSON property `columnLayout`
+        # @return [Google::Apis::MonitoringV1::ColumnLayout]
+        attr_accessor :column_layout
+      
+        # Required. The mutable, human-readable name.
+        # Corresponds to the JSON property `displayName`
+        # @return [String]
+        attr_accessor :display_name
+      
+        # etag is used for optimistic concurrency control as a way to help prevent
+        # simultaneous updates of a policy from overwriting each other. An etag is
+        # returned in the response to GetDashboard, and users are expected to put that
+        # etag in the request to UpdateDashboard to ensure that their change will be
+        # applied to the same version of the Dashboard configuration. The field should
+        # not be passed during dashboard creation.
+        # Corresponds to the JSON property `etag`
+        # @return [String]
+        attr_accessor :etag
+      
+        # A basic layout divides the available space into vertical columns of equal
+        # width and arranges a list of widgets using a row-first strategy.
+        # Corresponds to the JSON property `gridLayout`
+        # @return [Google::Apis::MonitoringV1::GridLayout]
+        attr_accessor :grid_layout
+      
+        # Immutable. The resource name of the dashboard.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # A simplified layout that divides the available space into rows and arranges a
+        # set of widgets horizontally in each row.
+        # Corresponds to the JSON property `rowLayout`
+        # @return [Google::Apis::MonitoringV1::RowLayout]
+        attr_accessor :row_layout
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @column_layout = args[:column_layout] if args.key?(:column_layout)
+          @display_name = args[:display_name] if args.key?(:display_name)
+          @etag = args[:etag] if args.key?(:etag)
+          @grid_layout = args[:grid_layout] if args.key?(:grid_layout)
+          @name = args[:name] if args.key?(:name)
+          @row_layout = args[:row_layout] if args.key?(:row_layout)
+        end
+      end
+      
+      # Groups a time series query definition with charting options.
+      class DataSet
+        include Google::Apis::Core::Hashable
+      
+        # A template string for naming TimeSeries in the resulting data set. This should
+        # be a string with interpolations of the form $`label_name`, which will resolve
+        # to the label's value.
+        # Corresponds to the JSON property `legendTemplate`
+        # @return [String]
+        attr_accessor :legend_template
+      
+        # Optional. The lower bound on data point frequency for this data set,
+        # implemented by specifying the minimum alignment period to use in a time series
+        # query For example, if the data is published once every 10 minutes, the
+        # min_alignment_period should be at least 10 minutes. It would not make sense to
+        # fetch and align data at one minute intervals.
+        # Corresponds to the JSON property `minAlignmentPeriod`
+        # @return [String]
+        attr_accessor :min_alignment_period
+      
+        # How this data should be plotted on the chart.
+        # Corresponds to the JSON property `plotType`
+        # @return [String]
+        attr_accessor :plot_type
+      
+        # TimeSeriesQuery collects the set of supported methods for querying time series
+        # data from the Stackdriver metrics API.
+        # Corresponds to the JSON property `timeSeriesQuery`
+        # @return [Google::Apis::MonitoringV1::TimeSeriesQuery]
+        attr_accessor :time_series_query
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @legend_template = args[:legend_template] if args.key?(:legend_template)
+          @min_alignment_period = args[:min_alignment_period] if args.key?(:min_alignment_period)
+          @plot_type = args[:plot_type] if args.key?(:plot_type)
+          @time_series_query = args[:time_series_query] if args.key?(:time_series_query)
+        end
+      end
+      
+      # A set of (label, value) pairs which were dropped during aggregation, attached
+      # to google.api.Distribution.Exemplars in google.api.Distribution values during
+      # aggregation.These values are used in combination with the label values that
+      # remain on the aggregated Distribution timeseries to construct the full label
+      # set for the exemplar values. The resulting full label set may be used to
+      # identify the specific task/job/instance (for example) which may be
+      # contributing to a long-tail, while allowing the storage savings of only
+      # storing aggregated distribution values for a large group.Note that there are
+      # no guarantees on ordering of the labels from exemplar-to-exemplar and from
+      # distribution-to-distribution in the same stream, and there may be duplicates.
+      # It is up to clients to resolve any ambiguities.
+      class DroppedLabels
+        include Google::Apis::Core::Hashable
+      
+        # Map from label to its value, for all labels dropped in any aggregation.
+        # Corresponds to the JSON property `label`
+        # @return [Hash<String,String>]
+        attr_accessor :label
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @label = args[:label] if args.key?(:label)
+        end
+      end
+      
+      # A generic empty message that you can re-use to avoid defining duplicated empty
+      # messages in your APIs. A typical example is to use it as the request or the
+      # response type of an API method. For instance:
+      # service Foo `
+      # rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+      # `
+      # The JSON representation for Empty is empty JSON object ``.
+      class Empty
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # A single field of a message type.
+      class Field
+        include Google::Apis::Core::Hashable
+      
+        # The field cardinality.
+        # Corresponds to the JSON property `cardinality`
+        # @return [String]
+        attr_accessor :cardinality
+      
+        # The string value of the default value of this field. Proto2 syntax only.
+        # Corresponds to the JSON property `defaultValue`
+        # @return [String]
+        attr_accessor :default_value
+      
+        # The field JSON name.
+        # Corresponds to the JSON property `jsonName`
+        # @return [String]
+        attr_accessor :json_name
+      
+        # The field type.
+        # Corresponds to the JSON property `kind`
+        # @return [String]
+        attr_accessor :kind
+      
+        # The field name.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # The field number.
+        # Corresponds to the JSON property `number`
+        # @return [Fixnum]
+        attr_accessor :number
+      
+        # The index of the field type in Type.oneofs, for message or enumeration types.
+        # The first type has index 1; zero means the type is not in the list.
+        # Corresponds to the JSON property `oneofIndex`
+        # @return [Fixnum]
+        attr_accessor :oneof_index
+      
+        # The protocol buffer options.
+        # Corresponds to the JSON property `options`
+        # @return [Array<Google::Apis::MonitoringV1::Option>]
+        attr_accessor :options
+      
+        # Whether to use alternative packed wire representation.
+        # Corresponds to the JSON property `packed`
+        # @return [Boolean]
+        attr_accessor :packed
+        alias_method :packed?, :packed
+      
+        # The field type URL, without the scheme, for message or enumeration types.
+        # Example: "type.googleapis.com/google.protobuf.Timestamp".
+        # Corresponds to the JSON property `typeUrl`
+        # @return [String]
+        attr_accessor :type_url
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @cardinality = args[:cardinality] if args.key?(:cardinality)
+          @default_value = args[:default_value] if args.key?(:default_value)
+          @json_name = args[:json_name] if args.key?(:json_name)
+          @kind = args[:kind] if args.key?(:kind)
+          @name = args[:name] if args.key?(:name)
+          @number = args[:number] if args.key?(:number)
+          @oneof_index = args[:oneof_index] if args.key?(:oneof_index)
+          @options = args[:options] if args.key?(:options)
+          @packed = args[:packed] if args.key?(:packed)
+          @type_url = args[:type_url] if args.key?(:type_url)
+        end
+      end
+      
+      # A gauge chart shows where the current value sits within a pre-defined range.
+      # The upper and lower bounds should define the possible range of values for the
+      # scorecard's query (inclusive).
+      class GaugeView
+        include Google::Apis::Core::Hashable
+      
+        # The lower bound for this gauge chart. The value of the chart should always be
+        # greater than or equal to this.
+        # Corresponds to the JSON property `lowerBound`
+        # @return [Float]
+        attr_accessor :lower_bound
+      
+        # The upper bound for this gauge chart. The value of the chart should always be
+        # less than or equal to this.
+        # Corresponds to the JSON property `upperBound`
+        # @return [Float]
+        attr_accessor :upper_bound
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @lower_bound = args[:lower_bound] if args.key?(:lower_bound)
+          @upper_bound = args[:upper_bound] if args.key?(:upper_bound)
+        end
+      end
+      
+      # A basic layout divides the available space into vertical columns of equal
+      # width and arranges a list of widgets using a row-first strategy.
+      class GridLayout
+        include Google::Apis::Core::Hashable
+      
+        # The number of columns into which the view's width is divided. If omitted or
+        # set to zero, a system default will be used while rendering.
+        # Corresponds to the JSON property `columns`
+        # @return [Fixnum]
+        attr_accessor :columns
+      
+        # The informational elements that are arranged into the columns row-first.
+        # Corresponds to the JSON property `widgets`
+        # @return [Array<Google::Apis::MonitoringV1::Widget>]
+        attr_accessor :widgets
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @columns = args[:columns] if args.key?(:columns)
+          @widgets = args[:widgets] if args.key?(:widgets)
+        end
+      end
+      
+      # The ListDashboards request.
+      class ListDashboardsResponse
+        include Google::Apis::Core::Hashable
+      
+        # The list of requested dashboards.
+        # Corresponds to the JSON property `dashboards`
+        # @return [Array<Google::Apis::MonitoringV1::Dashboard>]
+        attr_accessor :dashboards
+      
+        # If there are more results than have been returned, then this field is set to a
+        # non-empty value. To see the additional results, use that value as page_token
+        # in the next call to this method.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @dashboards = args[:dashboards] if args.key?(:dashboards)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+        end
+      end
+      
+      # A protocol buffer option, which can be attached to a message, field,
+      # enumeration, etc.
+      class Option
+        include Google::Apis::Core::Hashable
+      
+        # The option's name. For protobuf built-in options (options defined in
+        # descriptor.proto), this is the short name. For example, "map_entry". For
+        # custom options, it should be the fully-qualified name. For example, "google.
+        # api.http".
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # The option's value packed in an Any message. If the value is a primitive, the
+        # corresponding wrapper type defined in google/protobuf/wrappers.proto should be
+        # used. If the value is an enum, it should be stored as an int32 value using the
+        # google.protobuf.Int32Value type.
+        # Corresponds to the JSON property `value`
+        # @return [Hash<String,Object>]
+        attr_accessor :value
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @name = args[:name] if args.key?(:name)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+      
+      # Describes a ranking-based time series filter. Each input time series is ranked
+      # with an aligner. The filter will allow up to num_time_series time series to
+      # pass through it, selecting them based on the relative ranking.For example, if
+      # ranking_method is METHOD_MEAN,direction is BOTTOM, and num_time_series is 3,
+      # then the 3 times series with the lowest mean values will pass through the
+      # filter.
+      class PickTimeSeriesFilter
+        include Google::Apis::Core::Hashable
+      
+        # How to use the ranking to select time series that pass through the filter.
+        # Corresponds to the JSON property `direction`
+        # @return [String]
+        attr_accessor :direction
+      
+        # How many time series to allow to pass through the filter.
+        # Corresponds to the JSON property `numTimeSeries`
+        # @return [Fixnum]
+        attr_accessor :num_time_series
+      
+        # ranking_method is applied to each time series independently to produce the
+        # value which will be used to compare the time series to other time series.
+        # Corresponds to the JSON property `rankingMethod`
+        # @return [String]
+        attr_accessor :ranking_method
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @direction = args[:direction] if args.key?(:direction)
+          @num_time_series = args[:num_time_series] if args.key?(:num_time_series)
+          @ranking_method = args[:ranking_method] if args.key?(:ranking_method)
+        end
+      end
+      
+      # Describes a query to build the numerator or denominator of a
+      # TimeSeriesFilterRatio.
+      class RatioPart
+        include Google::Apis::Core::Hashable
+      
+        # Describes how to combine multiple time series to provide a different view of
+        # the data. Aggregation of time series is done in two steps. First, each time
+        # series in the set is aligned to the same time interval boundaries, then the
+        # set of time series is optionally reduced in number.Alignment consists of
+        # applying the per_series_aligner operation to each time series after its data
+        # has been divided into regular alignment_period time intervals. This process
+        # takes all of the data points in an alignment period, applies a mathematical
+        # transformation such as averaging, minimum, maximum, delta, etc., and converts
+        # them into a single data point per period.Reduction is when the aligned and
+        # transformed time series can optionally be combined, reducing the number of
+        # time series through similar mathematical transformations. Reduction involves
+        # applying a cross_series_reducer to all the time series, optionally sorting the
+        # time series into subsets with group_by_fields, and applying the reducer to
+        # each subset.The raw time series data can contain a huge amount of information
+        # from multiple sources. Alignment and reduction transforms this mass of data
+        # into a more manageable and representative collection of data, for example "the
+        # 95% latency across the average of all tasks in a cluster". This representative
+        # data can be more easily graphed and comprehended, and the individual time
+        # series data is still available for later drilldown. For more details, see
+        # Filtering and aggregation (https://cloud.google.com/monitoring/api/v3/
+        # aggregation).
+        # Corresponds to the JSON property `aggregation`
+        # @return [Google::Apis::MonitoringV1::Aggregation]
+        attr_accessor :aggregation
+      
+        # Required. The monitoring filter (https://cloud.google.com/monitoring/api/v3/
+        # filters) that identifies the metric types, resources, and projects to query.
+        # Corresponds to the JSON property `filter`
+        # @return [String]
+        attr_accessor :filter
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @aggregation = args[:aggregation] if args.key?(:aggregation)
+          @filter = args[:filter] if args.key?(:filter)
+        end
+      end
+      
+      # Defines the layout properties and content for a row.
+      class Row
+        include Google::Apis::Core::Hashable
+      
+        # The relative weight of this row. The row weight is used to adjust the height
+        # of rows on the screen (relative to peers). Greater the weight, greater the
+        # height of the row on the screen. If omitted, a value of 1 is used while
+        # rendering.
+        # Corresponds to the JSON property `weight`
+        # @return [Fixnum]
+        attr_accessor :weight
+      
+        # The display widgets arranged horizontally in this row.
+        # Corresponds to the JSON property `widgets`
+        # @return [Array<Google::Apis::MonitoringV1::Widget>]
+        attr_accessor :widgets
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @weight = args[:weight] if args.key?(:weight)
+          @widgets = args[:widgets] if args.key?(:widgets)
+        end
+      end
+      
+      # A simplified layout that divides the available space into rows and arranges a
+      # set of widgets horizontally in each row.
+      class RowLayout
+        include Google::Apis::Core::Hashable
+      
+        # The rows of content to display.
+        # Corresponds to the JSON property `rows`
+        # @return [Array<Google::Apis::MonitoringV1::Row>]
+        attr_accessor :rows
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @rows = args[:rows] if args.key?(:rows)
+        end
+      end
+      
+      # A widget showing the latest value of a metric, and how this value relates to
+      # one or more thresholds.
+      class Scorecard
+        include Google::Apis::Core::Hashable
+      
+        # A gauge chart shows where the current value sits within a pre-defined range.
+        # The upper and lower bounds should define the possible range of values for the
+        # scorecard's query (inclusive).
+        # Corresponds to the JSON property `gaugeView`
+        # @return [Google::Apis::MonitoringV1::GaugeView]
+        attr_accessor :gauge_view
+      
+        # A sparkChart is a small chart suitable for inclusion in a table-cell or inline
+        # in text. This message contains the configuration for a sparkChart to show up
+        # on a Scorecard, showing recent trends of the scorecard's timeseries.
+        # Corresponds to the JSON property `sparkChartView`
+        # @return [Google::Apis::MonitoringV1::SparkChartView]
+        attr_accessor :spark_chart_view
+      
+        # The thresholds used to determine the state of the scorecard given the time
+        # series' current value. For an actual value x, the scorecard is in a danger
+        # state if x is less than or equal to a danger threshold that triggers below, or
+        # greater than or equal to a danger threshold that triggers above. Similarly, if
+        # x is above/below a warning threshold that triggers above/below, then the
+        # scorecard is in a warning state - unless x also puts it in a danger state. (
+        # Danger trumps warning.)As an example, consider a scorecard with the following
+        # four thresholds: `  value: 90,  category: 'DANGER',  trigger: 'ABOVE', `, `
+        # value: 70,  category: 'WARNING',  trigger: 'ABOVE', `, `  value: 10,  category:
+        # 'DANGER',  trigger: 'BELOW', `, `  value: 20,  category: 'WARNING',  trigger:
+        # 'BELOW', `Then: values less than or equal to 10 would put the scorecard in a
+        # DANGER state, values greater than 10 but less than or equal to 20 a WARNING
+        # state, values strictly between 20 and 70 an OK state, values greater than or
+        # equal to 70 but less than 90 a WARNING state, and values greater than or equal
+        # to 90 a DANGER state.
+        # Corresponds to the JSON property `thresholds`
+        # @return [Array<Google::Apis::MonitoringV1::Threshold>]
+        attr_accessor :thresholds
+      
+        # TimeSeriesQuery collects the set of supported methods for querying time series
+        # data from the Stackdriver metrics API.
+        # Corresponds to the JSON property `timeSeriesQuery`
+        # @return [Google::Apis::MonitoringV1::TimeSeriesQuery]
+        attr_accessor :time_series_query
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @gauge_view = args[:gauge_view] if args.key?(:gauge_view)
+          @spark_chart_view = args[:spark_chart_view] if args.key?(:spark_chart_view)
+          @thresholds = args[:thresholds] if args.key?(:thresholds)
+          @time_series_query = args[:time_series_query] if args.key?(:time_series_query)
+        end
+      end
+      
+      # SourceContext represents information about the source of a protobuf element,
+      # like the file in which it is defined.
+      class SourceContext
+        include Google::Apis::Core::Hashable
+      
+        # The path-qualified name of the .proto file that contained the associated
+        # protobuf element. For example: "google/protobuf/source_context.proto".
+        # Corresponds to the JSON property `fileName`
+        # @return [String]
+        attr_accessor :file_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @file_name = args[:file_name] if args.key?(:file_name)
+        end
+      end
+      
+      # The context of a span, attached to Exemplars in Distribution values during
+      # aggregation.It contains the name of a span with format:
+      # projects/[PROJECT_ID_OR_NUMBER]/traces/[TRACE_ID]/spans/[SPAN_ID]
+      class SpanContext
+        include Google::Apis::Core::Hashable
+      
+        # The resource name of the span. The format is:
+        # projects/[PROJECT_ID_OR_NUMBER]/traces/[TRACE_ID]/spans/[SPAN_ID]
+        # [TRACE_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 `spanName`
+        # @return [String]
+        attr_accessor :span_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @span_name = args[:span_name] if args.key?(:span_name)
+        end
+      end
+      
+      # A sparkChart is a small chart suitable for inclusion in a table-cell or inline
+      # in text. This message contains the configuration for a sparkChart to show up
+      # on a Scorecard, showing recent trends of the scorecard's timeseries.
+      class SparkChartView
+        include Google::Apis::Core::Hashable
+      
+        # The lower bound on data point frequency in the chart implemented by specifying
+        # the minimum alignment period to use in a time series query. For example, if
+        # the data is published once every 10 minutes it would not make sense to fetch
+        # and align data at one minute intervals. This field is optional and exists only
+        # as a hint.
+        # Corresponds to the JSON property `minAlignmentPeriod`
+        # @return [String]
+        attr_accessor :min_alignment_period
+      
+        # Required. The type of sparkchart to show in this chartView.
+        # Corresponds to the JSON property `sparkChartType`
+        # @return [String]
+        attr_accessor :spark_chart_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @min_alignment_period = args[:min_alignment_period] if args.key?(:min_alignment_period)
+          @spark_chart_type = args[:spark_chart_type] if args.key?(:spark_chart_type)
+        end
+      end
+      
+      # A widget that displays textual content.
+      class Text
+        include Google::Apis::Core::Hashable
+      
+        # The text content to be displayed.
+        # Corresponds to the JSON property `content`
+        # @return [String]
+        attr_accessor :content
+      
+        # How the text content is formatted.
+        # Corresponds to the JSON property `format`
+        # @return [String]
+        attr_accessor :format
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @content = args[:content] if args.key?(:content)
+          @format = args[:format] if args.key?(:format)
+        end
+      end
+      
+      # Defines a threshold for categorizing time series values.
+      class Threshold
+        include Google::Apis::Core::Hashable
+      
+        # The state color for this threshold. Color is not allowed in a XyChart.
+        # Corresponds to the JSON property `color`
+        # @return [String]
+        attr_accessor :color
+      
+        # The direction for the current threshold. Direction is not allowed in a XyChart.
+        # Corresponds to the JSON property `direction`
+        # @return [String]
+        attr_accessor :direction
+      
+        # A label for the threshold.
+        # Corresponds to the JSON property `label`
+        # @return [String]
+        attr_accessor :label
+      
+        # The value of the threshold. The value should be defined in the native scale of
+        # the metric.
+        # 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)
+          @color = args[:color] if args.key?(:color)
+          @direction = args[:direction] if args.key?(:direction)
+          @label = args[:label] if args.key?(:label)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+      
+      # A filter that defines a subset of time series data that is displayed in a
+      # widget. Time series data is fetched using the ListTimeSeries (https://cloud.
+      # google.com/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list) method.
+      class TimeSeriesFilter
+        include Google::Apis::Core::Hashable
+      
+        # Describes how to combine multiple time series to provide a different view of
+        # the data. Aggregation of time series is done in two steps. First, each time
+        # series in the set is aligned to the same time interval boundaries, then the
+        # set of time series is optionally reduced in number.Alignment consists of
+        # applying the per_series_aligner operation to each time series after its data
+        # has been divided into regular alignment_period time intervals. This process
+        # takes all of the data points in an alignment period, applies a mathematical
+        # transformation such as averaging, minimum, maximum, delta, etc., and converts
+        # them into a single data point per period.Reduction is when the aligned and
+        # transformed time series can optionally be combined, reducing the number of
+        # time series through similar mathematical transformations. Reduction involves
+        # applying a cross_series_reducer to all the time series, optionally sorting the
+        # time series into subsets with group_by_fields, and applying the reducer to
+        # each subset.The raw time series data can contain a huge amount of information
+        # from multiple sources. Alignment and reduction transforms this mass of data
+        # into a more manageable and representative collection of data, for example "the
+        # 95% latency across the average of all tasks in a cluster". This representative
+        # data can be more easily graphed and comprehended, and the individual time
+        # series data is still available for later drilldown. For more details, see
+        # Filtering and aggregation (https://cloud.google.com/monitoring/api/v3/
+        # aggregation).
+        # Corresponds to the JSON property `aggregation`
+        # @return [Google::Apis::MonitoringV1::Aggregation]
+        attr_accessor :aggregation
+      
+        # Required. The monitoring filter (https://cloud.google.com/monitoring/api/v3/
+        # filters) that identifies the metric types, resources, and projects to query.
+        # Corresponds to the JSON property `filter`
+        # @return [String]
+        attr_accessor :filter
+      
+        # Describes a ranking-based time series filter. Each input time series is ranked
+        # with an aligner. The filter will allow up to num_time_series time series to
+        # pass through it, selecting them based on the relative ranking.For example, if
+        # ranking_method is METHOD_MEAN,direction is BOTTOM, and num_time_series is 3,
+        # then the 3 times series with the lowest mean values will pass through the
+        # filter.
+        # Corresponds to the JSON property `pickTimeSeriesFilter`
+        # @return [Google::Apis::MonitoringV1::PickTimeSeriesFilter]
+        attr_accessor :pick_time_series_filter
+      
+        # Describes how to combine multiple time series to provide a different view of
+        # the data. Aggregation of time series is done in two steps. First, each time
+        # series in the set is aligned to the same time interval boundaries, then the
+        # set of time series is optionally reduced in number.Alignment consists of
+        # applying the per_series_aligner operation to each time series after its data
+        # has been divided into regular alignment_period time intervals. This process
+        # takes all of the data points in an alignment period, applies a mathematical
+        # transformation such as averaging, minimum, maximum, delta, etc., and converts
+        # them into a single data point per period.Reduction is when the aligned and
+        # transformed time series can optionally be combined, reducing the number of
+        # time series through similar mathematical transformations. Reduction involves
+        # applying a cross_series_reducer to all the time series, optionally sorting the
+        # time series into subsets with group_by_fields, and applying the reducer to
+        # each subset.The raw time series data can contain a huge amount of information
+        # from multiple sources. Alignment and reduction transforms this mass of data
+        # into a more manageable and representative collection of data, for example "the
+        # 95% latency across the average of all tasks in a cluster". This representative
+        # data can be more easily graphed and comprehended, and the individual time
+        # series data is still available for later drilldown. For more details, see
+        # Filtering and aggregation (https://cloud.google.com/monitoring/api/v3/
+        # aggregation).
+        # Corresponds to the JSON property `secondaryAggregation`
+        # @return [Google::Apis::MonitoringV1::Aggregation]
+        attr_accessor :secondary_aggregation
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @aggregation = args[:aggregation] if args.key?(:aggregation)
+          @filter = args[:filter] if args.key?(:filter)
+          @pick_time_series_filter = args[:pick_time_series_filter] if args.key?(:pick_time_series_filter)
+          @secondary_aggregation = args[:secondary_aggregation] if args.key?(:secondary_aggregation)
+        end
+      end
+      
+      # A pair of time series filters that define a ratio computation. The output time
+      # series is the pair-wise division of each aligned element from the numerator
+      # and denominator time series.
+      class TimeSeriesFilterRatio
+        include Google::Apis::Core::Hashable
+      
+        # Describes a query to build the numerator or denominator of a
+        # TimeSeriesFilterRatio.
+        # Corresponds to the JSON property `denominator`
+        # @return [Google::Apis::MonitoringV1::RatioPart]
+        attr_accessor :denominator
+      
+        # Describes a query to build the numerator or denominator of a
+        # TimeSeriesFilterRatio.
+        # Corresponds to the JSON property `numerator`
+        # @return [Google::Apis::MonitoringV1::RatioPart]
+        attr_accessor :numerator
+      
+        # Describes a ranking-based time series filter. Each input time series is ranked
+        # with an aligner. The filter will allow up to num_time_series time series to
+        # pass through it, selecting them based on the relative ranking.For example, if
+        # ranking_method is METHOD_MEAN,direction is BOTTOM, and num_time_series is 3,
+        # then the 3 times series with the lowest mean values will pass through the
+        # filter.
+        # Corresponds to the JSON property `pickTimeSeriesFilter`
+        # @return [Google::Apis::MonitoringV1::PickTimeSeriesFilter]
+        attr_accessor :pick_time_series_filter
+      
+        # Describes how to combine multiple time series to provide a different view of
+        # the data. Aggregation of time series is done in two steps. First, each time
+        # series in the set is aligned to the same time interval boundaries, then the
+        # set of time series is optionally reduced in number.Alignment consists of
+        # applying the per_series_aligner operation to each time series after its data
+        # has been divided into regular alignment_period time intervals. This process
+        # takes all of the data points in an alignment period, applies a mathematical
+        # transformation such as averaging, minimum, maximum, delta, etc., and converts
+        # them into a single data point per period.Reduction is when the aligned and
+        # transformed time series can optionally be combined, reducing the number of
+        # time series through similar mathematical transformations. Reduction involves
+        # applying a cross_series_reducer to all the time series, optionally sorting the
+        # time series into subsets with group_by_fields, and applying the reducer to
+        # each subset.The raw time series data can contain a huge amount of information
+        # from multiple sources. Alignment and reduction transforms this mass of data
+        # into a more manageable and representative collection of data, for example "the
+        # 95% latency across the average of all tasks in a cluster". This representative
+        # data can be more easily graphed and comprehended, and the individual time
+        # series data is still available for later drilldown. For more details, see
+        # Filtering and aggregation (https://cloud.google.com/monitoring/api/v3/
+        # aggregation).
+        # Corresponds to the JSON property `secondaryAggregation`
+        # @return [Google::Apis::MonitoringV1::Aggregation]
+        attr_accessor :secondary_aggregation
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @denominator = args[:denominator] if args.key?(:denominator)
+          @numerator = args[:numerator] if args.key?(:numerator)
+          @pick_time_series_filter = args[:pick_time_series_filter] if args.key?(:pick_time_series_filter)
+          @secondary_aggregation = args[:secondary_aggregation] if args.key?(:secondary_aggregation)
+        end
+      end
+      
+      # TimeSeriesQuery collects the set of supported methods for querying time series
+      # data from the Stackdriver metrics API.
+      class TimeSeriesQuery
+        include Google::Apis::Core::Hashable
+      
+        # A filter that defines a subset of time series data that is displayed in a
+        # widget. Time series data is fetched using the ListTimeSeries (https://cloud.
+        # google.com/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list) method.
+        # Corresponds to the JSON property `timeSeriesFilter`
+        # @return [Google::Apis::MonitoringV1::TimeSeriesFilter]
+        attr_accessor :time_series_filter
+      
+        # A pair of time series filters that define a ratio computation. The output time
+        # series is the pair-wise division of each aligned element from the numerator
+        # and denominator time series.
+        # Corresponds to the JSON property `timeSeriesFilterRatio`
+        # @return [Google::Apis::MonitoringV1::TimeSeriesFilterRatio]
+        attr_accessor :time_series_filter_ratio
+      
+        # A query used to fetch time series.
+        # Corresponds to the JSON property `timeSeriesQueryLanguage`
+        # @return [String]
+        attr_accessor :time_series_query_language
+      
+        # The unit of data contained in fetched time series. If non-empty, this unit
+        # will override any unit that accompanies fetched data. The format is the same
+        # as the unit (https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.
+        # metricDescriptors) field in MetricDescriptor.
+        # Corresponds to the JSON property `unitOverride`
+        # @return [String]
+        attr_accessor :unit_override
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @time_series_filter = args[:time_series_filter] if args.key?(:time_series_filter)
+          @time_series_filter_ratio = args[:time_series_filter_ratio] if args.key?(:time_series_filter_ratio)
+          @time_series_query_language = args[:time_series_query_language] if args.key?(:time_series_query_language)
+          @unit_override = args[:unit_override] if args.key?(:unit_override)
+        end
+      end
+      
+      # A protocol buffer message type.
+      class Type
+        include Google::Apis::Core::Hashable
+      
+        # The list of fields.
+        # Corresponds to the JSON property `fields`
+        # @return [Array<Google::Apis::MonitoringV1::Field>]
+        attr_accessor :fields
+      
+        # The fully qualified message name.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # The list of types appearing in oneof definitions in this type.
+        # Corresponds to the JSON property `oneofs`
+        # @return [Array<String>]
+        attr_accessor :oneofs
+      
+        # The protocol buffer options.
+        # Corresponds to the JSON property `options`
+        # @return [Array<Google::Apis::MonitoringV1::Option>]
+        attr_accessor :options
+      
+        # SourceContext represents information about the source of a protobuf element,
+        # like the file in which it is defined.
+        # Corresponds to the JSON property `sourceContext`
+        # @return [Google::Apis::MonitoringV1::SourceContext]
+        attr_accessor :source_context
+      
+        # The source syntax.
+        # Corresponds to the JSON property `syntax`
+        # @return [String]
+        attr_accessor :syntax
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @fields = args[:fields] if args.key?(:fields)
+          @name = args[:name] if args.key?(:name)
+          @oneofs = args[:oneofs] if args.key?(:oneofs)
+          @options = args[:options] if args.key?(:options)
+          @source_context = args[:source_context] if args.key?(:source_context)
+          @syntax = args[:syntax] if args.key?(:syntax)
+        end
+      end
+      
+      # Widget contains a single dashboard component and configuration of how to
+      # present the component in the dashboard.
+      class Widget
+        include Google::Apis::Core::Hashable
+      
+        # A generic empty message that you can re-use to avoid defining duplicated empty
+        # messages in your APIs. A typical example is to use it as the request or the
+        # response type of an API method. For instance:
+        # service Foo `
+        # rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+        # `
+        # The JSON representation for Empty is empty JSON object ``.
+        # Corresponds to the JSON property `blank`
+        # @return [Google::Apis::MonitoringV1::Empty]
+        attr_accessor :blank
+      
+        # A widget showing the latest value of a metric, and how this value relates to
+        # one or more thresholds.
+        # Corresponds to the JSON property `scorecard`
+        # @return [Google::Apis::MonitoringV1::Scorecard]
+        attr_accessor :scorecard
+      
+        # A widget that displays textual content.
+        # Corresponds to the JSON property `text`
+        # @return [Google::Apis::MonitoringV1::Text]
+        attr_accessor :text
+      
+        # Optional. The title of the widget.
+        # Corresponds to the JSON property `title`
+        # @return [String]
+        attr_accessor :title
+      
+        # A chart that displays data on a 2D (X and Y axes) plane.
+        # Corresponds to the JSON property `xyChart`
+        # @return [Google::Apis::MonitoringV1::XyChart]
+        attr_accessor :xy_chart
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @blank = args[:blank] if args.key?(:blank)
+          @scorecard = args[:scorecard] if args.key?(:scorecard)
+          @text = args[:text] if args.key?(:text)
+          @title = args[:title] if args.key?(:title)
+          @xy_chart = args[:xy_chart] if args.key?(:xy_chart)
+        end
+      end
+      
+      # A chart that displays data on a 2D (X and Y axes) plane.
+      class XyChart
+        include Google::Apis::Core::Hashable
+      
+        # Options to control visual rendering of a chart.
+        # Corresponds to the JSON property `chartOptions`
+        # @return [Google::Apis::MonitoringV1::ChartOptions]
+        attr_accessor :chart_options
+      
+        # Required. The data displayed in this chart.
+        # Corresponds to the JSON property `dataSets`
+        # @return [Array<Google::Apis::MonitoringV1::DataSet>]
+        attr_accessor :data_sets
+      
+        # Threshold lines drawn horizontally across the chart.
+        # Corresponds to the JSON property `thresholds`
+        # @return [Array<Google::Apis::MonitoringV1::Threshold>]
+        attr_accessor :thresholds
+      
+        # The duration used to display a comparison chart. A comparison chart
+        # simultaneously shows values from two similar-length time periods (e.g., week-
+        # over-week metrics). The duration must be positive, and it can only be applied
+        # to charts with data sets of LINE plot type.
+        # Corresponds to the JSON property `timeshiftDuration`
+        # @return [String]
+        attr_accessor :timeshift_duration
+      
+        # A chart axis.
+        # Corresponds to the JSON property `xAxis`
+        # @return [Google::Apis::MonitoringV1::Axis]
+        attr_accessor :x_axis
+      
+        # A chart axis.
+        # Corresponds to the JSON property `yAxis`
+        # @return [Google::Apis::MonitoringV1::Axis]
+        attr_accessor :y_axis
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @chart_options = args[:chart_options] if args.key?(:chart_options)
+          @data_sets = args[:data_sets] if args.key?(:data_sets)
+          @thresholds = args[:thresholds] if args.key?(:thresholds)
+          @timeshift_duration = args[:timeshift_duration] if args.key?(:timeshift_duration)
+          @x_axis = args[:x_axis] if args.key?(:x_axis)
+          @y_axis = args[:y_axis] if args.key?(:y_axis)
+        end
+      end
+    end
+  end
+end