Api-roll 39: 2016-07-18

generated/googleapis/lib/analyticsreporting/v4.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.analyticsreporting.v4;
 
 import 'dart:core' as core;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
 import 'package:http/http.dart' as http;
@@ skipping 301 matching lines @@
     if (pivotValueRegions != null) {
       _json["pivotValueRegions"] = pivotValueRegions.map((value) => (value).toJson()).toList();
     }
     if (values != null) {
       _json["values"] = values;
     }
     return _json;
   }
 }
 
-/** A dimension in the request. */
+/**
+ * [Dimensions](https://support.google.com/analytics/answer/1033861)
+ * are attributes of your data. For example, the dimension `ga:city`
+ * indicates the city, for example, "Paris" or "New York", from which
+ * a session originates.
+ */
 class Dimension {
   /**
    * If non-empty, we place dimension values into buckets after string to
    * int64. Dimension values that are not the string representation of an
    * integral value will be converted to zero.  The bucket values have to be in
    * increasing order.  Each bucket is closed on the lower end, and open on the
    * upper end. The "first" bucket includes all values less than the first
    * boundary, the "last" bucket includes all values up to infinity. Dimension
    * values that fall in a bucket get transformed to a new dimension value. For
    * example, if one gives a list of "0, 1, 3, 4, 7", then we return the
@@ skipping 279 matching lines @@
 
   core.Map toJson() {
     var _json = new core.Map();
     if (reports != null) {
       _json["reports"] = reports.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/** A metric in the request. */
+/**
+ * [Metrics](https://support.google.com/analytics/answer/1033861)
+ * are the quantitative measurements. For example, the metric `ga:users`
+ * indicates the total number of users for the requested time period.
+ */
 class Metric {
   /**
    * An alias for the metric expression is an alternate name for the
    * expression. The alias can be used for filtering and sorting. This field
    * is optional and is useful if the expression is not a single metric but
    * a complex expression which cannot be used in filtering and sorting.
    * The alias is also used in the response column header.
    */
   core.String alias;
   /**
@@ skipping 340 matching lines @@
   /**
    * DimensionFilterClauses are logically combined with an `AND` operator: only
    * data that is included by all these DimensionFilterClauses contributes to
    * the values in this pivot region. Dimension filters can be used to restrict
    * the columns shown in the pivot region. For example if you have
    * `ga:browser` as the requested dimension in the pivot region, and you
    * specify key filters to restrict `ga:browser` to only "IE" or "Firefox",
    * then only those two browsers would show up as columns.
    */
   core.List<DimensionFilterClause> dimensionFilterClauses;
-  /** A list of dimensions to show as pivot columns. */
+  /**
+   * A list of dimensions to show as pivot columns. A Pivot can have a maximum
+   * of 4 dimensions.
+   */
   core.List<Dimension> dimensions;
   /**
    * Specifies the maximum number of groups to return.
    * The default value is 10, also the maximum value is 1,000.
    */
   core.int maxGroupCount;
-  /** Metrics to aggregate and return. */
+  /**
+   * The pivot metrics. Pivot metrics are part of the
+   * restriction on total number of metrics in the request.
+   */
   core.List<Metric> metrics;
   /**
    * If k metrics were requested, then the response will contain some
    * data-dependent multiple of k columns in the report.  E.g., if you pivoted
    * on the dimension `ga:browser` then you'd get k columns for "Firefox", k
    * columns for "IE", k columns for "Chrome", etc. The ordering of the groups
    * of columns is determined by descending order of "total" for the first of
    * the k values.  Ties are broken by lexicographic ordering of the first
    * pivot dimension, then lexicographic ordering of the second pivot
    * dimension, and so on.  E.g., if the totals for the first value for
@@ skipping 314 matching lines @@
    * contain the same `dateRanges` definition.
    */
   core.List<DateRange> dateRanges;
   /**
    * The dimension filter clauses for filtering Dimension Values. They are
    * logically combined with the `AND` operator. Note that filtering occurs
    * before any dimensions are aggregated, so that the returned metrics
    * represent the total for only the relevant dimensions.
    */
   core.List<DimensionFilterClause> dimensionFilterClauses;
-  /** Dimensions requested in the request. */
+  /**
+   * The dimensions requested.
+   * Requests can have a total of 7 dimensions.
+   */
   core.List<Dimension> dimensions;
   /**
    * Dimension or metric filters that restrict the data returned for your
    * request. To use the `filtersExpression`, supply a dimension or metric on
    * which to filter, followed by the filter expression. For example, the
    * following expression selects `ga:browser` dimension which starts with
    * Firefox; `ga:browser=~^Firefox`. For more information on dimensions
    * and metric filters, see
    * [Filters
    * reference](https://developers.google.com/analytics/devguides/reporting/core/v3/reference#filters).
@@ skipping 16 matching lines @@
    */
   core.bool includeEmptyRows;
   /**
    * The metric filter clauses. They are logically combined with the `AND`
    * operator.  Metric filters look at only the first date range and not the
    * comparing date range. Note that filtering on metrics occurs after the
    * metrics are aggregated.
    */
   core.List<MetricFilterClause> metricFilterClauses;
   /**
-   * Metrics, the quantitative measurements, requested in the request.
-   * Requests must specify at least one metric.
+   * The metrics requested.
+   * Requests must specify at least one metric. Requests can have a
+   * total of 10 metrics.
    */
   core.List<Metric> metrics;
   /**
    * Sort order on output rows. To compare two rows, the elements of the
    * following are applied in order until a difference is found.  All date
    * ranges in the output get the same row order.
    */
   core.List<OrderBy> orderBys;
   /**
    * Page size is for paging and specifies the maximum number of returned rows.
    * Page size should be >= 0. A query returns the default of 1,000 rows.
    * The Analytics Core Reporting API returns a maximum of 10,000 rows per
    * request, no matter how many you ask for. It can also return fewer rows
    * than requested, if there aren't as many dimension segments as you expect.
    * For instance, there are fewer than 300 possible values for `ga:country`,
    * so when segmenting only by country, you can't get more than 300 rows,
    * even if you set `pageSize` to a higher value.
    */
   core.int pageSize;
   /**
    * A continuation token to get the next page of the results. Adding this to
    * the request will return the rows after the pageToken. The pageToken should
    * be the value returned in the nextPageToken parameter in the response to
    * the GetReports request.
    */
   core.String pageToken;
-  /** The pivot definitions. */
+  /** The pivot definitions. Requests can have a maximum of 2 pivots. */
   core.List<Pivot> pivots;
   /**
    * The desired report
    * [sample](https://support.google.com/analytics/answer/2637192) size.
    * If the the `samplingLevel` field is unspecified the `DEFAULT` sampling
    * level is used. Every [ReportRequest](#ReportRequest) within a
    * `batchGet` method must contain the same `samplingLevel` definition. See
    * [developer guide](/analytics/devguides/reporting/core/v4/basics#sampling)
    *  for details.
    * Possible string values are:
@@ skipping 634 matching lines @@
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (orFiltersForSegment != null) {
       _json["orFiltersForSegment"] = orFiltersForSegment.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }