// Copyright 2024 Google LLC // // 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 // // https://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. // Generated code. DO NOT EDIT! namespace Google.Apis.AnalyticsReporting.v4 { /// The AnalyticsReporting Service. public class AnalyticsReportingService : Google.Apis.Services.BaseClientService { /// The API version. public const string Version = "v4"; /// The discovery version used to generate this service. public static Google.Apis.Discovery.DiscoveryVersion DiscoveryVersionUsed = Google.Apis.Discovery.DiscoveryVersion.Version_1_0; /// Constructs a new service. public AnalyticsReportingService() : this(new Google.Apis.Services.BaseClientService.Initializer()) { } /// Constructs a new service. /// The service initializer. public AnalyticsReportingService(Google.Apis.Services.BaseClientService.Initializer initializer) : base(initializer) { Reports = new ReportsResource(this); UserActivity = new UserActivityResource(this); BaseUri = GetEffectiveUri(BaseUriOverride, "https://analyticsreporting.googleapis.com/"); BatchUri = GetEffectiveUri(null, "https://analyticsreporting.googleapis.com/batch"); } /// Gets the service supported features. public override System.Collections.Generic.IList Features => new string[0]; /// Gets the service name. public override string Name => "analyticsreporting"; /// Gets the service base URI. public override string BaseUri { get; } /// Gets the service base path. public override string BasePath => ""; /// Gets the batch base URI; null if unspecified. public override string BatchUri { get; } /// Gets the batch base path; null if unspecified. public override string BatchPath => "batch"; /// Available OAuth 2.0 scopes for use with the Analytics Reporting API. public class Scope { /// View and manage your Google Analytics data public static string Analytics = "https://www.googleapis.com/auth/analytics"; /// See and download your Google Analytics data public static string AnalyticsReadonly = "https://www.googleapis.com/auth/analytics.readonly"; } /// Available OAuth 2.0 scope constants for use with the Analytics Reporting API. public static class ScopeConstants { /// View and manage your Google Analytics data public const string Analytics = "https://www.googleapis.com/auth/analytics"; /// See and download your Google Analytics data public const string AnalyticsReadonly = "https://www.googleapis.com/auth/analytics.readonly"; } /// Gets the Reports resource. public virtual ReportsResource Reports { get; } /// Gets the UserActivity resource. public virtual UserActivityResource UserActivity { get; } } /// A base abstract class for AnalyticsReporting requests. public abstract class AnalyticsReportingBaseServiceRequest : Google.Apis.Requests.ClientServiceRequest { /// Constructs a new AnalyticsReportingBaseServiceRequest instance. protected AnalyticsReportingBaseServiceRequest(Google.Apis.Services.IClientService service) : base(service) { } /// V1 error format. [Google.Apis.Util.RequestParameterAttribute("$.xgafv", Google.Apis.Util.RequestParameterType.Query)] public virtual System.Nullable Xgafv { get; set; } /// V1 error format. public enum XgafvEnum { /// v1 error format [Google.Apis.Util.StringValueAttribute("1")] Value1 = 0, /// v2 error format [Google.Apis.Util.StringValueAttribute("2")] Value2 = 1, } /// OAuth access token. [Google.Apis.Util.RequestParameterAttribute("access_token", Google.Apis.Util.RequestParameterType.Query)] public virtual string AccessToken { get; set; } /// Data format for response. [Google.Apis.Util.RequestParameterAttribute("alt", Google.Apis.Util.RequestParameterType.Query)] public virtual System.Nullable Alt { get; set; } /// Data format for response. public enum AltEnum { /// Responses with Content-Type of application/json [Google.Apis.Util.StringValueAttribute("json")] Json = 0, /// Media download with context-dependent Content-Type [Google.Apis.Util.StringValueAttribute("media")] Media = 1, /// Responses with Content-Type of application/x-protobuf [Google.Apis.Util.StringValueAttribute("proto")] Proto = 2, } /// JSONP [Google.Apis.Util.RequestParameterAttribute("callback", Google.Apis.Util.RequestParameterType.Query)] public virtual string Callback { get; set; } /// Selector specifying which fields to include in a partial response. [Google.Apis.Util.RequestParameterAttribute("fields", Google.Apis.Util.RequestParameterType.Query)] public virtual string Fields { get; set; } /// /// API key. Your API key identifies your project and provides you with API access, quota, and reports. Required /// unless you provide an OAuth 2.0 token. /// [Google.Apis.Util.RequestParameterAttribute("key", Google.Apis.Util.RequestParameterType.Query)] public virtual string Key { get; set; } /// OAuth 2.0 token for the current user. [Google.Apis.Util.RequestParameterAttribute("oauth_token", Google.Apis.Util.RequestParameterType.Query)] public virtual string OauthToken { get; set; } /// Returns response with indentations and line breaks. [Google.Apis.Util.RequestParameterAttribute("prettyPrint", Google.Apis.Util.RequestParameterType.Query)] public virtual System.Nullable PrettyPrint { get; set; } /// /// Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a /// user, but should not exceed 40 characters. /// [Google.Apis.Util.RequestParameterAttribute("quotaUser", Google.Apis.Util.RequestParameterType.Query)] public virtual string QuotaUser { get; set; } /// Legacy upload protocol for media (e.g. "media", "multipart"). [Google.Apis.Util.RequestParameterAttribute("uploadType", Google.Apis.Util.RequestParameterType.Query)] public virtual string UploadType { get; set; } /// Upload protocol for media (e.g. "raw", "multipart"). [Google.Apis.Util.RequestParameterAttribute("upload_protocol", Google.Apis.Util.RequestParameterType.Query)] public virtual string UploadProtocol { get; set; } /// Initializes AnalyticsReporting parameter list. protected override void InitParameters() { base.InitParameters(); RequestParameters.Add("$.xgafv", new Google.Apis.Discovery.Parameter { Name = "$.xgafv", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("access_token", new Google.Apis.Discovery.Parameter { Name = "access_token", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("alt", new Google.Apis.Discovery.Parameter { Name = "alt", IsRequired = false, ParameterType = "query", DefaultValue = "json", Pattern = null, }); RequestParameters.Add("callback", new Google.Apis.Discovery.Parameter { Name = "callback", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("fields", new Google.Apis.Discovery.Parameter { Name = "fields", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("key", new Google.Apis.Discovery.Parameter { Name = "key", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("oauth_token", new Google.Apis.Discovery.Parameter { Name = "oauth_token", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("prettyPrint", new Google.Apis.Discovery.Parameter { Name = "prettyPrint", IsRequired = false, ParameterType = "query", DefaultValue = "true", Pattern = null, }); RequestParameters.Add("quotaUser", new Google.Apis.Discovery.Parameter { Name = "quotaUser", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("uploadType", new Google.Apis.Discovery.Parameter { Name = "uploadType", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); RequestParameters.Add("upload_protocol", new Google.Apis.Discovery.Parameter { Name = "upload_protocol", IsRequired = false, ParameterType = "query", DefaultValue = null, Pattern = null, }); } } /// The "reports" collection of methods. public class ReportsResource { private const string Resource = "reports"; /// The service which this resource belongs to. private readonly Google.Apis.Services.IClientService service; /// Constructs a new resource. public ReportsResource(Google.Apis.Services.IClientService service) { this.service = service; } /// Returns the Analytics data. /// The body of the request. public virtual BatchGetRequest BatchGet(Google.Apis.AnalyticsReporting.v4.Data.GetReportsRequest body) { return new BatchGetRequest(this.service, body); } /// Returns the Analytics data. public class BatchGetRequest : AnalyticsReportingBaseServiceRequest { /// Constructs a new BatchGet request. public BatchGetRequest(Google.Apis.Services.IClientService service, Google.Apis.AnalyticsReporting.v4.Data.GetReportsRequest body) : base(service) { Body = body; InitParameters(); } /// Gets or sets the body of this request. Google.Apis.AnalyticsReporting.v4.Data.GetReportsRequest Body { get; set; } /// Returns the body of the request. protected override object GetBody() => Body; /// Gets the method name. public override string MethodName => "batchGet"; /// Gets the HTTP method. public override string HttpMethod => "POST"; /// Gets the REST path. public override string RestPath => "v4/reports:batchGet"; /// Initializes BatchGet parameter list. protected override void InitParameters() { base.InitParameters(); } } } /// The "userActivity" collection of methods. public class UserActivityResource { private const string Resource = "userActivity"; /// The service which this resource belongs to. private readonly Google.Apis.Services.IClientService service; /// Constructs a new resource. public UserActivityResource(Google.Apis.Services.IClientService service) { this.service = service; } /// Returns User Activity data. /// The body of the request. public virtual SearchRequest Search(Google.Apis.AnalyticsReporting.v4.Data.SearchUserActivityRequest body) { return new SearchRequest(this.service, body); } /// Returns User Activity data. public class SearchRequest : AnalyticsReportingBaseServiceRequest { /// Constructs a new Search request. public SearchRequest(Google.Apis.Services.IClientService service, Google.Apis.AnalyticsReporting.v4.Data.SearchUserActivityRequest body) : base(service) { Body = body; InitParameters(); } /// Gets or sets the body of this request. Google.Apis.AnalyticsReporting.v4.Data.SearchUserActivityRequest Body { get; set; } /// Returns the body of the request. protected override object GetBody() => Body; /// Gets the method name. public override string MethodName => "search"; /// Gets the HTTP method. public override string HttpMethod => "POST"; /// Gets the REST path. public override string RestPath => "v4/userActivity:search"; /// Initializes Search parameter list. protected override void InitParameters() { base.InitParameters(); } } } } namespace Google.Apis.AnalyticsReporting.v4.Data { /// /// An Activity represents data for an activity of a user. Note that an Activity is different from a hit. A hit /// might result in multiple Activity's. For example, if a hit includes a transaction and a goal completion, there /// will be two Activity protos for this hit, one for ECOMMERCE and one for GOAL. Conversely, multiple hits can also /// construct one Activity. In classic e-commerce, data for one transaction might be sent through multiple hits. /// These hits will be merged into one ECOMMERCE Activity. /// public class Activity : Google.Apis.Requests.IDirectResponseSchema { private string _activityTimeRaw; private object _activityTime; /// /// Timestamp of the activity. If activities for a visit cross midnight and occur in two separate dates, then /// two sessions (one per date) share the session identifier. For example, say session ID 113472 has activity /// within 2019-08-20, and session ID 243742 has activity within 2019-08-25 and 2019-08-26. Session ID 113472 is /// one session, and session ID 243742 is two sessions. /// [Newtonsoft.Json.JsonPropertyAttribute("activityTime")] public virtual string ActivityTimeRaw { get => _activityTimeRaw; set { _activityTime = Google.Apis.Util.Utilities.DeserializeForGoogleFormat(value); _activityTimeRaw = value; } } /// representation of . [Newtonsoft.Json.JsonIgnoreAttribute] [System.ObsoleteAttribute("This property is obsolete and may behave unexpectedly; please use ActivityTimeDateTimeOffset instead.")] public virtual object ActivityTime { get => _activityTime; set { _activityTimeRaw = Google.Apis.Util.Utilities.SerializeForGoogleFormat(value); _activityTime = value; } } /// representation of . [Newtonsoft.Json.JsonIgnoreAttribute] public virtual System.DateTimeOffset? ActivityTimeDateTimeOffset { get => Google.Apis.Util.DiscoveryFormat.ParseGoogleDateTimeToDateTimeOffset(ActivityTimeRaw); set => ActivityTimeRaw = Google.Apis.Util.DiscoveryFormat.FormatDateTimeOffsetToGoogleDateTime(value); } /// Type of this activity. [Newtonsoft.Json.JsonPropertyAttribute("activityType")] public virtual string ActivityType { get; set; } /// This will be set if `activity_type` equals `SCREEN_VIEW`. [Newtonsoft.Json.JsonPropertyAttribute("appview")] public virtual ScreenviewData Appview { get; set; } /// /// For manual campaign tracking, it is the value of the utm_campaign campaign tracking parameter. For AdWords /// autotagging, it is the name(s) of the online ad campaign(s) you use for the property. If you use neither, /// its value is (not set). /// [Newtonsoft.Json.JsonPropertyAttribute("campaign")] public virtual string Campaign { get; set; } /// /// The Channel Group associated with an end user's session for this View (defined by the View's Channel /// Groupings). /// [Newtonsoft.Json.JsonPropertyAttribute("channelGrouping")] public virtual string ChannelGrouping { get; set; } /// A list of all custom dimensions associated with this activity. [Newtonsoft.Json.JsonPropertyAttribute("customDimension")] public virtual System.Collections.Generic.IList CustomDimension { get; set; } /// This will be set if `activity_type` equals `ECOMMERCE`. [Newtonsoft.Json.JsonPropertyAttribute("ecommerce")] public virtual EcommerceData Ecommerce { get; set; } /// /// This field contains all the details pertaining to an event and will be set if `activity_type` equals /// `EVENT`. /// [Newtonsoft.Json.JsonPropertyAttribute("event")] public virtual EventData Event__ { get; set; } /// /// This field contains a list of all the goals that were reached in this activity when `activity_type` equals /// `GOAL`. /// [Newtonsoft.Json.JsonPropertyAttribute("goals")] public virtual GoalSetData Goals { get; set; } /// The hostname from which the tracking request was made. [Newtonsoft.Json.JsonPropertyAttribute("hostname")] public virtual string Hostname { get; set; } /// /// For manual campaign tracking, it is the value of the utm_term campaign tracking parameter. For AdWords /// traffic, it contains the best matching targeting criteria. For the display network, where multiple targeting /// criteria could have caused the ad to show up, it returns the best matching targeting criteria as selected by /// Ads. This could be display_keyword, site placement, boomuserlist, user_interest, age, or gender. Otherwise /// its value is (not set). /// [Newtonsoft.Json.JsonPropertyAttribute("keyword")] public virtual string Keyword { get; set; } /// The first page in users' sessions, or the landing page. [Newtonsoft.Json.JsonPropertyAttribute("landingPagePath")] public virtual string LandingPagePath { get; set; } /// /// The type of referrals. For manual campaign tracking, it is the value of the utm_medium campaign tracking /// parameter. For AdWords autotagging, it is cpc. If users came from a search engine detected by Google /// Analytics, it is organic. If the referrer is not a search engine, it is referral. If users came directly to /// the property and document.referrer is empty, its value is (none). /// [Newtonsoft.Json.JsonPropertyAttribute("medium")] public virtual string Medium { get; set; } /// /// This will be set if `activity_type` equals `PAGEVIEW`. This field contains all the details about the visitor /// and the page that was visited. /// [Newtonsoft.Json.JsonPropertyAttribute("pageview")] public virtual PageviewData Pageview { get; set; } /// /// The source of referrals. For manual campaign tracking, it is the value of the utm_source campaign tracking /// parameter. For AdWords autotagging, it is google. If you use neither, it is the domain of the source (e.g., /// document.referrer) referring the users. It may also contain a port address. If users arrived without a /// referrer, its value is (direct). /// [Newtonsoft.Json.JsonPropertyAttribute("source")] public virtual string Source { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// Defines a cohort. A cohort is a group of users who share a common characteristic. For example, all users with /// the same acquisition date belong to the same cohort. /// public class Cohort : Google.Apis.Requests.IDirectResponseSchema { /// /// This is used for `FIRST_VISIT_DATE` cohort, the cohort selects users whose first visit date is between start /// date and end date defined in the DateRange. The date ranges should be aligned for cohort requests. If the /// request contains `ga:cohortNthDay` it should be exactly one day long, if `ga:cohortNthWeek` it should be /// aligned to the week boundary (starting at Sunday and ending Saturday), and for `ga:cohortNthMonth` the date /// range should be aligned to the month (starting at the first and ending on the last day of the month). For /// LTV requests there are no such restrictions. You do not need to supply a date range for the /// `reportsRequest.dateRanges` field. /// [Newtonsoft.Json.JsonPropertyAttribute("dateRange")] public virtual DateRange DateRange { get; set; } /// /// A unique name for the cohort. If not defined name will be auto-generated with values cohort_[1234...]. /// [Newtonsoft.Json.JsonPropertyAttribute("name")] public virtual string Name { get; set; } /// /// Type of the cohort. The only supported type as of now is `FIRST_VISIT_DATE`. If this field is unspecified /// the cohort is treated as `FIRST_VISIT_DATE` type cohort. /// [Newtonsoft.Json.JsonPropertyAttribute("type")] public virtual string Type { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// Defines a cohort group. For example: "cohortGroup": { "cohorts": [{ "name": "cohort 1", "type": /// "FIRST_VISIT_DATE", "dateRange": { "startDate": "2015-08-01", "endDate": "2015-08-01" } },{ "name": "cohort 2" /// "type": "FIRST_VISIT_DATE" "dateRange": { "startDate": "2015-07-01", "endDate": "2015-07-01" } }] } /// public class CohortGroup : Google.Apis.Requests.IDirectResponseSchema { /// The definition for the cohort. [Newtonsoft.Json.JsonPropertyAttribute("cohorts")] public virtual System.Collections.Generic.IList Cohorts { get; set; } /// /// Enable Life Time Value (LTV). LTV measures lifetime value for users acquired through different channels. /// Please see: [Cohort Analysis](https://support.google.com/analytics/answer/6074676) and [Lifetime /// Value](https://support.google.com/analytics/answer/6182550) If the value of lifetimeValue is false: - The /// metric values are similar to the values in the web interface cohort report. - The cohort definition date /// ranges must be aligned to the calendar week and month. i.e. while requesting `ga:cohortNthWeek` the /// `startDate` in the cohort definition should be a Sunday and the `endDate` should be the following Saturday, /// and for `ga:cohortNthMonth`, the `startDate` should be the 1st of the month and `endDate` should be the last /// day of the month. When the lifetimeValue is true: - The metric values will correspond to the values in the /// web interface LifeTime value report. - The Lifetime Value report shows you how user value (Revenue) and /// engagement (Appviews, Goal Completions, Sessions, and Session Duration) grow during the 90 days after a user /// is acquired. - The metrics are calculated as a cumulative average per user per the time increment. - The /// cohort definition date ranges need not be aligned to the calendar week and month boundaries. - The `viewId` /// must be an [app view ID](https://support.google.com/analytics/answer/2649553#WebVersusAppViews) /// [Newtonsoft.Json.JsonPropertyAttribute("lifetimeValue")] public virtual System.Nullable LifetimeValue { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Column headers. public class ColumnHeader : Google.Apis.Requests.IDirectResponseSchema { /// The dimension names in the response. [Newtonsoft.Json.JsonPropertyAttribute("dimensions")] public virtual System.Collections.Generic.IList Dimensions { get; set; } /// Metric headers for the metrics in the response. [Newtonsoft.Json.JsonPropertyAttribute("metricHeader")] public virtual MetricHeader MetricHeader { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Custom dimension. public class CustomDimension : Google.Apis.Requests.IDirectResponseSchema { /// Slot number of custom dimension. [Newtonsoft.Json.JsonPropertyAttribute("index")] public virtual System.Nullable Index { get; set; } /// /// Value of the custom dimension. Default value (i.e. empty string) indicates clearing sesion/visitor scope /// custom dimension value. /// [Newtonsoft.Json.JsonPropertyAttribute("value")] public virtual string Value { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// A contiguous set of days: startDate, startDate + 1 day, ..., endDate. The start and end dates are specified in /// [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) date format `YYYY-MM-DD`. /// public class DateRange : Google.Apis.Requests.IDirectResponseSchema { /// The end date for the query in the format `YYYY-MM-DD`. [Newtonsoft.Json.JsonPropertyAttribute("endDate")] public virtual string EndDate { get; set; } /// The start date for the query in the format `YYYY-MM-DD`. [Newtonsoft.Json.JsonPropertyAttribute("startDate")] public virtual string StartDate { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Used to return a list of metrics for a single DateRange / dimension combination public class DateRangeValues : Google.Apis.Requests.IDirectResponseSchema { /// The values of each pivot region. [Newtonsoft.Json.JsonPropertyAttribute("pivotValueRegions")] public virtual System.Collections.Generic.IList PivotValueRegions { get; set; } /// Each value corresponds to each Metric in the request. [Newtonsoft.Json.JsonPropertyAttribute("values")] public virtual System.Collections.Generic.IList Values { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// [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. /// public class Dimension : Google.Apis.Requests.IDirectResponseSchema { /// /// 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 following buckets: - bucket #1: values < 0, dimension /// value "<0" - bucket #2: values in [0,1), dimension value "0" - bucket #3: values in [1,3), dimension /// value "1-2" - bucket #4: values in [3,4), dimension value "3" - bucket #5: values in [4,7), dimension value /// "4-6" - bucket #6: values >= 7, dimension value "7+" NOTE: If you are applying histogram mutation on /// any dimension, and using that dimension in sort, you will want to use the sort type `HISTOGRAM_BUCKET` for /// that purpose. Without that the dimension values will be sorted according to dictionary (lexicographic) /// order. For example the ascending dictionary order is: "<50", "1001+", "121-1000", "50-120" And the /// ascending `HISTOGRAM_BUCKET` order is: "<50", "50-120", "121-1000", "1001+" The client has to /// explicitly request `"orderType": "HISTOGRAM_BUCKET"` for a histogram-mutated dimension. /// [Newtonsoft.Json.JsonPropertyAttribute("histogramBuckets")] public virtual System.Collections.Generic.IList> HistogramBuckets { get; set; } /// Name of the dimension to fetch, for example `ga:browser`. [Newtonsoft.Json.JsonPropertyAttribute("name")] public virtual string Name { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Dimension filter specifies the filtering options on a dimension. public class DimensionFilter : Google.Apis.Requests.IDirectResponseSchema { /// Should the match be case sensitive? Default is false. [Newtonsoft.Json.JsonPropertyAttribute("caseSensitive")] public virtual System.Nullable CaseSensitive { get; set; } /// The dimension to filter on. A DimensionFilter must contain a dimension. [Newtonsoft.Json.JsonPropertyAttribute("dimensionName")] public virtual string DimensionName { get; set; } /// /// Strings or regular expression to match against. Only the first value of the list is used for comparison /// unless the operator is `IN_LIST`. If `IN_LIST` operator, then the entire list is used to filter the /// dimensions as explained in the description of the `IN_LIST` operator. /// [Newtonsoft.Json.JsonPropertyAttribute("expressions")] public virtual System.Collections.Generic.IList Expressions { get; set; } /// /// Logical `NOT` operator. If this boolean is set to true, then the matching dimension values will be excluded /// in the report. The default is false. /// [Newtonsoft.Json.JsonPropertyAttribute("not")] public virtual System.Nullable Not { get; set; } /// How to match the dimension to the expression. The default is REGEXP. [Newtonsoft.Json.JsonPropertyAttribute("operator")] public virtual string Operator__ { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// A group of dimension filters. Set the operator value to specify how the filters are logically combined. /// public class DimensionFilterClause : Google.Apis.Requests.IDirectResponseSchema { /// The repeated set of filters. They are logically combined based on the operator specified. [Newtonsoft.Json.JsonPropertyAttribute("filters")] public virtual System.Collections.Generic.IList Filters { get; set; } /// /// The operator for combining multiple dimension filters. If unspecified, it is treated as an `OR`. /// [Newtonsoft.Json.JsonPropertyAttribute("operator")] public virtual string Operator__ { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// Dynamic segment definition for defining the segment within the request. A segment can select users, sessions or /// both. /// public class DynamicSegment : Google.Apis.Requests.IDirectResponseSchema { /// The name of the dynamic segment. [Newtonsoft.Json.JsonPropertyAttribute("name")] public virtual string Name { get; set; } /// Session Segment to select sessions to include in the segment. [Newtonsoft.Json.JsonPropertyAttribute("sessionSegment")] public virtual SegmentDefinition SessionSegment { get; set; } /// User Segment to select users to include in the segment. [Newtonsoft.Json.JsonPropertyAttribute("userSegment")] public virtual SegmentDefinition UserSegment { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// E-commerce details associated with the user activity. public class EcommerceData : Google.Apis.Requests.IDirectResponseSchema { /// Action associated with this e-commerce action. [Newtonsoft.Json.JsonPropertyAttribute("actionType")] public virtual string ActionType { get; set; } /// The type of this e-commerce activity. [Newtonsoft.Json.JsonPropertyAttribute("ecommerceType")] public virtual string EcommerceType { get; set; } /// Details of the products in this transaction. [Newtonsoft.Json.JsonPropertyAttribute("products")] public virtual System.Collections.Generic.IList Products { get; set; } /// Transaction details of this e-commerce action. [Newtonsoft.Json.JsonPropertyAttribute("transaction")] public virtual TransactionData Transaction { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Represents all the details pertaining to an event. public class EventData : Google.Apis.Requests.IDirectResponseSchema { /// Type of interaction with the object. Eg: 'play'. [Newtonsoft.Json.JsonPropertyAttribute("eventAction")] public virtual string EventAction { get; set; } /// The object on the page that was interacted with. Eg: 'Video'. [Newtonsoft.Json.JsonPropertyAttribute("eventCategory")] public virtual string EventCategory { get; set; } /// Number of such events in this activity. [Newtonsoft.Json.JsonPropertyAttribute("eventCount")] public virtual System.Nullable EventCount { get; set; } /// Label attached with the event. [Newtonsoft.Json.JsonPropertyAttribute("eventLabel")] public virtual string EventLabel { get; set; } /// Numeric value associated with the event. [Newtonsoft.Json.JsonPropertyAttribute("eventValue")] public virtual System.Nullable EventValue { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The batch request containing multiple report request. public class GetReportsRequest : Google.Apis.Requests.IDirectResponseSchema { /// /// Requests, each request will have a separate response. There can be a maximum of 5 requests. All requests /// should have the same `dateRanges`, `viewId`, `segments`, `samplingLevel`, and `cohortGroup`. /// [Newtonsoft.Json.JsonPropertyAttribute("reportRequests")] public virtual System.Collections.Generic.IList ReportRequests { get; set; } /// /// Enables [resource based /// quotas](/analytics/devguides/reporting/core/v4/limits-quotas#analytics_reporting_api_v4), (defaults to /// `False`). If this field is set to `True` the per view (profile) quotas are governed by the computational /// cost of the request. Note that using cost based quotas will higher enable sampling rates. (10 Million for /// `SMALL`, 100M for `LARGE`. See the [limits and quotas /// documentation](/analytics/devguides/reporting/core/v4/limits-quotas#analytics_reporting_api_v4) for details. /// [Newtonsoft.Json.JsonPropertyAttribute("useResourceQuotas")] public virtual System.Nullable UseResourceQuotas { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The main response class which holds the reports from the Reporting API `batchGet` call. public class GetReportsResponse : Google.Apis.Requests.IDirectResponseSchema { /// /// The amount of resource quota tokens deducted to execute the query. Includes all responses. /// [Newtonsoft.Json.JsonPropertyAttribute("queryCost")] public virtual System.Nullable QueryCost { get; set; } /// Responses corresponding to each of the request. [Newtonsoft.Json.JsonPropertyAttribute("reports")] public virtual System.Collections.Generic.IList Reports { get; set; } /// The amount of resource quota remaining for the property. [Newtonsoft.Json.JsonPropertyAttribute("resourceQuotasRemaining")] public virtual ResourceQuotasRemaining ResourceQuotasRemaining { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Represents all the details pertaining to a goal. public class GoalData : Google.Apis.Requests.IDirectResponseSchema { /// URL of the page where this goal was completed. [Newtonsoft.Json.JsonPropertyAttribute("goalCompletionLocation")] public virtual string GoalCompletionLocation { get; set; } /// Total number of goal completions in this activity. [Newtonsoft.Json.JsonPropertyAttribute("goalCompletions")] public virtual System.Nullable GoalCompletions { get; set; } /// This identifies the goal as configured for the profile. [Newtonsoft.Json.JsonPropertyAttribute("goalIndex")] public virtual System.Nullable GoalIndex { get; set; } /// Name of the goal. [Newtonsoft.Json.JsonPropertyAttribute("goalName")] public virtual string GoalName { get; set; } /// URL of the page one step prior to the goal completion. [Newtonsoft.Json.JsonPropertyAttribute("goalPreviousStep1")] public virtual string GoalPreviousStep1 { get; set; } /// URL of the page two steps prior to the goal completion. [Newtonsoft.Json.JsonPropertyAttribute("goalPreviousStep2")] public virtual string GoalPreviousStep2 { get; set; } /// URL of the page three steps prior to the goal completion. [Newtonsoft.Json.JsonPropertyAttribute("goalPreviousStep3")] public virtual string GoalPreviousStep3 { get; set; } /// Value in this goal. [Newtonsoft.Json.JsonPropertyAttribute("goalValue")] public virtual System.Nullable GoalValue { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Represents a set of goals that were reached in an activity. public class GoalSetData : Google.Apis.Requests.IDirectResponseSchema { /// All the goals that were reached in the current activity. [Newtonsoft.Json.JsonPropertyAttribute("goals")] public virtual System.Collections.Generic.IList Goals { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// [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. /// public class Metric : Google.Apis.Requests.IDirectResponseSchema { /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("alias")] public virtual string Alias { get; set; } /// /// A metric expression in the request. An expression is constructed from one or more metrics and numbers. /// Accepted operators include: Plus (+), Minus (-), Negation (Unary -), Divided by (/), Multiplied by (*), /// Parenthesis, Positive cardinal numbers (0-9), can include decimals and is limited to 1024 characters. /// Example `ga:totalRefunds/ga:users`, in most cases the metric expression is just a single metric name like /// `ga:users`. Adding mixed `MetricType` (E.g., `CURRENCY` + `PERCENTAGE`) metrics will result in unexpected /// results. /// [Newtonsoft.Json.JsonPropertyAttribute("expression")] public virtual string Expression { get; set; } /// Specifies how the metric expression should be formatted, for example `INTEGER`. [Newtonsoft.Json.JsonPropertyAttribute("formattingType")] public virtual string FormattingType { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// MetricFilter specifies the filter on a metric. public class MetricFilter : Google.Apis.Requests.IDirectResponseSchema { /// The value to compare against. [Newtonsoft.Json.JsonPropertyAttribute("comparisonValue")] public virtual string ComparisonValue { get; set; } /// /// The metric that will be filtered on. A metricFilter must contain a metric name. A metric name can be an /// alias earlier defined as a metric or it can also be a metric expression. /// [Newtonsoft.Json.JsonPropertyAttribute("metricName")] public virtual string MetricName { get; set; } /// /// Logical `NOT` operator. If this boolean is set to true, then the matching metric values will be excluded in /// the report. The default is false. /// [Newtonsoft.Json.JsonPropertyAttribute("not")] public virtual System.Nullable Not { get; set; } /// /// Is the metric `EQUAL`, `LESS_THAN` or `GREATER_THAN` the comparisonValue, the default is `EQUAL`. If the /// operator is `IS_MISSING`, checks if the metric is missing and would ignore the comparisonValue. /// [Newtonsoft.Json.JsonPropertyAttribute("operator")] public virtual string Operator__ { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// Represents a group of metric filters. Set the operator value to specify how the filters are logically combined. /// public class MetricFilterClause : Google.Apis.Requests.IDirectResponseSchema { /// The repeated set of filters. They are logically combined based on the operator specified. [Newtonsoft.Json.JsonPropertyAttribute("filters")] public virtual System.Collections.Generic.IList Filters { get; set; } /// /// The operator for combining multiple metric filters. If unspecified, it is treated as an `OR`. /// [Newtonsoft.Json.JsonPropertyAttribute("operator")] public virtual string Operator__ { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The headers for the metrics. public class MetricHeader : Google.Apis.Requests.IDirectResponseSchema { /// Headers for the metrics in the response. [Newtonsoft.Json.JsonPropertyAttribute("metricHeaderEntries")] public virtual System.Collections.Generic.IList MetricHeaderEntries { get; set; } /// Headers for the pivots in the response. [Newtonsoft.Json.JsonPropertyAttribute("pivotHeaders")] public virtual System.Collections.Generic.IList PivotHeaders { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Header for the metrics. public class MetricHeaderEntry : Google.Apis.Requests.IDirectResponseSchema { /// The name of the header. [Newtonsoft.Json.JsonPropertyAttribute("name")] public virtual string Name { get; set; } /// The type of the metric, for example `INTEGER`. [Newtonsoft.Json.JsonPropertyAttribute("type")] public virtual string Type { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// A list of segment filters in the `OR` group are combined with the logical OR operator. public class OrFiltersForSegment : Google.Apis.Requests.IDirectResponseSchema { /// List of segment filters to be combined with a `OR` operator. [Newtonsoft.Json.JsonPropertyAttribute("segmentFilterClauses")] public virtual System.Collections.Generic.IList SegmentFilterClauses { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Specifies the sorting options. public class OrderBy : Google.Apis.Requests.IDirectResponseSchema { /// /// The field which to sort by. The default sort order is ascending. Example: `ga:browser`. Note, that you can /// only specify one field for sort here. For example, `ga:browser, ga:city` is not valid. /// [Newtonsoft.Json.JsonPropertyAttribute("fieldName")] public virtual string FieldName { get; set; } /// The order type. The default orderType is `VALUE`. [Newtonsoft.Json.JsonPropertyAttribute("orderType")] public virtual string OrderType { get; set; } /// The sorting order for the field. [Newtonsoft.Json.JsonPropertyAttribute("sortOrder")] public virtual string SortOrder { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Represents details collected when the visitor views a page. public class PageviewData : Google.Apis.Requests.IDirectResponseSchema { /// The URL of the page that the visitor viewed. [Newtonsoft.Json.JsonPropertyAttribute("pagePath")] public virtual string PagePath { get; set; } /// The title of the page that the visitor viewed. [Newtonsoft.Json.JsonPropertyAttribute("pageTitle")] public virtual string PageTitle { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// The Pivot describes the pivot section in the request. The Pivot helps rearrange the information in the table for /// certain reports by pivoting your data on a second dimension. /// public class Pivot : Google.Apis.Requests.IDirectResponseSchema { /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dimensionFilterClauses")] public virtual System.Collections.Generic.IList DimensionFilterClauses { get; set; } /// /// A list of dimensions to show as pivot columns. A Pivot can have a maximum of 4 dimensions. Pivot dimensions /// are part of the restriction on the total number of dimensions allowed in the request. /// [Newtonsoft.Json.JsonPropertyAttribute("dimensions")] public virtual System.Collections.Generic.IList Dimensions { get; set; } /// /// Specifies the maximum number of groups to return. The default value is 10, also the maximum value is 1,000. /// [Newtonsoft.Json.JsonPropertyAttribute("maxGroupCount")] public virtual System.Nullable MaxGroupCount { get; set; } /// /// The pivot metrics. Pivot metrics are part of the restriction on total number of metrics allowed in the /// request. /// [Newtonsoft.Json.JsonPropertyAttribute("metrics")] public virtual System.Collections.Generic.IList Metrics { get; set; } /// /// 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 Firefox, IE, and Chrome were 8, 2, 8, respectively, the order of columns would be Chrome, /// Firefox, IE. The following let you choose which of the groups of k columns are included in the response. /// [Newtonsoft.Json.JsonPropertyAttribute("startGroup")] public virtual System.Nullable StartGroup { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The headers for each of the pivot sections defined in the request. public class PivotHeader : Google.Apis.Requests.IDirectResponseSchema { /// A single pivot section header. [Newtonsoft.Json.JsonPropertyAttribute("pivotHeaderEntries")] public virtual System.Collections.Generic.IList PivotHeaderEntries { get; set; } /// The total number of groups for this pivot. [Newtonsoft.Json.JsonPropertyAttribute("totalPivotGroupsCount")] public virtual System.Nullable TotalPivotGroupsCount { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// The headers for the each of the metric column corresponding to the metrics requested in the pivots section of /// the response. /// public class PivotHeaderEntry : Google.Apis.Requests.IDirectResponseSchema { /// The name of the dimensions in the pivot response. [Newtonsoft.Json.JsonPropertyAttribute("dimensionNames")] public virtual System.Collections.Generic.IList DimensionNames { get; set; } /// The values for the dimensions in the pivot. [Newtonsoft.Json.JsonPropertyAttribute("dimensionValues")] public virtual System.Collections.Generic.IList DimensionValues { get; set; } /// The metric header for the metric in the pivot. [Newtonsoft.Json.JsonPropertyAttribute("metric")] public virtual MetricHeaderEntry Metric { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The metric values in the pivot region. public class PivotValueRegion : Google.Apis.Requests.IDirectResponseSchema { /// The values of the metrics in each of the pivot regions. [Newtonsoft.Json.JsonPropertyAttribute("values")] public virtual System.Collections.Generic.IList Values { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Details of the products in an e-commerce transaction. public class ProductData : Google.Apis.Requests.IDirectResponseSchema { /// The total revenue from purchased product items. [Newtonsoft.Json.JsonPropertyAttribute("itemRevenue")] public virtual System.Nullable ItemRevenue { get; set; } /// /// The product name, supplied by the e-commerce tracking application, for the purchased items. /// [Newtonsoft.Json.JsonPropertyAttribute("productName")] public virtual string ProductName { get; set; } /// Total number of this product units in the transaction. [Newtonsoft.Json.JsonPropertyAttribute("productQuantity")] public virtual System.Nullable ProductQuantity { get; set; } /// Unique code that represents the product. [Newtonsoft.Json.JsonPropertyAttribute("productSku")] public virtual string ProductSku { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The data response corresponding to the request. public class Report : Google.Apis.Requests.IDirectResponseSchema { /// The column headers. [Newtonsoft.Json.JsonPropertyAttribute("columnHeader")] public virtual ColumnHeader ColumnHeader { get; set; } /// Response data. [Newtonsoft.Json.JsonPropertyAttribute("data")] public virtual ReportData Data { get; set; } /// Page token to retrieve the next page of results in the list. [Newtonsoft.Json.JsonPropertyAttribute("nextPageToken")] public virtual string NextPageToken { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The data part of the report. public class ReportData : Google.Apis.Requests.IDirectResponseSchema { private string _dataLastRefreshedRaw; private object _dataLastRefreshed; /// /// The last time the data in the report was refreshed. All the hits received before this timestamp are included /// in the calculation of the report. /// [Newtonsoft.Json.JsonPropertyAttribute("dataLastRefreshed")] public virtual string DataLastRefreshedRaw { get => _dataLastRefreshedRaw; set { _dataLastRefreshed = Google.Apis.Util.Utilities.DeserializeForGoogleFormat(value); _dataLastRefreshedRaw = value; } } /// representation of . [Newtonsoft.Json.JsonIgnoreAttribute] [System.ObsoleteAttribute("This property is obsolete and may behave unexpectedly; please use DataLastRefreshedDateTimeOffset instead.")] public virtual object DataLastRefreshed { get => _dataLastRefreshed; set { _dataLastRefreshedRaw = Google.Apis.Util.Utilities.SerializeForGoogleFormat(value); _dataLastRefreshed = value; } } /// /// representation of . /// [Newtonsoft.Json.JsonIgnoreAttribute] public virtual System.DateTimeOffset? DataLastRefreshedDateTimeOffset { get => Google.Apis.Util.DiscoveryFormat.ParseGoogleDateTimeToDateTimeOffset(DataLastRefreshedRaw); set => DataLastRefreshedRaw = Google.Apis.Util.DiscoveryFormat.FormatDateTimeOffsetToGoogleDateTime(value); } /// If empty reason is specified, the report is empty for this reason. [Newtonsoft.Json.JsonPropertyAttribute("emptyReason")] public virtual string EmptyReason { get; set; } /// /// Indicates if response to this request is golden or not. Data is golden when the exact same request will not /// produce any new results if asked at a later point in time. /// [Newtonsoft.Json.JsonPropertyAttribute("isDataGolden")] public virtual System.Nullable IsDataGolden { get; set; } /// /// Minimum and maximum values seen over all matching rows. These are both empty when `hideValueRanges` in the /// request is false, or when rowCount is zero. /// [Newtonsoft.Json.JsonPropertyAttribute("maximums")] public virtual System.Collections.Generic.IList Maximums { get; set; } /// /// Minimum and maximum values seen over all matching rows. These are both empty when `hideValueRanges` in the /// request is false, or when rowCount is zero. /// [Newtonsoft.Json.JsonPropertyAttribute("minimums")] public virtual System.Collections.Generic.IList Minimums { get; set; } /// Total number of matching rows for this query. [Newtonsoft.Json.JsonPropertyAttribute("rowCount")] public virtual System.Nullable RowCount { get; set; } /// There's one ReportRow for every unique combination of dimensions. [Newtonsoft.Json.JsonPropertyAttribute("rows")] public virtual System.Collections.Generic.IList Rows { get; set; } /// /// If the results are [sampled](https://support.google.com/analytics/answer/2637192), this returns the total /// number of samples read, one entry per date range. If the results are not sampled this field will not be /// defined. See [developer guide](/analytics/devguides/reporting/core/v4/basics#sampling) for details. /// [Newtonsoft.Json.JsonPropertyAttribute("samplesReadCounts")] public virtual System.Collections.Generic.IList> SamplesReadCounts { get; set; } /// /// If the results are [sampled](https://support.google.com/analytics/answer/2637192), this returns the total /// number of samples present, one entry per date range. If the results are not sampled this field will not be /// defined. See [developer guide](/analytics/devguides/reporting/core/v4/basics#sampling) for details. /// [Newtonsoft.Json.JsonPropertyAttribute("samplingSpaceSizes")] public virtual System.Collections.Generic.IList> SamplingSpaceSizes { get; set; } /// /// For each requested date range, for the set of all rows that match the query, every requested value format /// gets a total. The total for a value format is computed by first totaling the metrics mentioned in the value /// format and then evaluating the value format as a scalar expression. E.g., The "totals" for `3 / (ga:sessions /// + 2)` we compute `3 / ((sum of all relevant ga:sessions) + 2)`. Totals are computed before pagination. /// [Newtonsoft.Json.JsonPropertyAttribute("totals")] public virtual System.Collections.Generic.IList Totals { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The main request class which specifies the Reporting API request. public class ReportRequest : Google.Apis.Requests.IDirectResponseSchema { /// /// Cohort group associated with this request. If there is a cohort group in the request the `ga:cohort` /// dimension must be present. Every [ReportRequest](#ReportRequest) within a `batchGet` method must contain the /// same `cohortGroup` definition. /// [Newtonsoft.Json.JsonPropertyAttribute("cohortGroup")] public virtual CohortGroup CohortGroup { get; set; } /// /// Date ranges in the request. The request can have a maximum of 2 date ranges. The response will contain a set /// of metric values for each combination of the dimensions for each date range in the request. So, if there are /// two date ranges, there will be two set of metric values, one for the original date range and one for the /// second date range. The `reportRequest.dateRanges` field should not be specified for cohorts or Lifetime /// value requests. If a date range is not provided, the default date range is (startDate: current date - 7 /// days, endDate: current date - 1 day). Every [ReportRequest](#ReportRequest) within a `batchGet` method must /// contain the same `dateRanges` definition. /// [Newtonsoft.Json.JsonPropertyAttribute("dateRanges")] public virtual System.Collections.Generic.IList DateRanges { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("dimensionFilterClauses")] public virtual System.Collections.Generic.IList DimensionFilterClauses { get; set; } /// The dimensions requested. Requests can have a total of 9 dimensions. [Newtonsoft.Json.JsonPropertyAttribute("dimensions")] public virtual System.Collections.Generic.IList Dimensions { get; set; } /// /// 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). /// [Newtonsoft.Json.JsonPropertyAttribute("filtersExpression")] public virtual string FiltersExpression { get; set; } /// /// If set to true, hides the total of all metrics for all the matching rows, for every date range. The default /// false and will return the totals. /// [Newtonsoft.Json.JsonPropertyAttribute("hideTotals")] public virtual System.Nullable HideTotals { get; set; } /// /// If set to true, hides the minimum and maximum across all matching rows. The default is false and the value /// ranges are returned. /// [Newtonsoft.Json.JsonPropertyAttribute("hideValueRanges")] public virtual System.Nullable HideValueRanges { get; set; } /// /// If set to false, the response does not include rows if all the retrieved metrics are equal to zero. The /// default is false which will exclude these rows. /// [Newtonsoft.Json.JsonPropertyAttribute("includeEmptyRows")] public virtual System.Nullable IncludeEmptyRows { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("metricFilterClauses")] public virtual System.Collections.Generic.IList MetricFilterClauses { get; set; } /// /// The metrics requested. Requests must specify at least one metric. Requests can have a total of 10 metrics. /// [Newtonsoft.Json.JsonPropertyAttribute("metrics")] public virtual System.Collections.Generic.IList Metrics { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("orderBys")] public virtual System.Collections.Generic.IList OrderBys { get; set; } /// /// 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 100,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. /// [Newtonsoft.Json.JsonPropertyAttribute("pageSize")] public virtual System.Nullable PageSize { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("pageToken")] public virtual string PageToken { get; set; } /// The pivot definitions. Requests can have a maximum of 2 pivots. [Newtonsoft.Json.JsonPropertyAttribute("pivots")] public virtual System.Collections.Generic.IList Pivots { get; set; } /// /// 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. /// [Newtonsoft.Json.JsonPropertyAttribute("samplingLevel")] public virtual string SamplingLevel { get; set; } /// /// Segment the data returned for the request. A segment definition helps look at a subset of the segment /// request. A request can contain up to four segments. Every [ReportRequest](#ReportRequest) within a /// `batchGet` method must contain the same `segments` definition. Requests with segments must have the /// `ga:segment` dimension. /// [Newtonsoft.Json.JsonPropertyAttribute("segments")] public virtual System.Collections.Generic.IList Segments { get; set; } /// /// The Analytics [view ID](https://support.google.com/analytics/answer/1009618) from which to retrieve data. /// Every [ReportRequest](#ReportRequest) within a `batchGet` method must contain the same `viewId`. /// [Newtonsoft.Json.JsonPropertyAttribute("viewId")] public virtual string ViewId { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// A row in the report. public class ReportRow : Google.Apis.Requests.IDirectResponseSchema { /// List of requested dimensions. [Newtonsoft.Json.JsonPropertyAttribute("dimensions")] public virtual System.Collections.Generic.IList Dimensions { get; set; } /// List of metrics for each requested DateRange. [Newtonsoft.Json.JsonPropertyAttribute("metrics")] public virtual System.Collections.Generic.IList Metrics { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The resource quota tokens remaining for the property after the request is completed. public class ResourceQuotasRemaining : Google.Apis.Requests.IDirectResponseSchema { /// Daily resource quota remaining remaining. [Newtonsoft.Json.JsonPropertyAttribute("dailyQuotaTokensRemaining")] public virtual System.Nullable DailyQuotaTokensRemaining { get; set; } /// Hourly resource quota tokens remaining. [Newtonsoft.Json.JsonPropertyAttribute("hourlyQuotaTokensRemaining")] public virtual System.Nullable HourlyQuotaTokensRemaining { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } public class ScreenviewData : Google.Apis.Requests.IDirectResponseSchema { /// The application name. [Newtonsoft.Json.JsonPropertyAttribute("appName")] public virtual string AppName { get; set; } /// Mobile manufacturer or branded name. Eg: "Google", "Apple" etc. [Newtonsoft.Json.JsonPropertyAttribute("mobileDeviceBranding")] public virtual string MobileDeviceBranding { get; set; } /// Mobile device model. Eg: "Pixel", "iPhone" etc. [Newtonsoft.Json.JsonPropertyAttribute("mobileDeviceModel")] public virtual string MobileDeviceModel { get; set; } /// The name of the screen. [Newtonsoft.Json.JsonPropertyAttribute("screenName")] public virtual string ScreenName { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The request to fetch User Report from Reporting API `userActivity:get` call. public class SearchUserActivityRequest : Google.Apis.Requests.IDirectResponseSchema { /// /// Set of all activity types being requested. Only acvities matching these types will be returned in the /// response. If empty, all activies will be returned. /// [Newtonsoft.Json.JsonPropertyAttribute("activityTypes")] public virtual System.Collections.Generic.IList ActivityTypes { get; set; } /// /// Date range for which to retrieve the user activity. If a date range is not provided, the default date range /// is (startDate: current date - 7 days, endDate: current date - 1 day). /// [Newtonsoft.Json.JsonPropertyAttribute("dateRange")] public virtual DateRange DateRange { get; set; } /// /// Page size is for paging and specifies the maximum number of returned rows. Page size should be > 0. /// If the value is 0 or if the field isn't specified, the request returns the default of 1000 rows per page. /// [Newtonsoft.Json.JsonPropertyAttribute("pageSize")] public virtual System.Nullable PageSize { get; set; } /// /// 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 [SearchUserActivityRequest](#SearchUserActivityRequest) request. /// [Newtonsoft.Json.JsonPropertyAttribute("pageToken")] public virtual string PageToken { get; set; } /// /// Required. Unique user Id to query for. Every [SearchUserActivityRequest](#SearchUserActivityRequest) must /// contain this field. /// [Newtonsoft.Json.JsonPropertyAttribute("user")] public virtual User User { get; set; } /// /// Required. The Analytics [view ID](https://support.google.com/analytics/answer/1009618) from which to /// retrieve data. Every [SearchUserActivityRequest](#SearchUserActivityRequest) must contain the `viewId`. /// [Newtonsoft.Json.JsonPropertyAttribute("viewId")] public virtual string ViewId { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// The response from `userActivity:get` call. public class SearchUserActivityResponse : Google.Apis.Requests.IDirectResponseSchema { /// /// This token should be passed to [SearchUserActivityRequest](#SearchUserActivityRequest) to retrieve the next /// page. /// [Newtonsoft.Json.JsonPropertyAttribute("nextPageToken")] public virtual string NextPageToken { get; set; } /// /// This field represents the [sampling rate](https://support.google.com/analytics/answer/2637192) for the given /// request and is a number between 0.0 to 1.0. See [developer /// guide](/analytics/devguides/reporting/core/v4/basics#sampling) for details. /// [Newtonsoft.Json.JsonPropertyAttribute("sampleRate")] public virtual System.Nullable SampleRate { get; set; } /// Each record represents a session (device details, duration, etc). [Newtonsoft.Json.JsonPropertyAttribute("sessions")] public virtual System.Collections.Generic.IList Sessions { get; set; } /// Total rows returned by this query (across different pages). [Newtonsoft.Json.JsonPropertyAttribute("totalRows")] public virtual System.Nullable TotalRows { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// The segment definition, if the report needs to be segmented. A Segment is a subset of the Analytics data. For /// example, of the entire set of users, one Segment might be users from a particular country or city. /// public class Segment : Google.Apis.Requests.IDirectResponseSchema { /// A dynamic segment definition in the request. [Newtonsoft.Json.JsonPropertyAttribute("dynamicSegment")] public virtual DynamicSegment DynamicSegment { get; set; } /// The segment ID of a built-in or custom segment, for example `gaid::-3`. [Newtonsoft.Json.JsonPropertyAttribute("segmentId")] public virtual string SegmentId { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// SegmentDefinition defines the segment to be a set of SegmentFilters which are combined together with a logical /// `AND` operation. /// public class SegmentDefinition : Google.Apis.Requests.IDirectResponseSchema { /// /// A segment is defined by a set of segment filters which are combined together with a logical `AND` operation. /// [Newtonsoft.Json.JsonPropertyAttribute("segmentFilters")] public virtual System.Collections.Generic.IList SegmentFilters { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Dimension filter specifies the filtering options on a dimension. public class SegmentDimensionFilter : Google.Apis.Requests.IDirectResponseSchema { /// Should the match be case sensitive, ignored for `IN_LIST` operator. [Newtonsoft.Json.JsonPropertyAttribute("caseSensitive")] public virtual System.Nullable CaseSensitive { get; set; } /// Name of the dimension for which the filter is being applied. [Newtonsoft.Json.JsonPropertyAttribute("dimensionName")] public virtual string DimensionName { get; set; } /// The list of expressions, only the first element is used for all operators [Newtonsoft.Json.JsonPropertyAttribute("expressions")] public virtual System.Collections.Generic.IList Expressions { get; set; } /// Maximum comparison values for `BETWEEN` match type. [Newtonsoft.Json.JsonPropertyAttribute("maxComparisonValue")] public virtual string MaxComparisonValue { get; set; } /// Minimum comparison values for `BETWEEN` match type. [Newtonsoft.Json.JsonPropertyAttribute("minComparisonValue")] public virtual string MinComparisonValue { get; set; } /// The operator to use to match the dimension with the expressions. [Newtonsoft.Json.JsonPropertyAttribute("operator")] public virtual string Operator__ { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// SegmentFilter defines the segment to be either a simple or a sequence segment. A simple segment condition /// contains dimension and metric conditions to select the sessions or users. A sequence segment condition can be /// used to select users or sessions based on sequential conditions. /// public class SegmentFilter : Google.Apis.Requests.IDirectResponseSchema { /// /// If true, match the complement of simple or sequence segment. For example, to match all visits not from "New /// York", we can define the segment as follows: "sessionSegment": { "segmentFilters": [{ "simpleSegment" :{ /// "orFiltersForSegment": [{ "segmentFilterClauses":[{ "dimensionFilter": { "dimensionName": "ga:city", /// "expressions": ["New York"] } }] }] }, "not": "True" }] }, /// [Newtonsoft.Json.JsonPropertyAttribute("not")] public virtual System.Nullable Not { get; set; } /// /// Sequence conditions consist of one or more steps, where each step is defined by one or more dimension/metric /// conditions. Multiple steps can be combined with special sequence operators. /// [Newtonsoft.Json.JsonPropertyAttribute("sequenceSegment")] public virtual SequenceSegment SequenceSegment { get; set; } /// /// A Simple segment conditions consist of one or more dimension/metric conditions that can be combined /// [Newtonsoft.Json.JsonPropertyAttribute("simpleSegment")] public virtual SimpleSegment SimpleSegment { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// Filter Clause to be used in a segment definition, can be wither a metric or a dimension filter. /// public class SegmentFilterClause : Google.Apis.Requests.IDirectResponseSchema { /// Dimension Filter for the segment definition. [Newtonsoft.Json.JsonPropertyAttribute("dimensionFilter")] public virtual SegmentDimensionFilter DimensionFilter { get; set; } /// Metric Filter for the segment definition. [Newtonsoft.Json.JsonPropertyAttribute("metricFilter")] public virtual SegmentMetricFilter MetricFilter { get; set; } /// Matches the complement (`!`) of the filter. [Newtonsoft.Json.JsonPropertyAttribute("not")] public virtual System.Nullable Not { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Metric filter to be used in a segment filter clause. public class SegmentMetricFilter : Google.Apis.Requests.IDirectResponseSchema { /// /// The value to compare against. If the operator is `BETWEEN`, this value is treated as minimum comparison /// value. /// [Newtonsoft.Json.JsonPropertyAttribute("comparisonValue")] public virtual string ComparisonValue { get; set; } /// Max comparison value is only used for `BETWEEN` operator. [Newtonsoft.Json.JsonPropertyAttribute("maxComparisonValue")] public virtual string MaxComparisonValue { get; set; } /// The metric that will be filtered on. A `metricFilter` must contain a metric name. [Newtonsoft.Json.JsonPropertyAttribute("metricName")] public virtual string MetricName { get; set; } /// Specifies is the operation to perform to compare the metric. The default is `EQUAL`. [Newtonsoft.Json.JsonPropertyAttribute("operator")] public virtual string Operator__ { get; set; } /// /// Scope for a metric defines the level at which that metric is defined. The specified metric scope must be /// equal to or greater than its primary scope as defined in the data model. The primary scope is defined by if /// the segment is selecting users or sessions. /// [Newtonsoft.Json.JsonPropertyAttribute("scope")] public virtual string Scope { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// A segment sequence definition. public class SegmentSequenceStep : Google.Apis.Requests.IDirectResponseSchema { /// Specifies if the step immediately precedes or can be any time before the next step. [Newtonsoft.Json.JsonPropertyAttribute("matchType")] public virtual string MatchType { get; set; } /// /// A sequence is specified with a list of Or grouped filters which are combined with `AND` operator. /// [Newtonsoft.Json.JsonPropertyAttribute("orFiltersForSegment")] public virtual System.Collections.Generic.IList OrFiltersForSegment { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// Sequence conditions consist of one or more steps, where each step is defined by one or more dimension/metric /// conditions. Multiple steps can be combined with special sequence operators. /// public class SequenceSegment : Google.Apis.Requests.IDirectResponseSchema { /// If set, first step condition must match the first hit of the visitor (in the date range). [Newtonsoft.Json.JsonPropertyAttribute("firstStepShouldMatchFirstHit")] public virtual System.Nullable FirstStepShouldMatchFirstHit { get; set; } /// The list of steps in the sequence. [Newtonsoft.Json.JsonPropertyAttribute("segmentSequenceSteps")] public virtual System.Collections.Generic.IList SegmentSequenceSteps { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// A Simple segment conditions consist of one or more dimension/metric conditions that can be combined. /// public class SimpleSegment : Google.Apis.Requests.IDirectResponseSchema { /// A list of segment filters groups which are combined with logical `AND` operator. [Newtonsoft.Json.JsonPropertyAttribute("orFiltersForSegment")] public virtual System.Collections.Generic.IList OrFiltersForSegment { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Represents details collected when the visitor performs a transaction on the page. public class TransactionData : Google.Apis.Requests.IDirectResponseSchema { /// /// The transaction ID, supplied by the e-commerce tracking method, for the purchase in the shopping cart. /// [Newtonsoft.Json.JsonPropertyAttribute("transactionId")] public virtual string TransactionId { get; set; } /// The total sale revenue (excluding shipping and tax) of the transaction. [Newtonsoft.Json.JsonPropertyAttribute("transactionRevenue")] public virtual System.Nullable TransactionRevenue { get; set; } /// Total cost of shipping. [Newtonsoft.Json.JsonPropertyAttribute("transactionShipping")] public virtual System.Nullable TransactionShipping { get; set; } /// Total tax for the transaction. [Newtonsoft.Json.JsonPropertyAttribute("transactionTax")] public virtual System.Nullable TransactionTax { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// Contains information to identify a particular user uniquely. public class User : Google.Apis.Requests.IDirectResponseSchema { /// Type of the user in the request. The field `userId` is associated with this type. [Newtonsoft.Json.JsonPropertyAttribute("type")] public virtual string Type { get; set; } /// Unique Id of the user for which the data is being requested. [Newtonsoft.Json.JsonPropertyAttribute("userId")] public virtual string UserId { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } /// /// This represents a user session performed on a specific device at a certain time over a period of time. /// public class UserActivitySession : Google.Apis.Requests.IDirectResponseSchema { /// Represents a detailed view into each of the activity in this session. [Newtonsoft.Json.JsonPropertyAttribute("activities")] public virtual System.Collections.Generic.IList Activities { get; set; } /// /// The data source of a hit. By default, hits sent from analytics.js are reported as "web" and hits sent from /// the mobile SDKs are reported as "app". These values can be overridden in the Measurement Protocol. /// [Newtonsoft.Json.JsonPropertyAttribute("dataSource")] public virtual string DataSource { get; set; } /// The type of device used: "mobile", "tablet" etc. [Newtonsoft.Json.JsonPropertyAttribute("deviceCategory")] public virtual string DeviceCategory { get; set; } /// Platform on which the activity happened: "android", "ios" etc. [Newtonsoft.Json.JsonPropertyAttribute("platform")] public virtual string Platform { get; set; } /// Date of this session in ISO-8601 format. [Newtonsoft.Json.JsonPropertyAttribute("sessionDate")] public virtual string SessionDate { get; set; } /// Unique ID of the session. [Newtonsoft.Json.JsonPropertyAttribute("sessionId")] public virtual string SessionId { get; set; } /// The ETag of the item. public virtual string ETag { get; set; } } }