{
  "ab_internal": {
    "isEnterprise": false,
    "ql": 400,
    "requireVersionIncrementsInPullRequests": true,
    "sl": 300
  },
  "allowedHosts": {
    "hosts": [
      "oauth2.googleapis.com",
      "www.googleapis.com",
      "analyticsdata.googleapis.com"
    ]
  },
  "connectorBuildOptions": {
    "baseImage": "docker.io/airbyte/source-declarative-manifest:7.23.8@sha256:58d3593d8e816d4a346570570d5a42bb78e41de344f8c74c2a5c225acdc4c4d1"
  },
  "connectorTestSuitesOptions": [
    {
      "suite": "unitTests"
    },
    {
      "suite": "acceptanceTests",
      "testSecrets": [
        {
          "fileName": "config.json",
          "name": "SECRET_SOURCE-GOOGLE-ANALYTICS-DATA-API__CREDS",
          "secretStore": {
            "alias": "airbyte-connector-testing-secret-store",
            "type": "GSM"
          }
        }
      ]
    }
  ],
  "custom": false,
  "dockerImageTag": "2.9.46-preview.c170a91",
  "dockerRepository": "airbyte/source-google-analytics-data-api",
  "documentationUrl": "https://docs.airbyte.com/integrations/sources/google-analytics-data-api",
  "externalDocumentationUrls": [
    {
      "title": "Data API changelog",
      "type": "api_release_history",
      "url": "https://developers.google.com/analytics/devguides/reporting/data/v1/changelog"
    }
  ],
  "generated": {
    "git": {
      "commit_author": "Devin AI",
      "commit_author_email": "158243242+devin-ai-integration[bot]@users.noreply.github.com",
      "commit_sha": "1df175ce6e96f0a82844c7510c6b13b3ea3d2202",
      "commit_timestamp": "2026-08-03T18:56:12+00:00"
    },
    "sbomUrl": "https://connectors.airbyte.com/files/sbom/airbyte/source-google-analytics-data-api/2.9.46-preview.c170a91.spdx.json",
    "source_file_info": {
      "metadata_bucket_name": "prod-airbyte-cloud-connector-metadata-service",
      "metadata_file_path": "metadata/airbyte/source-google-analytics-data-api/2.9.46-preview.c170a91/metadata.yaml",
      "metadata_last_modified": "2026-08-04T11:48:50.287671+00:00",
      "registry_entry_generated_at": "2026-08-04T11:48:50.287671+00:00"
    }
  },
  "githubIssueLabel": "source-google-analytics-data-api",
  "icon": "google-analytics.svg",
  "iconUrl": "https://connectors.airbyte.com/files/metadata/airbyte/source-google-analytics-data-api/latest/icon.svg",
  "language": "manifest-only",
  "license": "Elv2",
  "maxSecondsBetweenMessages": 86400,
  "name": "Google Analytics 4 (GA4)",
  "packageInfo": {},
  "public": true,
  "releaseStage": "generally_available",
  "releases": {
    "breakingChanges": {
      "2.0.0": {
        "message": "Version 2.0.0 introduces changes to stream names for those syncing more than one Google Analytics 4 property. It allows streams from all properties to sync successfully. Please upgrade the connector to enable this additional functionality.",
        "migrationDocumentationUrl": "https://docs.airbyte.com/integrations/sources/google-analytics-data-api-migrations#2.0.0",
        "upgradeDeadline": "2023-10-16"
      }
    },
    "migrationDocumentationUrl": "https://docs.airbyte.com/integrations/sources/google-analytics-data-api-migrations",
    "rolloutConfiguration": {
      "advanceDelayMinutes": 10,
      "enableProgressiveRollout": false,
      "initialPercentage": 0,
      "maxPercentage": 50
    }
  },
  "remoteRegistries": {
    "pypi": {
      "enabled": false,
      "packageName": "airbyte-source-google-analytics-data-api"
    }
  },
  "resourceRequirements": {
    "jobSpecific": [
      {
        "jobType": "check_connection",
        "resourceRequirements": {
          "memory_limit": "1600Mi",
          "memory_request": "1600Mi"
        }
      }
    ]
  },
  "sourceDefinitionId": "3cc2eafd-84aa-4dca-93af-322d9dfeec1a",
  "sourceType": "api",
  "spec": {
    "advanced_auth": {
      "auth_flow_type": "oauth2.0",
      "oauth_config_specification": {
        "complete_oauth_output_specification": {
          "properties": {
            "access_token": {
              "path_in_connector_config": [
                "credentials",
                "access_token"
              ],
              "type": "string"
            },
            "refresh_token": {
              "path_in_connector_config": [
                "credentials",
                "refresh_token"
              ],
              "type": "string"
            }
          },
          "type": "object"
        },
        "complete_oauth_server_input_specification": {
          "properties": {
            "client_id": {
              "type": "string"
            },
            "client_secret": {
              "type": "string"
            }
          },
          "type": "object"
        },
        "complete_oauth_server_output_specification": {
          "properties": {
            "client_id": {
              "path_in_connector_config": [
                "credentials",
                "client_id"
              ],
              "type": "string"
            },
            "client_secret": {
              "path_in_connector_config": [
                "credentials",
                "client_secret"
              ],
              "type": "string"
            }
          },
          "type": "object"
        },
        "oauth_connector_input_specification": {
          "access_token_url": "https://oauth2.googleapis.com/token?{{client_id_param}}&{{client_secret_param}}&{{auth_code_param}}&{{redirect_uri_param}}&grant_type=authorization_code",
          "consent_url": "https://accounts.google.com/o/oauth2/v2/auth?{{client_id_param}}&{{redirect_uri_param}}&response_type=code&{{scopes_param}}&access_type=offline&{{state_param}}&include_granted_scopes=true&prompt=consent",
          "extract_output": [
            "refresh_token",
            "access_token"
          ],
          "scopes": [
            {
              "scope": "https://www.googleapis.com/auth/analytics.readonly"
            }
          ],
          "scopes_join_strategy": "space"
        }
      },
      "predicate_key": [
        "credentials",
        "auth_type"
      ],
      "predicate_value": "Client"
    },
    "connectionSpecification": {
      "$schema": "https://json-schema.org/draft-07/schema#",
      "additionalProperties": true,
      "properties": {
        "convert_conversions_event": {
          "default": false,
          "description": "Enables conversion of `conversions:*` event metrics from integers to floats. This is beneficial for preventing data rounding when the API returns float values for any `conversions:*` fields.",
          "order": 8,
          "title": "Convert `conversions:*` Metrics to Float",
          "type": "boolean"
        },
        "credentials": {
          "description": "Credentials for the service",
          "oneOf": [
            {
              "properties": {
                "access_token": {
                  "airbyte_secret": true,
                  "description": "Access Token for making authenticated requests.",
                  "order": 4,
                  "title": "Access Token",
                  "type": "string"
                },
                "auth_type": {
                  "const": "Client",
                  "order": 0,
                  "type": "string"
                },
                "client_id": {
                  "description": "The Client ID of your Google Analytics developer application.",
                  "order": 1,
                  "title": "Client ID",
                  "type": "string"
                },
                "client_secret": {
                  "airbyte_secret": true,
                  "description": "The Client Secret of your Google Analytics developer application.",
                  "order": 2,
                  "title": "Client Secret",
                  "type": "string"
                },
                "refresh_token": {
                  "airbyte_secret": true,
                  "description": "The token for obtaining a new access token.",
                  "order": 3,
                  "title": "Refresh Token",
                  "type": "string"
                }
              },
              "required": [
                "client_id",
                "client_secret",
                "refresh_token"
              ],
              "title": "Authenticate via Google (Oauth)",
              "type": "object"
            },
            {
              "properties": {
                "auth_type": {
                  "const": "Service",
                  "order": 0,
                  "type": "string"
                },
                "credentials_json": {
                  "airbyte_secret": true,
                  "description": "The JSON key linked to the service account used for authorization. For steps on obtaining this key, refer to <a href=\"https://docs.airbyte.com/integrations/sources/google-analytics-data-api/#setup-guide\">the setup guide</a>.",
                  "examples": [
                    "{ \"type\": \"service_account\", \"project_id\": YOUR_PROJECT_ID, \"private_key_id\": YOUR_PRIVATE_KEY, ... }"
                  ],
                  "order": 1,
                  "title": "Service Account JSON Key",
                  "type": "string"
                }
              },
              "required": [
                "credentials_json"
              ],
              "title": "Service Account Key Authentication",
              "type": "object"
            }
          ],
          "order": 0,
          "title": "Credentials",
          "type": "object"
        },
        "custom_reports_array": {
          "description": "You can add your Custom Analytics report by creating one.",
          "items": {
            "properties": {
              "cohortSpec": {
                "description": "Cohort reports creates a time series of user retention for the cohort.",
                "oneOf": [
                  {
                    "properties": {
                      "enabled": {
                        "const": "false",
                        "type": "string"
                      }
                    },
                    "title": "Disabled",
                    "type": "object"
                  },
                  {
                    "properties": {
                      "cohortReportSettings": {
                        "description": "Optional settings for a cohort report.",
                        "properties": {
                          "accumulate": {
                            "always_show": true,
                            "description": "If true, accumulates the result from first touch day to the end day",
                            "title": "Accumulate",
                            "type": "boolean"
                          }
                        },
                        "title": "Cohort Report Settings",
                        "type": "object"
                      },
                      "cohorts": {
                        "always_show": true,
                        "items": {
                          "properties": {
                            "dateRange": {
                              "properties": {
                                "endDate": {
                                  "examples": [
                                    "2021-01-01"
                                  ],
                                  "format": "date",
                                  "order": 3,
                                  "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
                                  "pattern_descriptor": "YYYY-MM-DD",
                                  "title": "End Date",
                                  "type": "string"
                                },
                                "startDate": {
                                  "examples": [
                                    "2021-01-01"
                                  ],
                                  "format": "date",
                                  "order": 2,
                                  "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
                                  "pattern_descriptor": "YYYY-MM-DD",
                                  "title": "Start Date",
                                  "type": "string"
                                }
                              },
                              "required": [
                                "startDate",
                                "endDate"
                              ],
                              "type": "object"
                            },
                            "dimension": {
                              "description": "Dimension used by the cohort. Required and only supports `firstSessionDate`",
                              "enum": [
                                "firstSessionDate"
                              ],
                              "order": 1,
                              "title": "Dimension",
                              "type": "string"
                            },
                            "name": {
                              "always_show": true,
                              "description": "Assigns a name to this cohort. If not set, cohorts are named by their zero based index cohort_0, cohort_1, etc.",
                              "order": 0,
                              "pattern": "^(?!(cohort_|RESERVED_)).*$",
                              "title": "Name",
                              "type": "string"
                            }
                          },
                          "required": [
                            "dimension",
                            "dateRange"
                          ],
                          "title": "Cohorts",
                          "type": "object"
                        },
                        "name": "Cohorts",
                        "order": 0,
                        "type": "array"
                      },
                      "cohortsRange": {
                        "order": 1,
                        "properties": {
                          "endOffset": {
                            "description": "Specifies the end date of the extended reporting date range for a cohort report.",
                            "minimum": 0,
                            "order": 2,
                            "title": "End Offset",
                            "type": "integer"
                          },
                          "granularity": {
                            "description": "The granularity used to interpret the startOffset and endOffset for the extended reporting date range for a cohort report.",
                            "enum": [
                              "GRANULARITY_UNSPECIFIED",
                              "DAILY",
                              "WEEKLY",
                              "MONTHLY"
                            ],
                            "order": 0,
                            "title": "Granularity",
                            "type": "string"
                          },
                          "startOffset": {
                            "description": "Specifies the start date of the extended reporting date range for a cohort report.",
                            "minimum": 0,
                            "order": 1,
                            "title": "Start Offset",
                            "type": "integer"
                          }
                        },
                        "required": [
                          "granularity",
                          "endOffset"
                        ],
                        "type": "object"
                      },
                      "enabled": {
                        "const": "true",
                        "type": "string"
                      }
                    },
                    "title": "Enabled",
                    "type": "object"
                  }
                ],
                "order": 5,
                "title": "Cohort Reports",
                "type": "object"
              },
              "dimensionFilter": {
                "description": "Dimensions filter",
                "oneOf": [
                  {
                    "description": "The FilterExpressions in andGroup have an AND relationship.",
                    "properties": {
                      "expressions": {
                        "items": {
                          "properties": {
                            "field_name": {
                              "order": 1,
                              "title": "fieldName",
                              "type": "string"
                            },
                            "filter": {
                              "oneOf": [
                                {
                                  "properties": {
                                    "caseSensitive": {
                                      "order": 2,
                                      "tittle": "caseSensitive",
                                      "type": "boolean"
                                    },
                                    "filter_name": {
                                      "const": "stringFilter",
                                      "type": "string"
                                    },
                                    "matchType": {
                                      "items": {
                                        "enum": [
                                          "MATCH_TYPE_UNSPECIFIED",
                                          "EXACT",
                                          "BEGINS_WITH",
                                          "ENDS_WITH",
                                          "CONTAINS",
                                          "FULL_REGEXP",
                                          "PARTIAL_REGEXP"
                                        ],
                                        "title": "ValidEnums"
                                      },
                                      "order": 1,
                                      "title": "matchType",
                                      "type": "array"
                                    },
                                    "value": {
                                      "order": 0,
                                      "tittle": "value",
                                      "type": "string"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "value"
                                  ],
                                  "title": "stringFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "caseSensitive": {
                                      "order": 1,
                                      "tittle": "caseSensitive",
                                      "type": "boolean"
                                    },
                                    "filter_name": {
                                      "const": "inListFilter",
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "minItems": 1,
                                      "order": 0,
                                      "tittle": "values",
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "values"
                                  ],
                                  "title": "inListFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "filter_name": {
                                      "const": "numericFilter",
                                      "type": "string"
                                    },
                                    "operation": {
                                      "items": {
                                        "enum": [
                                          "OPERATION_UNSPECIFIED",
                                          "EQUAL",
                                          "LESS_THAN",
                                          "LESS_THAN_OR_EQUAL",
                                          "GREATER_THAN",
                                          "GREATER_THAN_OR_EQUAL"
                                        ],
                                        "title": "ValidEnums"
                                      },
                                      "order": 1,
                                      "title": "operation",
                                      "type": "array"
                                    },
                                    "value": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 0,
                                      "tittle": "value",
                                      "type": "object"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "operation",
                                    "value"
                                  ],
                                  "title": "numericFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "filter_name": {
                                      "const": "betweenFilter",
                                      "type": "string"
                                    },
                                    "fromValue": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 0,
                                      "tittle": "fromValue",
                                      "type": "object"
                                    },
                                    "toValue": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 1,
                                      "tittle": "toValue",
                                      "type": "object"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "fromValue",
                                    "toValue"
                                  ],
                                  "title": "betweenFilter",
                                  "type": "object"
                                }
                              ],
                              "order": 2,
                              "title": "filter",
                              "type": "object"
                            }
                          },
                          "required": [
                            "field_name",
                            "filter"
                          ],
                          "title": "Expression",
                          "type": "object"
                        },
                        "order": 1,
                        "title": "Expressions",
                        "type": "array"
                      },
                      "filter_type": {
                        "const": "andGroup",
                        "order": 0,
                        "type": "string"
                      }
                    },
                    "required": [
                      "filter_type",
                      "expressions"
                    ],
                    "title": "andGroup",
                    "type": "object"
                  },
                  {
                    "description": "The FilterExpressions in orGroup have an OR relationship.",
                    "properties": {
                      "expressions": {
                        "items": {
                          "properties": {
                            "field_name": {
                              "order": 1,
                              "title": "fieldName",
                              "type": "string"
                            },
                            "filter": {
                              "oneOf": [
                                {
                                  "properties": {
                                    "caseSensitive": {
                                      "order": 2,
                                      "tittle": "caseSensitive",
                                      "type": "boolean"
                                    },
                                    "filter_name": {
                                      "const": "stringFilter",
                                      "type": "string"
                                    },
                                    "matchType": {
                                      "items": {
                                        "enum": [
                                          "MATCH_TYPE_UNSPECIFIED",
                                          "EXACT",
                                          "BEGINS_WITH",
                                          "ENDS_WITH",
                                          "CONTAINS",
                                          "FULL_REGEXP",
                                          "PARTIAL_REGEXP"
                                        ],
                                        "title": "ValidEnums"
                                      },
                                      "order": 1,
                                      "title": "matchType",
                                      "type": "array"
                                    },
                                    "value": {
                                      "order": 0,
                                      "tittle": "value",
                                      "type": "string"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "value"
                                  ],
                                  "title": "stringFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "caseSensitive": {
                                      "order": 1,
                                      "tittle": "caseSensitive",
                                      "type": "boolean"
                                    },
                                    "filter_name": {
                                      "const": "inListFilter",
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "minItems": 1,
                                      "order": 0,
                                      "tittle": "values",
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "values"
                                  ],
                                  "title": "inListFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "filter_name": {
                                      "const": "numericFilter",
                                      "type": "string"
                                    },
                                    "operation": {
                                      "items": {
                                        "enum": [
                                          "OPERATION_UNSPECIFIED",
                                          "EQUAL",
                                          "LESS_THAN",
                                          "LESS_THAN_OR_EQUAL",
                                          "GREATER_THAN",
                                          "GREATER_THAN_OR_EQUAL"
                                        ],
                                        "title": "ValidEnums"
                                      },
                                      "order": 1,
                                      "title": "operation",
                                      "type": "array"
                                    },
                                    "value": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 0,
                                      "tittle": "value",
                                      "type": "object"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "operation",
                                    "value"
                                  ],
                                  "title": "numericFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "filter_name": {
                                      "const": "betweenFilter",
                                      "type": "string"
                                    },
                                    "fromValue": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 0,
                                      "tittle": "fromValue",
                                      "type": "object"
                                    },
                                    "toValue": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 1,
                                      "tittle": "toValue",
                                      "type": "object"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "fromValue",
                                    "toValue"
                                  ],
                                  "title": "betweenFilter",
                                  "type": "object"
                                }
                              ],
                              "order": 2,
                              "title": "filter",
                              "type": "object"
                            }
                          },
                          "required": [
                            "field_name",
                            "filter"
                          ],
                          "title": "Expression",
                          "type": "object"
                        },
                        "order": 1,
                        "title": "Expressions",
                        "type": "array"
                      },
                      "filter_type": {
                        "const": "orGroup",
                        "order": 0,
                        "type": "string"
                      }
                    },
                    "required": [
                      "filter_type",
                      "expressions"
                    ],
                    "title": "orGroup",
                    "type": "object"
                  },
                  {
                    "description": "The FilterExpression is NOT of notExpression.",
                    "properties": {
                      "expression": {
                        "properties": {
                          "field_name": {
                            "order": 1,
                            "title": "fieldName",
                            "type": "string"
                          },
                          "filter": {
                            "oneOf": [
                              {
                                "properties": {
                                  "caseSensitive": {
                                    "order": 2,
                                    "tittle": "caseSensitive",
                                    "type": "boolean"
                                  },
                                  "filter_name": {
                                    "const": "stringFilter",
                                    "type": "string"
                                  },
                                  "matchType": {
                                    "items": {
                                      "enum": [
                                        "MATCH_TYPE_UNSPECIFIED",
                                        "EXACT",
                                        "BEGINS_WITH",
                                        "ENDS_WITH",
                                        "CONTAINS",
                                        "FULL_REGEXP",
                                        "PARTIAL_REGEXP"
                                      ],
                                      "title": "ValidEnums"
                                    },
                                    "order": 1,
                                    "title": "matchType",
                                    "type": "array"
                                  },
                                  "value": {
                                    "order": 0,
                                    "tittle": "value",
                                    "type": "string"
                                  }
                                },
                                "required": [
                                  "filter_name",
                                  "value"
                                ],
                                "title": "stringFilter",
                                "type": "object"
                              },
                              {
                                "properties": {
                                  "caseSensitive": {
                                    "order": 1,
                                    "tittle": "caseSensitive",
                                    "type": "boolean"
                                  },
                                  "filter_name": {
                                    "const": "inListFilter",
                                    "type": "string"
                                  },
                                  "values": {
                                    "items": {
                                      "type": "string"
                                    },
                                    "minItems": 1,
                                    "order": 0,
                                    "tittle": "values",
                                    "type": "array"
                                  }
                                },
                                "required": [
                                  "filter_name",
                                  "values"
                                ],
                                "title": "inListFilter",
                                "type": "object"
                              },
                              {
                                "properties": {
                                  "filter_name": {
                                    "const": "numericFilter",
                                    "type": "string"
                                  },
                                  "operation": {
                                    "items": {
                                      "enum": [
                                        "OPERATION_UNSPECIFIED",
                                        "EQUAL",
                                        "LESS_THAN",
                                        "LESS_THAN_OR_EQUAL",
                                        "GREATER_THAN",
                                        "GREATER_THAN_OR_EQUAL"
                                      ],
                                      "title": "ValidEnums"
                                    },
                                    "order": 1,
                                    "title": "operation",
                                    "type": "array"
                                  },
                                  "value": {
                                    "oneOf": [
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "string"
                                          },
                                          "value_type": {
                                            "const": "int64Value",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "int64Value",
                                        "type": "object"
                                      },
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "number"
                                          },
                                          "value_type": {
                                            "const": "doubleValue",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "doubleValue",
                                        "type": "object"
                                      }
                                    ],
                                    "order": 0,
                                    "tittle": "value",
                                    "type": "object"
                                  }
                                },
                                "required": [
                                  "filter_name",
                                  "operation",
                                  "value"
                                ],
                                "title": "numericFilter",
                                "type": "object"
                              },
                              {
                                "properties": {
                                  "filter_name": {
                                    "const": "betweenFilter",
                                    "type": "string"
                                  },
                                  "fromValue": {
                                    "oneOf": [
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "string"
                                          },
                                          "value_type": {
                                            "const": "int64Value",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "int64Value",
                                        "type": "object"
                                      },
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "number"
                                          },
                                          "value_type": {
                                            "const": "doubleValue",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "doubleValue",
                                        "type": "object"
                                      }
                                    ],
                                    "order": 0,
                                    "tittle": "fromValue",
                                    "type": "object"
                                  },
                                  "toValue": {
                                    "oneOf": [
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "string"
                                          },
                                          "value_type": {
                                            "const": "int64Value",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "int64Value",
                                        "type": "object"
                                      },
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "number"
                                          },
                                          "value_type": {
                                            "const": "doubleValue",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "doubleValue",
                                        "type": "object"
                                      }
                                    ],
                                    "order": 1,
                                    "tittle": "toValue",
                                    "type": "object"
                                  }
                                },
                                "required": [
                                  "filter_name",
                                  "fromValue",
                                  "toValue"
                                ],
                                "title": "betweenFilter",
                                "type": "object"
                              }
                            ],
                            "order": 2,
                            "title": "filter",
                            "type": "object"
                          }
                        },
                        "required": [
                          "field_name",
                          "filter"
                        ],
                        "title": "Expression",
                        "type": "object"
                      },
                      "filter_type": {
                        "const": "notExpression",
                        "order": 0,
                        "type": "string"
                      }
                    },
                    "title": "notExpression",
                    "type": "object"
                  },
                  {
                    "description": "A primitive filter. In the same FilterExpression, all of the filter's field names need to be either all dimensions.",
                    "properties": {
                      "field_name": {
                        "order": 1,
                        "title": "fieldName",
                        "type": "string"
                      },
                      "filter": {
                        "oneOf": [
                          {
                            "properties": {
                              "caseSensitive": {
                                "order": 2,
                                "tittle": "caseSensitive",
                                "type": "boolean"
                              },
                              "filter_name": {
                                "const": "stringFilter",
                                "type": "string"
                              },
                              "matchType": {
                                "items": {
                                  "enum": [
                                    "MATCH_TYPE_UNSPECIFIED",
                                    "EXACT",
                                    "BEGINS_WITH",
                                    "ENDS_WITH",
                                    "CONTAINS",
                                    "FULL_REGEXP",
                                    "PARTIAL_REGEXP"
                                  ],
                                  "title": "ValidEnums"
                                },
                                "order": 1,
                                "title": "matchType",
                                "type": "array"
                              },
                              "value": {
                                "order": 0,
                                "tittle": "value",
                                "type": "string"
                              }
                            },
                            "required": [
                              "filter_name",
                              "value"
                            ],
                            "title": "stringFilter",
                            "type": "object"
                          },
                          {
                            "properties": {
                              "caseSensitive": {
                                "order": 1,
                                "tittle": "caseSensitive",
                                "type": "boolean"
                              },
                              "filter_name": {
                                "const": "inListFilter",
                                "type": "string"
                              },
                              "values": {
                                "items": {
                                  "type": "string"
                                },
                                "minItems": 1,
                                "order": 0,
                                "tittle": "values",
                                "type": "array"
                              }
                            },
                            "required": [
                              "filter_name",
                              "values"
                            ],
                            "title": "inListFilter",
                            "type": "object"
                          },
                          {
                            "properties": {
                              "filter_name": {
                                "const": "numericFilter",
                                "type": "string"
                              },
                              "operation": {
                                "items": {
                                  "enum": [
                                    "OPERATION_UNSPECIFIED",
                                    "EQUAL",
                                    "LESS_THAN",
                                    "LESS_THAN_OR_EQUAL",
                                    "GREATER_THAN",
                                    "GREATER_THAN_OR_EQUAL"
                                  ],
                                  "title": "ValidEnums"
                                },
                                "order": 1,
                                "title": "operation",
                                "type": "array"
                              },
                              "value": {
                                "oneOf": [
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "string"
                                      },
                                      "value_type": {
                                        "const": "int64Value",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "int64Value",
                                    "type": "object"
                                  },
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "number"
                                      },
                                      "value_type": {
                                        "const": "doubleValue",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "doubleValue",
                                    "type": "object"
                                  }
                                ],
                                "order": 0,
                                "tittle": "value",
                                "type": "object"
                              }
                            },
                            "required": [
                              "filter_name",
                              "operation",
                              "value"
                            ],
                            "title": "numericFilter",
                            "type": "object"
                          },
                          {
                            "properties": {
                              "filter_name": {
                                "const": "betweenFilter",
                                "type": "string"
                              },
                              "fromValue": {
                                "oneOf": [
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "string"
                                      },
                                      "value_type": {
                                        "const": "int64Value",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "int64Value",
                                    "type": "object"
                                  },
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "number"
                                      },
                                      "value_type": {
                                        "const": "doubleValue",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "doubleValue",
                                    "type": "object"
                                  }
                                ],
                                "order": 0,
                                "tittle": "fromValue",
                                "type": "object"
                              },
                              "toValue": {
                                "oneOf": [
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "string"
                                      },
                                      "value_type": {
                                        "const": "int64Value",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "int64Value",
                                    "type": "object"
                                  },
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "number"
                                      },
                                      "value_type": {
                                        "const": "doubleValue",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "doubleValue",
                                    "type": "object"
                                  }
                                ],
                                "order": 1,
                                "tittle": "toValue",
                                "type": "object"
                              }
                            },
                            "required": [
                              "filter_name",
                              "fromValue",
                              "toValue"
                            ],
                            "title": "betweenFilter",
                            "type": "object"
                          }
                        ],
                        "order": 2,
                        "title": "filter",
                        "type": "object"
                      },
                      "filter_type": {
                        "const": "filter",
                        "order": 0,
                        "type": "string"
                      }
                    },
                    "required": [
                      "field_name",
                      "filter"
                    ],
                    "title": "filter",
                    "type": "object"
                  }
                ],
                "order": 3,
                "title": "Dimensions filter",
                "type": "object"
              },
              "dimensions": {
                "description": "A list of dimensions.",
                "items": {
                  "type": "string"
                },
                "minItems": 1,
                "order": 1,
                "title": "Dimensions",
                "type": "array"
              },
              "metricFilter": {
                "description": "Metrics filter",
                "oneOf": [
                  {
                    "description": "The FilterExpressions in andGroup have an AND relationship.",
                    "properties": {
                      "expressions": {
                        "items": {
                          "properties": {
                            "field_name": {
                              "order": 1,
                              "title": "fieldName",
                              "type": "string"
                            },
                            "filter": {
                              "oneOf": [
                                {
                                  "properties": {
                                    "caseSensitive": {
                                      "order": 2,
                                      "tittle": "caseSensitive",
                                      "type": "boolean"
                                    },
                                    "filter_name": {
                                      "const": "stringFilter",
                                      "type": "string"
                                    },
                                    "matchType": {
                                      "items": {
                                        "enum": [
                                          "MATCH_TYPE_UNSPECIFIED",
                                          "EXACT",
                                          "BEGINS_WITH",
                                          "ENDS_WITH",
                                          "CONTAINS",
                                          "FULL_REGEXP",
                                          "PARTIAL_REGEXP"
                                        ],
                                        "title": "ValidEnums"
                                      },
                                      "order": 1,
                                      "title": "matchType",
                                      "type": "array"
                                    },
                                    "value": {
                                      "order": 0,
                                      "tittle": "value",
                                      "type": "string"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "value"
                                  ],
                                  "title": "stringFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "caseSensitive": {
                                      "order": 1,
                                      "tittle": "caseSensitive",
                                      "type": "boolean"
                                    },
                                    "filter_name": {
                                      "const": "inListFilter",
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "minItems": 1,
                                      "order": 0,
                                      "tittle": "values",
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "values"
                                  ],
                                  "title": "inListFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "filter_name": {
                                      "const": "numericFilter",
                                      "type": "string"
                                    },
                                    "operation": {
                                      "items": {
                                        "enum": [
                                          "OPERATION_UNSPECIFIED",
                                          "EQUAL",
                                          "LESS_THAN",
                                          "LESS_THAN_OR_EQUAL",
                                          "GREATER_THAN",
                                          "GREATER_THAN_OR_EQUAL"
                                        ],
                                        "title": "ValidEnums"
                                      },
                                      "order": 1,
                                      "title": "operation",
                                      "type": "array"
                                    },
                                    "value": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 0,
                                      "tittle": "value",
                                      "type": "object"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "operation",
                                    "value"
                                  ],
                                  "title": "numericFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "filter_name": {
                                      "const": "betweenFilter",
                                      "type": "string"
                                    },
                                    "fromValue": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 0,
                                      "tittle": "fromValue",
                                      "type": "object"
                                    },
                                    "toValue": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 1,
                                      "tittle": "toValue",
                                      "type": "object"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "fromValue",
                                    "toValue"
                                  ],
                                  "title": "betweenFilter",
                                  "type": "object"
                                }
                              ],
                              "order": 2,
                              "title": "filter",
                              "type": "object"
                            }
                          },
                          "required": [
                            "field_name",
                            "filter"
                          ],
                          "title": "Expression",
                          "type": "object"
                        },
                        "order": 1,
                        "title": "Expressions",
                        "type": "array"
                      },
                      "filter_type": {
                        "const": "andGroup",
                        "order": 0,
                        "type": "string"
                      }
                    },
                    "required": [
                      "filter_type",
                      "expressions"
                    ],
                    "title": "andGroup",
                    "type": "object"
                  },
                  {
                    "description": "The FilterExpressions in orGroup have an OR relationship.",
                    "properties": {
                      "expressions": {
                        "items": {
                          "properties": {
                            "field_name": {
                              "order": 1,
                              "title": "fieldName",
                              "type": "string"
                            },
                            "filter": {
                              "oneOf": [
                                {
                                  "properties": {
                                    "caseSensitive": {
                                      "order": 2,
                                      "tittle": "caseSensitive",
                                      "type": "boolean"
                                    },
                                    "filter_name": {
                                      "const": "stringFilter",
                                      "type": "string"
                                    },
                                    "matchType": {
                                      "items": {
                                        "enum": [
                                          "MATCH_TYPE_UNSPECIFIED",
                                          "EXACT",
                                          "BEGINS_WITH",
                                          "ENDS_WITH",
                                          "CONTAINS",
                                          "FULL_REGEXP",
                                          "PARTIAL_REGEXP"
                                        ],
                                        "title": "ValidEnums"
                                      },
                                      "order": 1,
                                      "title": "matchType",
                                      "type": "array"
                                    },
                                    "value": {
                                      "order": 0,
                                      "tittle": "value",
                                      "type": "string"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "value"
                                  ],
                                  "title": "stringFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "caseSensitive": {
                                      "order": 1,
                                      "tittle": "caseSensitive",
                                      "type": "boolean"
                                    },
                                    "filter_name": {
                                      "const": "inListFilter",
                                      "type": "string"
                                    },
                                    "values": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "minItems": 1,
                                      "order": 0,
                                      "tittle": "values",
                                      "type": "array"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "values"
                                  ],
                                  "title": "inListFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "filter_name": {
                                      "const": "numericFilter",
                                      "type": "string"
                                    },
                                    "operation": {
                                      "items": {
                                        "enum": [
                                          "OPERATION_UNSPECIFIED",
                                          "EQUAL",
                                          "LESS_THAN",
                                          "LESS_THAN_OR_EQUAL",
                                          "GREATER_THAN",
                                          "GREATER_THAN_OR_EQUAL"
                                        ],
                                        "title": "ValidEnums"
                                      },
                                      "order": 1,
                                      "title": "operation",
                                      "type": "array"
                                    },
                                    "value": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 0,
                                      "tittle": "value",
                                      "type": "object"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "operation",
                                    "value"
                                  ],
                                  "title": "numericFilter",
                                  "type": "object"
                                },
                                {
                                  "properties": {
                                    "filter_name": {
                                      "const": "betweenFilter",
                                      "type": "string"
                                    },
                                    "fromValue": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 0,
                                      "tittle": "fromValue",
                                      "type": "object"
                                    },
                                    "toValue": {
                                      "oneOf": [
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "string"
                                            },
                                            "value_type": {
                                              "const": "int64Value",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "int64Value",
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "value": {
                                              "type": "number"
                                            },
                                            "value_type": {
                                              "const": "doubleValue",
                                              "type": "string"
                                            }
                                          },
                                          "required": [
                                            "value_type",
                                            "value"
                                          ],
                                          "title": "doubleValue",
                                          "type": "object"
                                        }
                                      ],
                                      "order": 1,
                                      "tittle": "toValue",
                                      "type": "object"
                                    }
                                  },
                                  "required": [
                                    "filter_name",
                                    "fromValue",
                                    "toValue"
                                  ],
                                  "title": "betweenFilter",
                                  "type": "object"
                                }
                              ],
                              "order": 2,
                              "title": "filter",
                              "type": "object"
                            }
                          },
                          "required": [
                            "field_name",
                            "filter"
                          ],
                          "title": "Expression",
                          "type": "object"
                        },
                        "order": 1,
                        "title": "Expressions",
                        "type": "array"
                      },
                      "filter_type": {
                        "const": "orGroup",
                        "order": 0,
                        "type": "string"
                      }
                    },
                    "required": [
                      "filter_type",
                      "expressions"
                    ],
                    "title": "orGroup",
                    "type": "object"
                  },
                  {
                    "description": "The FilterExpression is NOT of notExpression.",
                    "properties": {
                      "expression": {
                        "properties": {
                          "field_name": {
                            "order": 1,
                            "title": "fieldName",
                            "type": "string"
                          },
                          "filter": {
                            "oneOf": [
                              {
                                "properties": {
                                  "caseSensitive": {
                                    "order": 2,
                                    "tittle": "caseSensitive",
                                    "type": "boolean"
                                  },
                                  "filter_name": {
                                    "const": "stringFilter",
                                    "type": "string"
                                  },
                                  "matchType": {
                                    "items": {
                                      "enum": [
                                        "MATCH_TYPE_UNSPECIFIED",
                                        "EXACT",
                                        "BEGINS_WITH",
                                        "ENDS_WITH",
                                        "CONTAINS",
                                        "FULL_REGEXP",
                                        "PARTIAL_REGEXP"
                                      ],
                                      "title": "ValidEnums"
                                    },
                                    "order": 1,
                                    "title": "matchType",
                                    "type": "array"
                                  },
                                  "value": {
                                    "order": 0,
                                    "tittle": "value",
                                    "type": "string"
                                  }
                                },
                                "required": [
                                  "filter_name",
                                  "value"
                                ],
                                "title": "stringFilter",
                                "type": "object"
                              },
                              {
                                "properties": {
                                  "caseSensitive": {
                                    "order": 1,
                                    "tittle": "caseSensitive",
                                    "type": "boolean"
                                  },
                                  "filter_name": {
                                    "const": "inListFilter",
                                    "type": "string"
                                  },
                                  "values": {
                                    "items": {
                                      "type": "string"
                                    },
                                    "minItems": 1,
                                    "order": 0,
                                    "tittle": "values",
                                    "type": "array"
                                  }
                                },
                                "required": [
                                  "filter_name",
                                  "values"
                                ],
                                "title": "inListFilter",
                                "type": "object"
                              },
                              {
                                "properties": {
                                  "filter_name": {
                                    "const": "numericFilter",
                                    "type": "string"
                                  },
                                  "operation": {
                                    "items": {
                                      "enum": [
                                        "OPERATION_UNSPECIFIED",
                                        "EQUAL",
                                        "LESS_THAN",
                                        "LESS_THAN_OR_EQUAL",
                                        "GREATER_THAN",
                                        "GREATER_THAN_OR_EQUAL"
                                      ],
                                      "title": "ValidEnums"
                                    },
                                    "order": 1,
                                    "title": "operation",
                                    "type": "array"
                                  },
                                  "value": {
                                    "oneOf": [
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "string"
                                          },
                                          "value_type": {
                                            "const": "int64Value",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "int64Value",
                                        "type": "object"
                                      },
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "number"
                                          },
                                          "value_type": {
                                            "const": "doubleValue",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "doubleValue",
                                        "type": "object"
                                      }
                                    ],
                                    "order": 0,
                                    "tittle": "value",
                                    "type": "object"
                                  }
                                },
                                "required": [
                                  "filter_name",
                                  "operation",
                                  "value"
                                ],
                                "title": "numericFilter",
                                "type": "object"
                              },
                              {
                                "properties": {
                                  "filter_name": {
                                    "const": "betweenFilter",
                                    "type": "string"
                                  },
                                  "fromValue": {
                                    "oneOf": [
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "string"
                                          },
                                          "value_type": {
                                            "const": "int64Value",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "int64Value",
                                        "type": "object"
                                      },
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "number"
                                          },
                                          "value_type": {
                                            "const": "doubleValue",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "doubleValue",
                                        "type": "object"
                                      }
                                    ],
                                    "order": 0,
                                    "tittle": "fromValue",
                                    "type": "object"
                                  },
                                  "toValue": {
                                    "oneOf": [
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "string"
                                          },
                                          "value_type": {
                                            "const": "int64Value",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "int64Value",
                                        "type": "object"
                                      },
                                      {
                                        "properties": {
                                          "value": {
                                            "type": "number"
                                          },
                                          "value_type": {
                                            "const": "doubleValue",
                                            "type": "string"
                                          }
                                        },
                                        "required": [
                                          "value_type",
                                          "value"
                                        ],
                                        "title": "doubleValue",
                                        "type": "object"
                                      }
                                    ],
                                    "order": 1,
                                    "tittle": "toValue",
                                    "type": "object"
                                  }
                                },
                                "required": [
                                  "filter_name",
                                  "fromValue",
                                  "toValue"
                                ],
                                "title": "betweenFilter",
                                "type": "object"
                              }
                            ],
                            "order": 2,
                            "title": "filter",
                            "type": "object"
                          }
                        },
                        "required": [
                          "field_name",
                          "filter"
                        ],
                        "title": "Expression",
                        "type": "object"
                      },
                      "filter_type": {
                        "const": "notExpression",
                        "order": 0,
                        "type": "string"
                      }
                    },
                    "title": "notExpression",
                    "type": "object"
                  },
                  {
                    "description": "A primitive filter. In the same FilterExpression, all of the filter's field names need to be either all metrics.",
                    "properties": {
                      "field_name": {
                        "order": 1,
                        "title": "fieldName",
                        "type": "string"
                      },
                      "filter": {
                        "oneOf": [
                          {
                            "properties": {
                              "caseSensitive": {
                                "order": 2,
                                "tittle": "caseSensitive",
                                "type": "boolean"
                              },
                              "filter_name": {
                                "const": "stringFilter",
                                "type": "string"
                              },
                              "matchType": {
                                "items": {
                                  "enum": [
                                    "MATCH_TYPE_UNSPECIFIED",
                                    "EXACT",
                                    "BEGINS_WITH",
                                    "ENDS_WITH",
                                    "CONTAINS",
                                    "FULL_REGEXP",
                                    "PARTIAL_REGEXP"
                                  ],
                                  "title": "ValidEnums"
                                },
                                "order": 1,
                                "title": "matchType",
                                "type": "array"
                              },
                              "value": {
                                "order": 0,
                                "tittle": "value",
                                "type": "string"
                              }
                            },
                            "required": [
                              "filter_name",
                              "value"
                            ],
                            "title": "stringFilter",
                            "type": "object"
                          },
                          {
                            "properties": {
                              "caseSensitive": {
                                "order": 1,
                                "tittle": "caseSensitive",
                                "type": "boolean"
                              },
                              "filter_name": {
                                "const": "inListFilter",
                                "type": "string"
                              },
                              "values": {
                                "items": {
                                  "type": "string"
                                },
                                "minItems": 1,
                                "order": 0,
                                "tittle": "values",
                                "type": "array"
                              }
                            },
                            "required": [
                              "filter_name",
                              "values"
                            ],
                            "title": "inListFilter",
                            "type": "object"
                          },
                          {
                            "properties": {
                              "filter_name": {
                                "const": "numericFilter",
                                "type": "string"
                              },
                              "operation": {
                                "items": {
                                  "enum": [
                                    "OPERATION_UNSPECIFIED",
                                    "EQUAL",
                                    "LESS_THAN",
                                    "LESS_THAN_OR_EQUAL",
                                    "GREATER_THAN",
                                    "GREATER_THAN_OR_EQUAL"
                                  ],
                                  "title": "ValidEnums"
                                },
                                "order": 1,
                                "title": "operation",
                                "type": "array"
                              },
                              "value": {
                                "oneOf": [
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "string"
                                      },
                                      "value_type": {
                                        "const": "int64Value",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "int64Value",
                                    "type": "object"
                                  },
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "number"
                                      },
                                      "value_type": {
                                        "const": "doubleValue",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "doubleValue",
                                    "type": "object"
                                  }
                                ],
                                "order": 0,
                                "tittle": "value",
                                "type": "object"
                              }
                            },
                            "required": [
                              "filter_name",
                              "operation",
                              "value"
                            ],
                            "title": "numericFilter",
                            "type": "object"
                          },
                          {
                            "properties": {
                              "filter_name": {
                                "const": "betweenFilter",
                                "type": "string"
                              },
                              "fromValue": {
                                "oneOf": [
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "string"
                                      },
                                      "value_type": {
                                        "const": "int64Value",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "int64Value",
                                    "type": "object"
                                  },
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "number"
                                      },
                                      "value_type": {
                                        "const": "doubleValue",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "doubleValue",
                                    "type": "object"
                                  }
                                ],
                                "order": 0,
                                "tittle": "fromValue",
                                "type": "object"
                              },
                              "toValue": {
                                "oneOf": [
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "string"
                                      },
                                      "value_type": {
                                        "const": "int64Value",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "int64Value",
                                    "type": "object"
                                  },
                                  {
                                    "properties": {
                                      "value": {
                                        "type": "number"
                                      },
                                      "value_type": {
                                        "const": "doubleValue",
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "value_type",
                                      "value"
                                    ],
                                    "title": "doubleValue",
                                    "type": "object"
                                  }
                                ],
                                "order": 1,
                                "tittle": "toValue",
                                "type": "object"
                              }
                            },
                            "required": [
                              "filter_name",
                              "fromValue",
                              "toValue"
                            ],
                            "title": "betweenFilter",
                            "type": "object"
                          }
                        ],
                        "order": 2,
                        "title": "filter",
                        "type": "object"
                      },
                      "filter_type": {
                        "const": "filter",
                        "order": 0,
                        "type": "string"
                      }
                    },
                    "required": [
                      "field_name",
                      "filter"
                    ],
                    "title": "filter",
                    "type": "object"
                  }
                ],
                "order": 4,
                "title": "Metrics filter",
                "type": "object"
              },
              "metrics": {
                "description": "A list of metrics.",
                "items": {
                  "type": "string"
                },
                "minItems": 1,
                "order": 2,
                "title": "Metrics",
                "type": "array"
              },
              "name": {
                "description": "The name of the custom report, this name would be used as stream name.",
                "order": 0,
                "title": "Name",
                "type": "string"
              }
            },
            "required": [
              "name",
              "dimensions",
              "metrics"
            ],
            "title": "Custom Report Config",
            "type": "object"
          },
          "order": 4,
          "title": "Custom Reports",
          "type": "array"
        },
        "date_ranges_end_date": {
          "description": "The end date from which to replicate report data in the format YYYY-MM-DD. Data generated after this date will not be included in the report. Not applied to custom Cohort reports. When no date is provided or the date is in the future, the date from today is used.",
          "examples": [
            "2021-01-31"
          ],
          "format": "date",
          "order": 3,
          "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
          "pattern_descriptor": "YYYY-MM-DD",
          "title": "End Date",
          "type": "string"
        },
        "date_ranges_start_date": {
          "description": "The start date from which to replicate report data in the format YYYY-MM-DD. Data generated before this date will not be included in the report. Not applied to custom Cohort reports.",
          "examples": [
            "2021-01-01"
          ],
          "format": "date",
          "order": 2,
          "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
          "pattern_descriptor": "YYYY-MM-DD",
          "title": "Start Date",
          "type": "string"
        },
        "keep_empty_rows": {
          "default": false,
          "description": "If false, each row with all metrics equal to 0 will not be returned. If true, these rows will be returned if they are not separately removed by a filter. More information is available in <a href=\"https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport#request-body\">the documentation</a>.",
          "order": 7,
          "title": "Keep Empty Rows",
          "type": "boolean"
        },
        "lookback_window": {
          "default": 2,
          "description": "Since attribution changes after the event date, and Google Analytics has a data processing latency, we should specify how many days in the past we should refresh the data in every run. So if you set it at 5 days, in every sync it will fetch the last bookmark date minus 5 days.",
          "examples": [
            2,
            3,
            4,
            7,
            14,
            28
          ],
          "maximum": 60,
          "minimum": 2,
          "order": 6,
          "title": "Lookback window (Days)",
          "type": "integer"
        },
        "property_ids": {
          "description": "A list of your Property IDs. The Property ID is a unique number assigned to each property in Google Analytics, found in your GA4 property URL. This ID allows the connector to track the specific events associated with your property. Refer to the <a href='https://developers.google.com/analytics/devguides/reporting/data/v1/property-id#what_is_my_property_id'>Google Analytics documentation</a> to locate your property ID.",
          "examples": [
            [
              "1738294",
              "5729978930"
            ]
          ],
          "items": {
            "pattern": "^[0-9]*$",
            "type": "string"
          },
          "order": 1,
          "title": "Property IDs",
          "type": "array",
          "uniqueItems": true
        },
        "subscription_tier": {
          "default": "Standard Property",
          "description": "Quota tier of the Google Analytics 4 properties being queried. Determines the per-property rate-limit policy applied locally once the tier-aware rate-limit budget is activated. Select \"Analytics 360 Property\" only if all configured property IDs belong to an Analytics 360 subscription. See https://developers.google.com/analytics/devguides/reporting/data/v1/quotas.",
          "enum": [
            "Standard Property",
            "Analytics 360 Property"
          ],
          "order": 9,
          "title": "Subscription Plan/Tier",
          "type": "string"
        },
        "window_in_days": {
          "default": 1,
          "description": "The interval in days for each data request made to the Google Analytics API. A larger value speeds up data sync, but increases the chance of data sampling, which may result in inaccuracies. We recommend a value of 1 to minimize sampling, unless speed is an absolute priority over accuracy. Acceptable values range from 1 to 364. Does not apply to custom Cohort reports. More information is available in <a href=\"https://docs.airbyte.com/integrations/sources/google-analytics-data-api\">the documentation</a>.",
          "examples": [
            30,
            60,
            90,
            120,
            200,
            364
          ],
          "maximum": 364,
          "minimum": 1,
          "order": 5,
          "title": "Data Request Interval (Days)",
          "type": "integer"
        }
      },
      "required": [
        "property_ids"
      ],
      "title": "Google Analytics (Data API) Spec",
      "type": "object"
    },
    "supportsDBT": false,
    "supportsNormalization": false
  },
  "suggestedStreams": {
    "streams": [
      "website_overview",
      "daily_active_users",
      "traffic_sources",
      "pages",
      "weekly_active_users",
      "devices",
      "locations",
      "four_weekly_active_users",
      "sessions"
    ]
  },
  "supportLevel": "certified",
  "supportsDataActivation": false,
  "supportsFileTransfer": false,
  "tags": [
    "language:manifest-only",
    "cdk:low-code"
  ],
  "tombstone": false
}
