diff --git a/describe.py b/describe.py
index e53724e..1f846fd 100755
--- a/describe.py
+++ b/describe.py
@@ -28,7 +28,7 @@
 import argparse
 import collections
 import json
-import os
+import pathlib
 import re
 import string
 import sys
@@ -37,12 +37,15 @@
 from googleapiclient.discovery import build
 from googleapiclient.discovery import build_from_document
 from googleapiclient.discovery import UnknownApiNameOrVersion
-from googleapiclient.discovery_cache import get_static_doc
 from googleapiclient.http import build_http
 from googleapiclient.errors import HttpError
 
 import uritemplate
 
+DISCOVERY_DOC_DIR = (
+    pathlib.Path(__file__).parent.resolve() / "googleapiclient" / "discovery_cache" / "documents"
+)
+
 CSS = """<style>
 
 body, h1, h2, h3, div, span, p, pre, a {
@@ -133,7 +136,7 @@
   <code><a href="#$name">$name($params)</a></code></p>
 <p class="firstline">$firstline</p>"""
 
-BASE = "docs/dyn"
+BASE = pathlib.Path(__file__).parent.resolve() / "docs" / "dyn"
 
 DIRECTORY_URI = "https://www.googleapis.com/discovery/v1/apis"
 
@@ -254,14 +257,10 @@
     name: string, Name of the method.
     doc: string, The methods docstring.
   """
+    import html
 
     params = method_params(doc)
-    if sys.version_info.major >= 3:
-        import html
-        doc = html.escape(doc)
-    else:
-        import cgi
-        doc = cgi.escape(doc)
+    doc = html.escape(doc)
     return string.Template(METHOD_TEMPLATE).substitute(
         name=name, params=params, doc=doc
     )
@@ -358,13 +357,10 @@
     return "\n".join(html)
 
 
-def document_collection_recursive(resource, path, root_discovery, discovery):
-
+def document_collection_recursive(resource, path, root_discovery, discovery, doc_destination_dir):
     html = document_collection(resource, path, root_discovery, discovery)
 
-    f = open(os.path.join(FLAGS.dest, path + "html"), "w")
-    if sys.version_info.major < 3:
-        html = html.encode("utf-8")
+    f = open(pathlib.Path(doc_destination_dir).joinpath(path + "html"), "w")
 
     f.write(html)
     f.close()
@@ -383,44 +379,76 @@
                 path + name + ".",
                 root_discovery,
                 discovery["resources"].get(dname, {}),
+                doc_destination_dir
             )
 
 
-def document_api(name, version, uri):
+def document_api(name, version, uri, doc_destination_dir):
     """Document the given API.
 
-  Args:
-    name: string, Name of the API.
-    version: string, Version of the API.
-    uri: string, URI of the API's discovery document
+    Args:
+        name (str): Name of the API.
+        version (str): Version of the API.
+        uri (str): URI of the API's discovery document
+        doc_destination_dir (str): relative path where the reference
+            documentation should be saved.
   """
-    try:
-        service = build(name, version)
-        content = get_static_doc(name, version)
-    except UnknownApiNameOrVersion as e:
-        print("Warning: {} {} found but could not be built.".format(name, version))
-        return
-    except HttpError as e:
-        print("Warning: {} {} returned {}.".format(name, version, e))
-        return
+    http = build_http()
+    resp, content = http.request(
+        uri or uritemplate.expand(
+            FLAGS.discovery_uri_template, {"api": name, "apiVersion": version}
+        )
+    )
 
-    discovery = json.loads(content)
+    if resp.status == 200:
+        discovery = json.loads(content)
+        service = build_from_document(discovery)
+        version = safe_version(version)
+        doc_name = "{}.{}.json".format(name, version.replace("_", ""))
 
-    version = safe_version(version)
+        discovery_file_path = DISCOVERY_DOC_DIR / doc_name
+        revision = None
+
+        pathlib.Path(discovery_file_path).touch(exist_ok=True)
+
+        # Write discovery artifact to disk if revision equal or newer
+        with open(discovery_file_path, "r+") as f:
+            try:
+                json_data = json.load(f)
+                revision = json_data['revision']
+            except json.JSONDecodeError:
+                revision = None
+
+            if revision is None or discovery['revision'] >= revision:
+                # Reset position to the beginning
+                f.seek(0)
+                # Write the changes to disk
+                json.dump(discovery, f, indent=2, sort_keys=True)
+                # Truncate anything left as it's not needed
+                f.truncate()
+
+    elif resp.status == 404:
+        print("Warning: {} {} not found. HTTP Code: {}".format(name, version, resp.status))
+        return
+    else:
+        print("Warning: {} {} could not be built. HTTP Code: {}".format(name, version, resp.status))
+        return
 
     document_collection_recursive(
-        service, "{}_{}.".format(name, version), discovery, discovery
+        service, "{}_{}.".format(name, version), discovery, discovery, doc_destination_dir
     )
 
 
-def document_api_from_discovery_document(uri):
+def document_api_from_discovery_document(discovery_url, doc_destination_dir):
     """Document the given API.
 
   Args:
-    uri: string, URI of discovery document.
+    discovery_url (str): URI of discovery document.
+    doc_destination_dir (str): relative path where the reference
+        documentation should be saved.
   """
     http = build_http()
-    response, content = http.request(FLAGS.discovery_uri)
+    response, content = http.request(discovery_url)
     discovery = json.loads(content)
 
     service = build_from_document(discovery)
@@ -429,48 +457,53 @@
     version = safe_version(discovery["version"])
 
     document_collection_recursive(
-        service, "{}_{}.".format(name, version), discovery, discovery
+        service, "{}_{}.".format(name, version), discovery, discovery, doc_destination_dir
     )
 
+def generate_all_api_documents(directory_uri=DIRECTORY_URI, doc_destination_dir=BASE):
+    """ Retrieve discovery artifacts and fetch reference documentations
+    for all apis listed in the public discovery directory.
+    args:
+        directory_uri (str): uri of the public discovery directory.
+        doc_destination_dir (str): relative path where the reference
+            documentation should be saved.
+    """
+    api_directory = collections.defaultdict(list)
+    http = build_http()
+    resp, content = http.request(directory_uri)
+    if resp.status == 200:
+        directory = json.loads(content)["items"]
+        for api in directory:
+            document_api(api["name"], api["version"], api["discoveryRestUrl"], doc_destination_dir)
+            api_directory[api["name"]].append(api["version"])
+
+        # sort by api name and version number
+        for api in api_directory:
+            api_directory[api] = sorted(api_directory[api])
+        api_directory = OrderedDict(
+            sorted(api_directory.items(), key=lambda x: x[0])
+        )
+
+        markdown = []
+        for api, versions in api_directory.items():
+            markdown.append("## %s" % api)
+            for version in versions:
+                markdown.append(
+                    "* [%s](http://googleapis.github.io/google-api-python-client/docs/dyn/%s_%s.html)"
+                    % (version, api, safe_version(version))
+                )
+            markdown.append("\n")
+
+        with open(BASE / "index.md", "w") as f:
+            markdown = "\n".join(markdown)
+            f.write(markdown)
+
+    else:
+        sys.exit("Failed to load the discovery document.")
 
 if __name__ == "__main__":
     FLAGS = parser.parse_args(sys.argv[1:])
     if FLAGS.discovery_uri:
-        document_api_from_discovery_document(FLAGS.discovery_uri)
+        document_api_from_discovery_document(discovery_url=FLAGS.discovery_uri, doc_destination_dir=FLAGS.dest)
     else:
-        api_directory = collections.defaultdict(list)
-        http = build_http()
-        resp, content = http.request(
-            FLAGS.directory_uri, headers={"X-User-IP": "0.0.0.0"}
-        )
-        if resp.status == 200:
-            directory = json.loads(content)["items"]
-            for api in directory:
-                document_api(api["name"], api["version"], api["discoveryRestUrl"])
-                api_directory[api["name"]].append(api["version"])
-
-            # sort by api name and version number
-            for api in api_directory:
-                api_directory[api] = sorted(api_directory[api])
-            api_directory = OrderedDict(
-                sorted(api_directory.items(), key=lambda x: x[0])
-            )
-
-            markdown = []
-            for api, versions in api_directory.items():
-                markdown.append("## %s" % api)
-                for version in versions:
-                    markdown.append(
-                        "* [%s](http://googleapis.github.io/google-api-python-client/docs/dyn/%s_%s.html)"
-                        % (version, api, safe_version(version))
-                    )
-                markdown.append("\n")
-
-            with open("docs/dyn/index.md", "w") as f:
-                markdown = "\n".join(markdown)
-                if sys.version_info.major < 3:
-                    markdown = markdown.encode("utf-8")
-                f.write(markdown)
-
-        else:
-            sys.exit("Failed to load the discovery document.")
+        generate_all_api_documents(directory_uri=FLAGS.directory_uri, doc_destination_dir=FLAGS.dest)
diff --git a/noxfile.py b/noxfile.py
index 4808772..0fda3e1 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 import sys
 
 import nox
@@ -90,3 +91,21 @@
         "tests",
         *session.posargs,
     )
+
+@nox.session(python=["3.9"])
+def scripts(session):
+    session.install(*test_dependencies)
+    session.install("-e", ".")
+    session.install("-r", "scripts/requirements.txt")
+
+    # Run py.test against the unit tests.
+    session.run(
+        "py.test",
+        "--quiet",
+        "--cov=scripts",
+        "--cov-config=.coveragerc",
+        "--cov-report=",
+        "--cov-fail-under=80",
+        "scripts",
+        *session.posargs,
+    )
diff --git a/scripts/README.md b/scripts/README.md
new file mode 100644
index 0000000..f2b59bd
--- /dev/null
+++ b/scripts/README.md
@@ -0,0 +1,21 @@
+# Discovery Artifact Automation
+Discovery Artifacts are automatically updated using a Github Action script. This
+documentation is intended for users that need to maintain the repository.
+
+## Updating discovery artifacts locally
+
+To update discovery artifacts locally:
+1. Create a virtual environment using `pyenv virtualenv updateartifacts`
+2. Activate the virtual environment using `pyenv activate updateartifacts`
+3. Clone the repository, and `cd` into the `scripts` directory
+4. Run `pip install -r requirements.txt`
+5. Run `pip install -e ../`
+6. Run `git checkout -b update-discovery-artifacts-manual`
+7. Run `python3 updatediscoveryartifacts.py`
+8. Run `./createcommits.sh`
+9. Run `python3 buildprbody.py`
+10. Create a pull request with the changes.
+11. Copy the contents of `temp/allapis.summary` into the PR Body.
+
+## Questions
+Feel free to submit an issue!
diff --git a/scripts/buildprbody.py b/scripts/buildprbody.py
new file mode 100644
index 0000000..10733b4
--- /dev/null
+++ b/scripts/buildprbody.py
@@ -0,0 +1,104 @@
+# Copyright 2021 Google LLC
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     https://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from enum import IntEnum
+import numpy as np
+import pandas as pd
+import pathlib
+
+class ChangeType(IntEnum):
+    UNKNOWN = 0
+    DELETED = 1
+    ADDED = 2
+    CHANGED = 3
+
+
+def get_commit_link(name):
+    """Return a string with a link to the last commit for the given
+        API Name.
+    args:
+        name (str): The name of the api.
+    """
+
+    url = "https://github.com/googleapis/google-api-python-client/commit/"
+    sha = None
+    api_link = ""
+
+    file_path = pathlib.Path(directory).joinpath("{0}.sha".format(name))
+    if file_path.is_file():
+        with open(file_path, "r") as f:
+            sha = f.readline().rstrip()
+            if sha:
+                api_link = "[{0}]({1}{2})".format(" [More details]", url, sha)
+
+    return api_link
+
+
+if __name__ == "__main__":
+    directory = pathlib.Path("temp")
+    dataframe = pd.read_csv("temp/allapis.dataframe")
+    dataframe["Version"] = dataframe["Version"].astype(str)
+
+    dataframe["Commit"] = np.vectorize(get_commit_link)(dataframe["Name"])
+
+    stable_and_breaking = (
+        dataframe[
+            dataframe["IsStable"]
+            & (dataframe["ChangeType"] == ChangeType.DELETED)
+        ][["Name", "Version", "Commit"]]
+        .drop_duplicates()
+        .agg("".join, axis=1)
+        .values
+    )
+
+    prestable_and_breaking = (
+        dataframe[
+            (dataframe["IsStable"] == False)
+            & (dataframe["ChangeType"] == ChangeType.DELETED)
+        ][["Name", "Version", "Commit"]]
+        .drop_duplicates()
+        .agg("".join, axis=1)
+        .values
+    )
+
+    all_apis = (
+        dataframe[["Name", "Version", "Commit"]]
+        .drop_duplicates()
+        .agg("".join, axis=1)
+        .values
+    )
+
+    with open(directory / "allapis.summary", "w") as f:
+        if len(stable_and_breaking) > 0:
+            f.writelines(
+                [
+                    "## Deleted keys were detected in the following stable discovery artifacts:\n",
+                    "\n".join(stable_and_breaking),
+                    "\n\n",
+                ]
+            )
+
+        if len(prestable_and_breaking) > 0:
+            f.writelines(
+                [
+                    "## Deleted keys were detected in the following pre-stable discovery artifacts:\n",
+                    "\n".join(prestable_and_breaking),
+                    "\n\n",
+                ]
+            )
+
+        if len(all_apis) > 0:
+            f.writelines(
+                ["## Discovery Artifact Change Summary:\n", "\n".join(all_apis), "\n"]
+            )
diff --git a/scripts/changesummary.py b/scripts/changesummary.py
new file mode 100644
index 0000000..badb7b8
--- /dev/null
+++ b/scripts/changesummary.py
@@ -0,0 +1,524 @@
+# Copyright 2021 Google LLC
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     https://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from enum import IntEnum
+import json
+from multiprocessing import Pool
+import pandas as pd
+import pathlib
+import numpy as np
+
+BRANCH_ARTIFACTS_DIR = (
+    pathlib.Path(__file__).parent.resolve() / "googleapiclient" / "discovery_cache" / "documents"
+)
+MAIN_ARTIFACTS_DIR = (
+    pathlib.Path(__file__).parent.resolve() / ".." / "main" / "googleapiclient" / "discovery_cache" / "documents"
+)
+
+MULTIPROCESSING_NUM_PER_BATCH = 5
+MULTIPROCESSING_NUM_AGENTS = 10
+
+
+class ChangeType(IntEnum):
+    UNKNOWN = 0
+    DELETED = 1
+    ADDED = 2
+    CHANGED = 3
+
+
+class DirectoryDoesNotExist(ValueError):
+    """Raised when the specified directory does not exist."""
+
+    pass
+
+
+class ChangeSummary:
+    """Represents the change summary between 2 directories containing \
+        artifacts.
+    """
+
+    def __init__(self, new_artifacts_dir, current_artifacts_dir, temp_dir, file_list):
+        """Initializes an instance of a ChangeSummary.
+
+        Args:
+            new_artifacts_dir (str): The relative path to the directory with the
+                new discovery artifacts.
+            current_artifacts_dir (str): The relative path to the directory with
+                the current discovery artifacts.
+            temp_dir (str): The relative path to the directory used for
+                temporary storage where intermediate files will be stored.
+            file_list (list): A list of strings containing files to analyze.
+        """
+
+        self._file_list = file_list
+        self._new_artifacts_dir = pathlib.Path(new_artifacts_dir)
+        self._current_artifacts_dir = pathlib.Path(current_artifacts_dir)
+        self._temp_dir = pathlib.Path(temp_dir)
+
+        # Sanity checks to ensure directories exist
+        self._raise_if_directory_not_found(self._new_artifacts_dir)
+        self._raise_if_directory_not_found(self._current_artifacts_dir)
+        self._raise_if_directory_not_found(self._temp_dir)
+
+    def _raise_if_directory_not_found(self, directory):
+        """Raises if the `directory` doesn't exist
+
+        args:
+            directory (str): The relative path to the `directory`
+        """
+
+        if not pathlib.Path(directory).exists():
+            raise DirectoryDoesNotExist(
+                "Directory does not exist : {0}".format(directory)
+            )
+
+    def _load_json_to_dataframe(self, file_path):
+        """Returns a pandas dataframe from the json file provided.
+
+        args:
+            file_path (str): The relative path to the discovery artifact to
+                parse.
+        """
+
+        # Create an empty dataframe as we will need to return it if the file
+        # doesn't exist
+        dataframe_doc = pd.DataFrame()
+
+        if pathlib.Path(file_path).is_file():
+            with open(file_path, "r") as f:
+                # Now load the json file into a pandas dataframe as a flat table
+                dataframe_doc = pd.json_normalize(json.load(f))
+        return dataframe_doc
+
+    def _get_discovery_differences(self, filename):
+        """Returns a pandas dataframe which contains the differences with the
+        current and new discovery artifact directories, corresponding to the
+        file name provided.
+
+        args:
+            filename (str): The name of the discovery artifact to parse.
+        """
+        # The paths of the 2 discovery artifacts to compare
+        current_artifact_path = self._current_artifacts_dir / filename
+        new_artifact_path = self._new_artifacts_dir / filename
+
+        # Use a helper functions to load the discovery artifacts into pandas
+        # dataframes
+        current_doc = self._load_json_to_dataframe(current_artifact_path)
+        new_doc = self._load_json_to_dataframe(new_artifact_path)
+
+        # Concatenate the 2 dataframes, transpose them, and create
+        # a new dataframe called combined_docs with columns
+        # `Key`, `CurrentValue`, `NewValue`.
+        combined_docs = (
+            pd.concat([current_doc, new_doc], keys=["CurrentValue", "NewValue"])
+            # Drop the index column
+            .reset_index(drop=True,level=1)
+            # Transpose the DataFrame, Resulting Columns should be
+            # ["Key", "CurrentValue", "New Value"]
+            .rename_axis(['Key'], axis=1)
+            .transpose()
+            # Drop the index column
+            .reset_index()
+        )
+
+        # When discovery documents are added, the column `CurrentValue` will
+        # not exist. In that case, we'll just populate with `np.nan`.
+        if "CurrentValue" not in combined_docs.columns:
+            combined_docs["CurrentValue"] = np.nan
+
+        # When discovery documents are deleted, the column `NewValue` will
+        # not exist. In that case, we'll just populate with `np.nan`.
+        if "NewValue" not in combined_docs.columns:
+            combined_docs["NewValue"] = np.nan
+
+        # Split the Key into 2 columns for `Parent` and `Child` in order
+        # to group keys with the same parents together to summarize the changes
+        # by parent.
+        parent_child_df = combined_docs["Key"].str.rsplit(".", 1, expand=True)
+        # Rename the columns and join them with the combined_docs dataframe.
+        # If we only have a `Parent` column, it means that the Key doesn't have
+        # any children.
+        if len(parent_child_df.columns) == 1:
+            parent_child_df.columns = ["Parent"]
+        else:
+            parent_child_df.columns = ["Parent", "Child"]
+        combined_docs = combined_docs.join(parent_child_df)
+
+        # Create a new column `Added` to identify rows which have new keys.
+        combined_docs["Added"] = np.where(
+            combined_docs["CurrentValue"].isnull(), True, False
+        )
+
+        # Create a new column `Deleted` to identify rows which have deleted keys.
+        combined_docs["Deleted"] = np.where(
+            combined_docs["NewValue"].isnull(), True, False
+        )
+
+        # Aggregate the keys added by grouping keys with the same parents
+        # together to summarize the changes by parent rather than by key.
+        parent_added_agg = (
+            combined_docs.groupby("Parent")
+            .Added.value_counts(normalize=True)
+            .reset_index(name="Proportion")
+        )
+
+        # Add a column NumLevels to inicate the number of levels in the tree
+        # which will allow us to sort the parents in hierarchical order.
+        parent_added_agg["NumLevels"] = (
+            parent_added_agg["Parent"].str.split(".").apply(lambda x: len(x))
+        )
+
+        # Aggregate the keys deleted by grouping keys with the same parents
+        # together to summarize the changes by parent rather than by key.
+        parent_deleted_agg = (
+            combined_docs.groupby("Parent")
+            .Deleted.value_counts(normalize=True)
+            .reset_index(name="Proportion")
+        )
+
+        # Add a column NumLevels to inicate the number of levels in the tree
+        # which will allow us to sort the parents in hierarchical order.
+        parent_deleted_agg["NumLevels"] = (
+            parent_added_agg["Parent"].str.split(".").apply(lambda x: len(x))
+        )
+
+        # Create a list of all parents that have been added in hierarchical
+        # order. When `Proportion` is 1, it means that the parent is new as all
+        # children keys have been added.
+        all_added = (
+            parent_added_agg[
+                (parent_added_agg["Proportion"] == 1) & (parent_added_agg["Added"] == True)
+            ][["Parent", "NumLevels"]]
+            .sort_values("NumLevels", ascending=True)
+            .Parent.to_list()
+        )
+
+        # Create a list of all parents that have been deleted in hierarchical
+        # order. When `Proportion` is 1, it means that the parent is new as all
+        # children keys have been deleted.
+        all_deleted = (
+            parent_deleted_agg[
+                (parent_deleted_agg["Proportion"] == 1)
+                & (parent_deleted_agg["Deleted"] == True)
+            ][["Parent", "NumLevels"]]
+            .sort_values("NumLevels", ascending=True)
+            .Parent.to_list()
+        )
+
+        # Go through the list of parents that have been added. If we find any
+        # keys with parents which are a substring of the parent in this list,
+        # then it means that the entire parent is new. We don't need verbose
+        # information about the children, so we replace the parent.
+        for i in range(0, len(all_added)):
+            word = all_added[i]
+            combined_docs.Parent = np.where(
+                combined_docs["Parent"].str.startswith(word), word, combined_docs.Parent
+            )
+
+        # Go through the list of parents that have been deleted. If we find any
+        # keys with parents which are a substring of the parent in this list,
+        # then it means that the entire parent is deleted. We don't need verbose
+        # information about the children, so we replace the parent.
+        for i in range(0, len(all_deleted)):
+            word = all_deleted[i]
+            combined_docs.Parent = np.where(
+                combined_docs["Parent"].str.startswith(word), word, combined_docs.Parent
+            )
+
+        # Create a new dataframe with only the keys which have changed
+        docs_diff = combined_docs[
+            combined_docs["CurrentValue"] != combined_docs["NewValue"]
+        ].copy(deep=False)
+
+        # Get the API and Version from the file name but exclude the extension.
+        api_version_string = filename.split(".")[:-1]
+        # Create columns `Name` and `Version` using the version string
+        docs_diff["Name"] = api_version_string[0]
+        docs_diff["Version"] = ".".join(api_version_string[1:])
+
+        # These conditions are used as arguments in the `np.where` function
+        # below.
+        deleted_condition = docs_diff["NewValue"].isnull()
+        added_condition = docs_diff["CurrentValue"].isnull()
+
+        # Create a new `ChangeType` column. The `np.where()` function is like a
+        # tenary operator. When the `deleted_condition` is `True`, the
+        # `ChangeType` will be `ChangeType.Deleted`. If the added_condition is
+        # `True` the `ChangeType` will be `ChangeType.Added`, otherwise the
+        # `ChangeType` will be `ChangeType.Changed`.
+        docs_diff["ChangeType"] = np.where(
+            deleted_condition,
+            ChangeType.DELETED,
+            np.where(added_condition, ChangeType.ADDED, ChangeType.CHANGED),
+        )
+
+        # Filter out keys which rarely affect functionality. For example:
+        # {"description", "documentation", "enum", "etag", "revision", "title",
+        # "url", "rootUrl"}
+        docs_diff = docs_diff[
+            ~docs_diff["Key"].str.contains(
+                "|".join(self._get_keys_to_ignore()), case=False
+            )
+        ]
+
+        # Group keys with similar parents together and create a new column
+        # called 'Count' which indicates the number of keys that have been
+        # grouped together. The reason for the count column is that when keys
+        # have the same parent, we group them together to improve readability.
+        docs_diff = (
+            docs_diff.groupby(
+                ["Parent", "Added", "Deleted", "Name", "Version", "ChangeType"]
+            )
+            .size()
+            .reset_index(name="Count")[
+                ["Parent", "Added", "Deleted", "Name", "Version", "ChangeType", "Count"]
+            ]
+        )
+
+        # Rename the Parent column to the Key Column since we are reporting
+        # summary information of keys with the same parent.
+        docs_diff.rename(columns={"Parent": "Key"}, inplace=True)
+        return docs_diff
+
+    def _build_summary_message(self, api_name, is_feature):
+        """Returns a string containing the summary for a given api. The string
+        returned will be in the format `fix(<api_name>): update the API`
+        when `is_feature=False` and `feat(<api_name>)!: update the API`
+        when `is_feature=True`.
+
+        args:
+            api_name (str): The name of the api to include in the summary.
+            is_feature (bool): If True, include the prefix `feat` otherwise use
+                `fix`
+        """
+
+        # Build the conventional commit string based on the arguments provided
+        commit_type = "feat" if is_feature else "fix"
+        return "{0}({1}): update the api".format(commit_type, api_name)
+
+    def _get_keys_to_ignore(self):
+        """Returns a list of strings with keys to ignore because they rarely
+            affect functionality.
+
+        args: None
+        """
+        keys_to_ignore = [
+            "description",
+            "documentation",
+            "enum",
+            "etag",
+            "revision",
+            "title",
+            "url",
+            "rootUrl",
+        ]
+        return keys_to_ignore
+
+    def _get_stable_versions(self, versions):
+        """ Returns a pandas series `pd.Series()` of boolean values,
+        corresponding to the given series, indicating whether the version is
+        considered stable or not.
+        args:
+            versions (object): a pandas series containing version
+                information for all discovery artifacts.
+        """
+        # Use a regex on the version to find versions with the pattern
+        # <v>.<0-9>.<0-9>.<0-9> . Any api that matches this pattern will be
+        # labeled as stable. In other words, v1, v1.4 and v1.4.5 is stable
+        # but v1b1 v1aplha and v1beta1 is not stable.
+        return versions.str.extract(r"(v\d?\.?\d?\.?\d+$)").notnull()
+
+    def _get_summary_and_write_to_disk(self, dataframe, directory):
+        """Writes summary information to file about changes made to discovery
+        artifacts based on the provided dataframe and returns a dataframe
+        with the same. The file `'allapis.summary'` is saved to the current
+        working directory.
+        args:
+            dataframe (object): a pandas dataframe containing summary change
+                information for all discovery artifacts
+            directory (str): path where the summary file should be saved
+        """
+
+        dataframe["IsStable"] = self._get_stable_versions(dataframe["Version"])
+
+        # Create a filter for features, which contains only rows which have keys
+        # that have been deleted or added, that will be used as an argument in
+        # the `np.where()` call below.
+        filter_features = (dataframe["ChangeType"] == ChangeType.DELETED) | (
+            dataframe["ChangeType"] == ChangeType.ADDED
+        )
+
+        # Create a new column `IsFeature` to indicate which rows should be
+        # considered as features.
+        dataframe["IsFeature"] = np.where(filter_features, True, np.nan)
+
+        # Create a new column `IsFeatureAggregate` which will be used to
+        # summarize the api changes. We can either have feature or fix but not
+        # both.
+        dataframe["IsFeatureAggregate"] = dataframe.groupby("Name").IsFeature.transform(
+            lambda x: x.any()
+        )
+
+        # Create a new column `Summary`, which will contain a string with the
+        # conventional commit message.
+        dataframe["Summary"] = np.vectorize(self._build_summary_message)(
+            dataframe["Name"],
+            dataframe["IsFeatureAggregate"]
+        )
+
+        # Write the final dataframe to disk as it will be used in the
+        # buildprbody.py script
+        dataframe.to_csv(directory / "allapis.dataframe")
+        return dataframe
+
+    def _write_verbose_changes_to_disk(self, dataframe, directory, summary_df):
+        """ Writes verbose information to file about changes made to discovery
+        artifacts based on the provided dataframe. A separate file is saved
+        for each api in the current working directory. The extension of the
+        files will be `'.verbose'`.
+
+        args:
+            dataframe (object): a pandas dataframe containing verbose change
+                information for all discovery artifacts
+            directory (str): path where the summary file should be saved
+            summary_df (object): A dataframe containing a summary of the changes
+        """
+        # Array of strings which will contains verbose change information for
+        # each api
+        verbose_changes = []
+
+        # Sort the dataframe to minimize file operations below.
+        dataframe.sort_values(by=["Name","Version","ChangeType"],
+                                ascending=True, inplace=True)
+
+        # Select only the relevant columns. We need to create verbose output
+        # by Api Name, Version and ChangeType so we need to group by these
+        # columns.
+
+        change_type_groups = dataframe[
+            ["Name", "Version", "ChangeType", "Key", "Count"]
+        ].groupby(["Name", "Version", "ChangeType"])
+
+        lastApi = ""
+        lastVersion = ""
+        lastType = ChangeType.UNKNOWN
+
+        f = None
+        for name, group in change_type_groups:
+            currentApi = name[0]
+            currentVersion = name[1]
+            currentType = name[2]
+
+            # We need to handing file opening and closing when processing an API
+            # which is different from the previous one
+            if lastApi != currentApi:
+                # If we are processing a new api, close the file used for
+                # processing the previous API
+                if f is not None:
+                    f.writelines(verbose_changes)
+                    f.close()
+                    f = None
+                # Clear the array of strings with information from the previous
+                # api and reset the last version
+                verbose_changes = []
+                lastVersion = ''
+                # Create a file which contains verbose changes for the current
+                # API being processed
+                filename = "{0}.verbose".format(currentApi)
+                f = open(pathlib.Path(directory / filename), "a")
+                lastApi = currentApi
+
+                # Create a filter with only the rows for the current API
+                current_api_filter = summary_df["Name"] == currentApi
+
+                # Get the string in the `Summary` column for the current api and
+                # append it to `verbose_changes`. The `Summary` column contains
+                # the conventional commit message. Use pandas.Series.iloc[0] to
+                # retrieve only the first elemnt, since all the values in the
+                # summary column are the same for a given API.
+                verbose_changes.append(summary_df[current_api_filter].Summary.iloc[0])
+
+
+            # If the version has changed, we need to create append a new heading
+            # in the verbose summary which contains the api and version.
+            if lastVersion != currentVersion:
+                # Append a header string with the API and version
+                verbose_changes.append("\n\n#### {0}:{1}\n\n".format(currentApi, currentVersion))
+
+                lastVersion = currentVersion
+                lastType = ChangeType.UNKNOWN
+
+            # Whenever the change type is different, we need to create a new
+            # heading for the group of keys with the same change type.
+            if currentType != lastType:
+                if currentType == ChangeType.DELETED:
+                    verbose_changes.append("\nThe following keys were deleted:\n")
+                elif currentType == ChangeType.ADDED:
+                    verbose_changes.append("\nThe following keys were added:\n")
+                else:
+                    verbose_changes.append("\nThe following keys were changed:\n")
+
+                lastType = currentType
+
+                # Append the keys, and corresponding count, in the same change
+                # type group.
+                verbose_changes.extend(
+                    [
+                        "- {0} (Total Keys: {1})\n".format(row['Key'], row['Count'])
+                        for index, row in group[["Key", "Count"]].iterrows()
+                    ]
+                )
+
+        # Make sure to close the last file and write the changes.
+        if f is not None:
+            f.writelines(verbose_changes)
+            f.close()
+            f = None
+
+    def detect_discovery_changes(self):
+        """Writes a summary of the changes to the discovery artifacts to disk
+            at the path specified in `temp_dir`.
+
+        args: None
+        """
+        result = pd.DataFrame()
+        # Process files in parallel to improve performance
+        with Pool(processes=MULTIPROCESSING_NUM_AGENTS) as pool:
+            result = result.append(
+                pool.map(
+                    self._get_discovery_differences,
+                    self._file_list,
+                    MULTIPROCESSING_NUM_PER_BATCH,
+                )
+            )
+
+        if len(result):
+            # Sort the resulting dataframe by `Name`, `Version`, `ChangeType`
+            # and `Key`
+            sort_columns = ["Name", "Version", "ChangeType", "Key"]
+            result.sort_values(by=sort_columns, ascending=True, inplace=True)
+
+            # Create a folder which be used by the `createcommits.sh` and
+            # `buildprbody.py` scripts.
+            pathlib.Path(self._temp_dir).mkdir(exist_ok=True)
+
+            # Create a summary which contains a conventional commit message
+            # for each API and write it to disk.
+            summary_df = self._get_summary_and_write_to_disk(result, self._temp_dir)
+
+            # Create verbose change information for each API which contains
+            # a list of changes by key and write it to disk.
+            self._write_verbose_changes_to_disk(result, self._temp_dir, summary_df)
+
diff --git a/scripts/changesummary_test.py b/scripts/changesummary_test.py
new file mode 100644
index 0000000..583dbe1
--- /dev/null
+++ b/scripts/changesummary_test.py
@@ -0,0 +1,240 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""ChangeSummary tests."""
+
+__author__ = "partheniou@google.com (Anthonios Partheniou)"
+
+import pathlib
+import shutil
+import unittest
+
+import pandas as pd
+
+from changesummary import ChangeSummary
+from changesummary import ChangeType
+from changesummary import DirectoryDoesNotExist
+
+SCRIPTS_DIR = pathlib.Path(__file__).parent.resolve()
+NEW_ARTIFACTS_DIR = SCRIPTS_DIR / "test_resources" / "new_artifacts_dir"
+CURRENT_ARTIFACTS_DIR = SCRIPTS_DIR / "test_resources" / "current_artifacts_dir"
+TEMP_DIR = SCRIPTS_DIR / "test_resources" / "temp"
+
+
+class TestChangeSummary(unittest.TestCase):
+    def setUp(self):
+        # Clear temporary directory
+        shutil.rmtree(TEMP_DIR, ignore_errors=True)
+        # Create temporary directory
+        pathlib.Path(TEMP_DIR).mkdir()
+
+        self.cs = ChangeSummary(NEW_ARTIFACTS_DIR, CURRENT_ARTIFACTS_DIR, TEMP_DIR, [])
+
+    def test_raises_on_directory_not_found_new_artifacts_dir(self):
+        with self.assertRaises(DirectoryDoesNotExist):
+            ChangeSummary(
+                "invalid_artifact_dir", CURRENT_ARTIFACTS_DIR, TEMP_DIR, []
+            ).detect_discovery_changes()
+
+    def test_raises_on_directory_not_found_current_artifacts_dir(self):
+        with self.assertRaises(DirectoryDoesNotExist):
+            ChangeSummary(
+                NEW_ARTIFACTS_DIR, "invalid_artifact_dir", TEMP_DIR, []
+            ).detect_discovery_changes()
+
+    def test_raises_on_directory_not_found_temp_dir(self):
+        # Remove temporary directory
+        shutil.rmtree(TEMP_DIR, ignore_errors=True)
+
+        with self.assertRaises(DirectoryDoesNotExist):
+            ChangeSummary(
+                NEW_ARTIFACTS_DIR, CURRENT_ARTIFACTS_DIR, "invalid_temp_dir", []
+            ).detect_discovery_changes()
+
+        # Create temporary directory
+        pathlib.Path(TEMP_DIR).mkdir()
+
+        ChangeSummary(
+            NEW_ARTIFACTS_DIR, CURRENT_ARTIFACTS_DIR, TEMP_DIR, []
+        ).detect_discovery_changes()
+
+    def test_raises_on_directory_not_found(self):
+        with self.assertRaises(DirectoryDoesNotExist):
+            self.cs._raise_if_directory_not_found(directory="invalid_dir")
+
+    def test_load_json_to_dataframe_returns_empty_df_if_file_path_invalid(self):
+        df = self.cs._load_json_to_dataframe(file_path="invalid_path")
+        self.assertTrue(df.empty)
+
+    def test_load_json_to_dataframe_returns_expected_data(self):
+        doc_path = NEW_ARTIFACTS_DIR / "drive.v3.json"
+        df = self.cs._load_json_to_dataframe(file_path=doc_path)
+        self.assertEqual(df["name"].iloc[0], "drive")
+        self.assertEqual(df["version"].iloc[0], "v3")
+
+    def test_get_discovery_differences_for_new_doc_returns_expected_dataframe(self):
+        df = self.cs._get_discovery_differences("drive.v3.json")
+        # Assume that `drive.v3.json` is a new discovery artifact that doesn't
+        # exist in `CURRENT_ARTIFACTS_DIR`.
+        self.assertEqual(df["Name"].iloc[0], "drive")
+        self.assertEqual(df["Version"].iloc[0], "v3")
+
+        # All rows in the dataframe should  have `True` in the `Added` column
+        # and `False` in the `Deleted` column.
+        # pd.Dataframe().all() will return `True` if all elements are `True`.
+        self.assertTrue(df["Added"].all())
+        self.assertTrue((~df["Deleted"]).all())
+
+        # There should be 74 unique key differences
+        self.assertEqual(len(df), 74)
+
+        # Expected Result for key 'schemas.File'
+        # Key            Added   Deleted  Name   Version  ChangeType  Count
+        # schemas.File   True    False    drive      v3           2    168
+        self.assertTrue(df[df["Key"] == "schemas.File"].Added.iloc[0])
+        self.assertFalse(df[df["Key"] == "schemas.File"].Deleted.iloc[0])
+        self.assertEqual(
+            df[df["Key"] == "schemas.File"].ChangeType.iloc[0], ChangeType.ADDED
+        )
+        self.assertEqual(df[df["Key"] == "schemas.File"].Count.iloc[0], 168)
+
+    def test_get_discovery_differences_for_deleted_doc_returns_expected_dataframe(self):
+        df = self.cs._get_discovery_differences("cloudtasks.v2.json")
+        # Assuming that `cloudtasks.v2.json` is a discovery artifact that doesn't
+        # exist in `NEW_ARTIFACTS_DIR`.
+        self.assertEqual(df["Name"].iloc[0], "cloudtasks")
+        self.assertEqual(df["Version"].iloc[0], "v2")
+
+        # All rows in the dataframe should have `False` in the `Added` column
+        # and `True` in the `Deleted` column.
+        # pd.Dataframe().all() will return `True` if all elements are `True`.
+        self.assertTrue((~df["Added"]).all())
+        self.assertTrue(df["Deleted"].all())
+
+        # There should be 72 unique key differences
+        self.assertEqual(len(df), 72)
+
+        # Expected Result for key 'schemas.Task'
+        # Key           Added   Deleted Name        Version  ChangeType  Count
+        # schemas.Task  False     True  cloudtasks      v2           1     18
+        self.assertFalse(df[df["Key"] == "schemas.Task"].Added.iloc[0])
+        self.assertTrue(df[df["Key"] == "schemas.Task"].Deleted.iloc[0])
+        self.assertEqual(
+            df[df["Key"] == "schemas.Task"].ChangeType.iloc[0], ChangeType.DELETED
+        )
+        self.assertEqual(df[df["Key"] == "schemas.Task"].Count.iloc[0], 18)
+
+    def test_get_discovery_differences_for_changed_doc_returns_expected_dataframe(self):
+        # Assuming that `bigquery.v2.json` is a discovery artifact has
+        # changed. There will be a mix of keys being added, changed or deleted.
+        df = self.cs._get_discovery_differences("bigquery.v2.json")
+
+        self.assertEqual(df["Name"].iloc[0], "bigquery")
+        self.assertEqual(df["Version"].iloc[0], "v2")
+
+        # There should be 28 unique key differences
+        # 11 unique keys changed, 13 unique keys added, 4 unique keys deleted
+        self.assertEqual(len(df), 28)
+        self.assertEqual(len(df[df["ChangeType"] == ChangeType.CHANGED]), 11)
+        self.assertEqual(len(df[df["ChangeType"] == ChangeType.ADDED]), 13)
+        self.assertEqual(len(df[df["ChangeType"] == ChangeType.DELETED]), 4)
+
+        # Expected Result for key 'schemas.PrincipalComponentInfo'
+        # Key                             Added  Deleted  Name     Version  ChangeType  Count
+        # schemas.PrincipalComponentInfo  False     True  bigquery v2            1     10
+        key = "schemas.PrincipalComponentInfo"
+        self.assertFalse(df[df["Key"] == key].Added.iloc[0])
+        self.assertTrue(df[df["Key"] == key].Deleted.iloc[0])
+        self.assertEqual(df[df["Key"] == key].ChangeType.iloc[0], ChangeType.DELETED)
+        self.assertEqual(df[df["Key"] == key].Count.iloc[0], 10)
+
+    def test_build_summary_message_returns_expected_result(self):
+        msg = self.cs._build_summary_message(api_name="bigquery", is_feature=True)
+        self.assertEqual(msg, "feat(bigquery): update the api")
+        msg = self.cs._build_summary_message(api_name="bigquery", is_feature=False)
+        self.assertEqual(msg, "fix(bigquery): update the api")
+
+    def test_get_stable_versions(self):
+        # These versions should be considered stable
+        s = pd.Series(["v1", "v1.4", "v1.4.5"])
+        self.assertTrue(self.cs._get_stable_versions(s).all().iloc[0])
+
+        # These versions should not be considered stable
+        s = pd.Series(["v1b1", "v1alpha", "v1beta1"])
+        self.assertTrue((~self.cs._get_stable_versions(s)).all().iloc[0])
+
+    def test_detect_discovery_changes(self):
+        files_changed = ["bigquery.v2.json", "cloudtasks.v2.json", "drive.v3.json"]
+        cs = ChangeSummary(
+            NEW_ARTIFACTS_DIR, CURRENT_ARTIFACTS_DIR, TEMP_DIR, files_changed
+        )
+        cs.detect_discovery_changes()
+        print("test")
+        result = pd.read_csv(TEMP_DIR / "allapis.dataframe")
+
+        # bigquery was added
+        # 28 key changes in total.
+        # 11 unique keys changed, 13 unique keys added, 4 unique keys deleted
+        self.assertEqual(len(result[result["Name"] == "bigquery"]), 28)
+        self.assertEqual(
+            len(result[(result["Name"] == "bigquery") & result["Added"]]), 13
+        )
+        self.assertEqual(
+            len(result[(result["Name"] == "bigquery") & result["Deleted"]]), 4
+        )
+        self.assertTrue(result[result["Name"] == "bigquery"].IsStable.all())
+        self.assertTrue(result[result["Name"] == "bigquery"].IsFeatureAggregate.all())
+        self.assertEqual(
+            result[result["Name"] == "bigquery"].Summary.iloc[0],
+            "feat(bigquery): update the api",
+        )
+
+        # cloudtasks was deleted
+        # 72 key changes in total. All 72 key changes should be deletions.
+        self.assertEqual(len(result[result["Name"] == "cloudtasks"]), 72)
+        self.assertEqual(
+            len(result[(result["Name"] == "cloudtasks") & result["Added"]]), 0
+        )
+        self.assertEqual(
+            len(result[(result["Name"] == "cloudtasks") & result["Deleted"]]), 72
+        )
+        self.assertTrue(result[(result["Name"] == "cloudtasks")].IsStable.all())
+        self.assertTrue(
+            result[(result["Name"] == "cloudtasks")].IsFeatureAggregate.all()
+        )
+        self.assertEqual(
+            result[(result["Name"] == "cloudtasks")].Summary.iloc[0],
+            "feat(cloudtasks): update the api",
+        )
+
+        # drive was updated
+        # 74 key changes in total. All 74 key changes should be additions
+        self.assertEqual(len(result[result["Name"] == "drive"]), 74)
+        self.assertEqual(
+            len(result[(result["Name"] == "drive") & result["Added"]]), 74
+        )
+        self.assertEqual(
+            len(result[(result["Name"] == "drive") & result["Deleted"]]), 0
+        )
+        self.assertTrue(result[(result["Name"] == "drive")].IsStable.all())
+        self.assertTrue(
+            result[(result["Name"] == "drive")].IsFeatureAggregate.all()
+        )
+        self.assertEqual(
+            result[(result["Name"] == "drive")].Summary.iloc[0],
+            "feat(drive): update the api",
+        )
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/createcommits.sh b/scripts/createcommits.sh
new file mode 100755
index 0000000..c6c23f3
--- /dev/null
+++ b/scripts/createcommits.sh
@@ -0,0 +1,52 @@
+#!/bin/bash
+# Copyright 2021 Google LLC
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     https://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# If this is a github job, configure git
+if [[ $GITHUB_JOB ]]; then
+    git config --global user.name 'Yoshi Automation'
+    git config --global user.email 'yoshi-automation@google.com'
+fi
+
+while read api;
+do
+    name=`echo $api | cut -d '.' -f 1`
+    API_SUMMARY_PATH=temp/$name.verbose
+
+    if [[ ! -f "temp/$name.sha" ]]; then
+        if [ $name = "index" ]; then
+            git add '../docs/dyn/index.md'
+            commitmsg='chore: update docs/dyn/index.md'
+        else
+            git add '../googleapiclient/discovery_cache/documents/'$name'.*.json'
+            git add '../docs/dyn/'$name'_*.html'
+            if [[ -f "$API_SUMMARY_PATH" ]]; then
+                commitmsg=`cat $API_SUMMARY_PATH`
+            else
+                commitmsg='chore('$name'): update the api'
+            fi
+        fi
+        git commit -m "$commitmsg"
+        git rev-parse HEAD>temp/$name'.sha'
+        git reset
+    fi
+done < temp/changed_files
+
+# Add untracked files
+git add "../googleapiclient/discovery_cache/documents/*.json"
+git add "../docs/dyn/*.html"
+commitmsg='chore(docs): Add new discovery artifacts and reference documents'
+git commit -m "$commitmsg"
+
+exit 0
diff --git a/scripts/requirements.txt b/scripts/requirements.txt
new file mode 100644
index 0000000..b60117f
--- /dev/null
+++ b/scripts/requirements.txt
@@ -0,0 +1 @@
+pandas==1.2.2
diff --git a/scripts/test_resources/current_artifacts_dir/bigquery.v2.json b/scripts/test_resources/current_artifacts_dir/bigquery.v2.json
new file mode 100644
index 0000000..b342837
--- /dev/null
+++ b/scripts/test_resources/current_artifacts_dir/bigquery.v2.json
@@ -0,0 +1,6518 @@
+{
+    "auth": {
+        "oauth2": {
+            "scopes": {
+                "https://www.googleapis.com/auth/bigquery": {
+                    "description": "View and manage your data in Google BigQuery"
+                },
+                "https://www.googleapis.com/auth/bigquery.insertdata": {
+                    "description": "Insert data into Google BigQuery"
+                },
+                "https://www.googleapis.com/auth/bigquery.readonly": {
+                    "description": "View your data in Google BigQuery"
+                },
+                "https://www.googleapis.com/auth/cloud-platform": {
+                    "description": "See, edit, configure, and delete your Google Cloud Platform data"
+                },
+                "https://www.googleapis.com/auth/cloud-platform.read-only": {
+                    "description": "View your data across Google Cloud Platform services"
+                },
+                "https://www.googleapis.com/auth/devstorage.full_control": {
+                    "description": "Manage your data and permissions in Google Cloud Storage"
+                },
+                "https://www.googleapis.com/auth/devstorage.read_only": {
+                    "description": "View your data in Google Cloud Storage"
+                },
+                "https://www.googleapis.com/auth/devstorage.read_write": {
+                    "description": "Manage your data in Google Cloud Storage"
+                }
+            }
+        }
+    },
+    "basePath": "/bigquery/v2/",
+    "baseUrl": "https://bigquery.googleapis.com/bigquery/v2/",
+    "batchPath": "batch/bigquery/v2",
+    "description": "A data platform for customers to create, manage, share and query data.",
+    "discoveryVersion": "v1",
+    "documentationLink": "https://cloud.google.com/bigquery/",
+    "icons": {
+        "x16": "https://www.google.com/images/icons/product/search-16.gif",
+        "x32": "https://www.google.com/images/icons/product/search-32.gif"
+    },
+    "id": "bigquery:v2",
+    "kind": "discovery#restDescription",
+    "mtlsRootUrl": "https://bigquery.mtls.googleapis.com/",
+    "name": "bigquery",
+    "ownerDomain": "google.com",
+    "ownerName": "Google",
+    "parameters": {
+        "alt": {
+            "default": "json",
+            "description": "Data format for the response.",
+            "enum": [
+                "json"
+            ],
+            "enumDescriptions": [
+                "Responses with Content-Type of application/json"
+            ],
+            "location": "query",
+            "type": "string"
+        },
+        "fields": {
+            "description": "Selector specifying which fields to include in a partial response.",
+            "location": "query",
+            "type": "string"
+        },
+        "key": {
+            "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.",
+            "location": "query",
+            "type": "string"
+        },
+        "oauth_token": {
+            "description": "OAuth 2.0 token for the current user.",
+            "location": "query",
+            "type": "string"
+        },
+        "prettyPrint": {
+            "default": "true",
+            "description": "Returns response with indentations and line breaks.",
+            "location": "query",
+            "type": "boolean"
+        },
+        "quotaUser": {
+            "description": "An opaque string that represents a user for quota purposes. Must not exceed 40 characters.",
+            "location": "query",
+            "type": "string"
+        },
+        "userIp": {
+            "description": "Deprecated. Please use quotaUser instead.",
+            "location": "query",
+            "type": "string"
+        }
+    },
+    "protocol": "rest",
+    "resources": {
+        "datasets": {
+            "methods": {
+                "delete": {
+                    "description": "Deletes the dataset specified by the datasetId value. Before you can delete a dataset, you must delete all its tables, either manually or by specifying deleteContents. Immediately after deletion, you can create another dataset with the same name.",
+                    "httpMethod": "DELETE",
+                    "id": "bigquery.datasets.delete",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of dataset being deleted",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "deleteContents": {
+                            "description": "If True, delete all the tables in the dataset. If False and the dataset contains tables, the request will fail. Default is False",
+                            "location": "query",
+                            "type": "boolean"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the dataset being deleted",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}",
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "get": {
+                    "description": "Returns the dataset specified by datasetID.",
+                    "httpMethod": "GET",
+                    "id": "bigquery.datasets.get",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the requested dataset",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the requested dataset",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}",
+                    "response": {
+                        "$ref": "Dataset"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "insert": {
+                    "description": "Creates a new empty dataset.",
+                    "httpMethod": "POST",
+                    "id": "bigquery.datasets.insert",
+                    "parameterOrder": [
+                        "projectId"
+                    ],
+                    "parameters": {
+                        "projectId": {
+                            "description": "Project ID of the new dataset",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets",
+                    "request": {
+                        "$ref": "Dataset"
+                    },
+                    "response": {
+                        "$ref": "Dataset"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "list": {
+                    "description": "Lists all datasets in the specified project to which you have been granted the READER dataset role.",
+                    "httpMethod": "GET",
+                    "id": "bigquery.datasets.list",
+                    "parameterOrder": [
+                        "projectId"
+                    ],
+                    "parameters": {
+                        "all": {
+                            "description": "Whether to list all datasets, including hidden ones",
+                            "location": "query",
+                            "type": "boolean"
+                        },
+                        "filter": {
+                            "description": "An expression for filtering the results of the request by label. The syntax is \"labels.<name>[:<value>]\". Multiple filters can be ANDed together by connecting with a space. Example: \"labels.department:receiving labels.active\". See Filtering datasets using labels for details.",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "maxResults": {
+                            "description": "The maximum number of results to return",
+                            "format": "uint32",
+                            "location": "query",
+                            "type": "integer"
+                        },
+                        "pageToken": {
+                            "description": "Page token, returned by a previous call, to request the next page of results",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the datasets to be listed",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets",
+                    "response": {
+                        "$ref": "DatasetList"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "patch": {
+                    "description": "Updates information in an existing dataset. The update method replaces the entire dataset resource, whereas the patch method only replaces fields that are provided in the submitted dataset resource. This method supports patch semantics.",
+                    "httpMethod": "PATCH",
+                    "id": "bigquery.datasets.patch",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the dataset being updated",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the dataset being updated",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}",
+                    "request": {
+                        "$ref": "Dataset"
+                    },
+                    "response": {
+                        "$ref": "Dataset"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "update": {
+                    "description": "Updates information in an existing dataset. The update method replaces the entire dataset resource, whereas the patch method only replaces fields that are provided in the submitted dataset resource.",
+                    "httpMethod": "PUT",
+                    "id": "bigquery.datasets.update",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the dataset being updated",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the dataset being updated",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}",
+                    "request": {
+                        "$ref": "Dataset"
+                    },
+                    "response": {
+                        "$ref": "Dataset"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                }
+            }
+        },
+        "jobs": {
+            "methods": {
+                "cancel": {
+                    "description": "Requests that a job be cancelled. This call will return immediately, and the client will need to poll for the job status to see if the cancel completed successfully. Cancelled jobs may still incur costs.",
+                    "httpMethod": "POST",
+                    "id": "bigquery.jobs.cancel",
+                    "parameterOrder": [
+                        "projectId",
+                        "jobId"
+                    ],
+                    "parameters": {
+                        "jobId": {
+                            "description": "[Required] Job ID of the job to cancel",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "location": {
+                            "description": "The geographic location of the job. Required except for US and EU. See details at https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "[Required] Project ID of the job to cancel",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/jobs/{jobId}/cancel",
+                    "response": {
+                        "$ref": "JobCancelResponse"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "get": {
+                    "description": "Returns information about a specific job. Job information is available for a six month period after creation. Requires that you're the person who ran the job, or have the Is Owner project role.",
+                    "httpMethod": "GET",
+                    "id": "bigquery.jobs.get",
+                    "parameterOrder": [
+                        "projectId",
+                        "jobId"
+                    ],
+                    "parameters": {
+                        "jobId": {
+                            "description": "[Required] Job ID of the requested job",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "location": {
+                            "description": "The geographic location of the job. Required except for US and EU. See details at https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "[Required] Project ID of the requested job",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/jobs/{jobId}",
+                    "response": {
+                        "$ref": "Job"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "getQueryResults": {
+                    "description": "Retrieves the results of a query job.",
+                    "httpMethod": "GET",
+                    "id": "bigquery.jobs.getQueryResults",
+                    "parameterOrder": [
+                        "projectId",
+                        "jobId"
+                    ],
+                    "parameters": {
+                        "jobId": {
+                            "description": "[Required] Job ID of the query job",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "location": {
+                            "description": "The geographic location where the job should run. Required except for US and EU. See details at https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "maxResults": {
+                            "description": "Maximum number of results to read",
+                            "format": "uint32",
+                            "location": "query",
+                            "type": "integer"
+                        },
+                        "pageToken": {
+                            "description": "Page token, returned by a previous call, to request the next page of results",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "[Required] Project ID of the query job",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "startIndex": {
+                            "description": "Zero-based index of the starting row",
+                            "format": "uint64",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "timeoutMs": {
+                            "description": "How long to wait for the query to complete, in milliseconds, before returning. Default is 10 seconds. If the timeout passes before the job completes, the 'jobComplete' field in the response will be false",
+                            "format": "uint32",
+                            "location": "query",
+                            "type": "integer"
+                        }
+                    },
+                    "path": "projects/{projectId}/queries/{jobId}",
+                    "response": {
+                        "$ref": "GetQueryResultsResponse"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "insert": {
+                    "description": "Starts a new asynchronous job. Requires the Can View project role.",
+                    "httpMethod": "POST",
+                    "id": "bigquery.jobs.insert",
+                    "mediaUpload": {
+                        "accept": [
+                            "*/*"
+                        ],
+                        "protocols": {
+                            "resumable": {
+                                "multipart": true,
+                                "path": "/resumable/upload/bigquery/v2/projects/{projectId}/jobs"
+                            },
+                            "simple": {
+                                "multipart": true,
+                                "path": "/upload/bigquery/v2/projects/{projectId}/jobs"
+                            }
+                        }
+                    },
+                    "parameterOrder": [
+                        "projectId"
+                    ],
+                    "parameters": {
+                        "projectId": {
+                            "description": "Project ID of the project that will be billed for the job",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/jobs",
+                    "request": {
+                        "$ref": "Job"
+                    },
+                    "response": {
+                        "$ref": "Job"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/devstorage.full_control",
+                        "https://www.googleapis.com/auth/devstorage.read_only",
+                        "https://www.googleapis.com/auth/devstorage.read_write"
+                    ],
+                    "supportsMediaUpload": true
+                },
+                "list": {
+                    "description": "Lists all jobs that you started in the specified project. Job information is available for a six month period after creation. The job list is sorted in reverse chronological order, by job creation time. Requires the Can View project role, or the Is Owner project role if you set the allUsers property.",
+                    "httpMethod": "GET",
+                    "id": "bigquery.jobs.list",
+                    "parameterOrder": [
+                        "projectId"
+                    ],
+                    "parameters": {
+                        "allUsers": {
+                            "description": "Whether to display jobs owned by all users in the project. Default false",
+                            "location": "query",
+                            "type": "boolean"
+                        },
+                        "maxCreationTime": {
+                            "description": "Max value for job creation time, in milliseconds since the POSIX epoch. If set, only jobs created before or at this timestamp are returned",
+                            "format": "uint64",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "maxResults": {
+                            "description": "Maximum number of results to return",
+                            "format": "uint32",
+                            "location": "query",
+                            "type": "integer"
+                        },
+                        "minCreationTime": {
+                            "description": "Min value for job creation time, in milliseconds since the POSIX epoch. If set, only jobs created after or at this timestamp are returned",
+                            "format": "uint64",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "pageToken": {
+                            "description": "Page token, returned by a previous call, to request the next page of results",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "parentJobId": {
+                            "description": "If set, retrieves only jobs whose parent is this job. Otherwise, retrieves only jobs which have no parent",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the jobs to list",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projection": {
+                            "description": "Restrict information returned to a set of selected fields",
+                            "enum": [
+                                "full",
+                                "minimal"
+                            ],
+                            "enumDescriptions": [
+                                "Includes all job data",
+                                "Does not include the job configuration"
+                            ],
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "stateFilter": {
+                            "description": "Filter for job state",
+                            "enum": [
+                                "done",
+                                "pending",
+                                "running"
+                            ],
+                            "enumDescriptions": [
+                                "Finished jobs",
+                                "Pending jobs",
+                                "Running jobs"
+                            ],
+                            "location": "query",
+                            "repeated": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/jobs",
+                    "response": {
+                        "$ref": "JobList"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "query": {
+                    "description": "Runs a BigQuery SQL query synchronously and returns query results if the query completes within a specified timeout.",
+                    "httpMethod": "POST",
+                    "id": "bigquery.jobs.query",
+                    "parameterOrder": [
+                        "projectId"
+                    ],
+                    "parameters": {
+                        "projectId": {
+                            "description": "Project ID of the project billed for the query",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/queries",
+                    "request": {
+                        "$ref": "QueryRequest"
+                    },
+                    "response": {
+                        "$ref": "QueryResponse"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                }
+            }
+        },
+        "models": {
+            "methods": {
+                "delete": {
+                    "description": "Deletes the model specified by modelId from the dataset.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/models/{modelsId}",
+                    "httpMethod": "DELETE",
+                    "id": "bigquery.models.delete",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "modelId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Required. Dataset ID of the model to delete.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "modelId": {
+                            "description": "Required. Model ID of the model to delete.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Required. Project ID of the model to delete.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{+projectId}/datasets/{+datasetId}/models/{+modelId}",
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "get": {
+                    "description": "Gets the specified model resource by model ID.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/models/{modelsId}",
+                    "httpMethod": "GET",
+                    "id": "bigquery.models.get",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "modelId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Required. Dataset ID of the requested model.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "modelId": {
+                            "description": "Required. Model ID of the requested model.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Required. Project ID of the requested model.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{+projectId}/datasets/{+datasetId}/models/{+modelId}",
+                    "response": {
+                        "$ref": "Model"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "list": {
+                    "description": "Lists all models in the specified dataset. Requires the READER dataset role.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/models",
+                    "httpMethod": "GET",
+                    "id": "bigquery.models.list",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Required. Dataset ID of the models to list.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "maxResults": {
+                            "description": "The maximum number of results to return in a single response page. Leverage the page tokens to iterate through the entire collection.",
+                            "format": "uint32",
+                            "location": "query",
+                            "type": "integer"
+                        },
+                        "pageToken": {
+                            "description": "Page token, returned by a previous call to request the next page of results",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Required. Project ID of the models to list.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{+projectId}/datasets/{+datasetId}/models",
+                    "response": {
+                        "$ref": "ListModelsResponse"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "patch": {
+                    "description": "Patch specific fields in the specified model.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/models/{modelsId}",
+                    "httpMethod": "PATCH",
+                    "id": "bigquery.models.patch",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "modelId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Required. Dataset ID of the model to patch.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "modelId": {
+                            "description": "Required. Model ID of the model to patch.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Required. Project ID of the model to patch.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{+projectId}/datasets/{+datasetId}/models/{+modelId}",
+                    "request": {
+                        "$ref": "Model"
+                    },
+                    "response": {
+                        "$ref": "Model"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                }
+            }
+        },
+        "projects": {
+            "methods": {
+                "getServiceAccount": {
+                    "description": "Returns the email address of the service account for your project used for interactions with Google Cloud KMS.",
+                    "httpMethod": "GET",
+                    "id": "bigquery.projects.getServiceAccount",
+                    "parameterOrder": [
+                        "projectId"
+                    ],
+                    "parameters": {
+                        "projectId": {
+                            "description": "Project ID for which the service account is requested.",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/serviceAccount",
+                    "response": {
+                        "$ref": "GetServiceAccountResponse"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "list": {
+                    "description": "Lists all projects to which you have been granted any project role.",
+                    "httpMethod": "GET",
+                    "id": "bigquery.projects.list",
+                    "parameters": {
+                        "maxResults": {
+                            "description": "Maximum number of results to return",
+                            "format": "uint32",
+                            "location": "query",
+                            "type": "integer"
+                        },
+                        "pageToken": {
+                            "description": "Page token, returned by a previous call, to request the next page of results",
+                            "location": "query",
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects",
+                    "response": {
+                        "$ref": "ProjectList"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                }
+            }
+        },
+        "routines": {
+            "methods": {
+                "delete": {
+                    "description": "Deletes the routine specified by routineId from the dataset.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/routines/{routinesId}",
+                    "httpMethod": "DELETE",
+                    "id": "bigquery.routines.delete",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "routineId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Required. Dataset ID of the routine to delete",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Required. Project ID of the routine to delete",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "routineId": {
+                            "description": "Required. Routine ID of the routine to delete",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{+projectId}/datasets/{+datasetId}/routines/{+routineId}",
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "get": {
+                    "description": "Gets the specified routine resource by routine ID.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/routines/{routinesId}",
+                    "httpMethod": "GET",
+                    "id": "bigquery.routines.get",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "routineId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Required. Dataset ID of the requested routine",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Required. Project ID of the requested routine",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "readMask": {
+                            "description": "If set, only the Routine fields in the field mask are returned in the response. If unset, all Routine fields are returned.",
+                            "format": "google-fieldmask",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "routineId": {
+                            "description": "Required. Routine ID of the requested routine",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{+projectId}/datasets/{+datasetId}/routines/{+routineId}",
+                    "response": {
+                        "$ref": "Routine"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "insert": {
+                    "description": "Creates a new routine in the dataset.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/routines",
+                    "httpMethod": "POST",
+                    "id": "bigquery.routines.insert",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Required. Dataset ID of the new routine",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Required. Project ID of the new routine",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{+projectId}/datasets/{+datasetId}/routines",
+                    "request": {
+                        "$ref": "Routine"
+                    },
+                    "response": {
+                        "$ref": "Routine"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "list": {
+                    "description": "Lists all routines in the specified dataset. Requires the READER dataset role.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/routines",
+                    "httpMethod": "GET",
+                    "id": "bigquery.routines.list",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Required. Dataset ID of the routines to list",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "filter": {
+                            "description": "If set, then only the Routines matching this filter are returned. The current supported form is either \"routine_type:\" or \"routineType:\", where is a RoutineType enum. Example: \"routineType:SCALAR_FUNCTION\".",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "maxResults": {
+                            "description": "The maximum number of results to return in a single response page. Leverage the page tokens to iterate through the entire collection.",
+                            "format": "uint32",
+                            "location": "query",
+                            "type": "integer"
+                        },
+                        "pageToken": {
+                            "description": "Page token, returned by a previous call, to request the next page of results",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Required. Project ID of the routines to list",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "readMask": {
+                            "description": "If set, then only the Routine fields in the field mask, as well as project_id, dataset_id and routine_id, are returned in the response. If unset, then the following Routine fields are returned: etag, project_id, dataset_id, routine_id, routine_type, creation_time, last_modified_time, and language.",
+                            "format": "google-fieldmask",
+                            "location": "query",
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{+projectId}/datasets/{+datasetId}/routines",
+                    "response": {
+                        "$ref": "ListRoutinesResponse"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "update": {
+                    "description": "Updates information in an existing routine. The update method replaces the entire Routine resource.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/routines/{routinesId}",
+                    "httpMethod": "PUT",
+                    "id": "bigquery.routines.update",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "routineId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Required. Dataset ID of the routine to update",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Required. Project ID of the routine to update",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "routineId": {
+                            "description": "Required. Routine ID of the routine to update",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{+projectId}/datasets/{+datasetId}/routines/{+routineId}",
+                    "request": {
+                        "$ref": "Routine"
+                    },
+                    "response": {
+                        "$ref": "Routine"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                }
+            }
+        },
+        "rowAccessPolicies": {
+            "methods": {
+                "getIamPolicy": {
+                    "description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}/rowAccessPolicies/{rowAccessPoliciesId}:getIamPolicy",
+                    "httpMethod": "POST",
+                    "id": "bigquery.rowAccessPolicies.getIamPolicy",
+                    "parameterOrder": [
+                        "resource"
+                    ],
+                    "parameters": {
+                        "resource": {
+                            "description": "REQUIRED: The resource for which the policy is being requested. See the operation documentation for the appropriate value for this field.",
+                            "location": "path",
+                            "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+/rowAccessPolicies/[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "{+resource}:getIamPolicy",
+                    "request": {
+                        "$ref": "GetIamPolicyRequest"
+                    },
+                    "response": {
+                        "$ref": "Policy"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "list": {
+                    "description": "Lists all row access policies on the specified table.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}/rowAccessPolicies",
+                    "httpMethod": "GET",
+                    "id": "bigquery.rowAccessPolicies.list",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "tableId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Required. Dataset ID of row access policies to list.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "pageSize": {
+                            "description": "The maximum number of results to return in a single response page. Leverage the page tokens to iterate through the entire collection.",
+                            "format": "int32",
+                            "location": "query",
+                            "type": "integer"
+                        },
+                        "pageToken": {
+                            "description": "Page token, returned by a previous call, to request the next page of results.",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Required. Project ID of the row access policies to list.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "tableId": {
+                            "description": "Required. Table ID of the table to list row access policies.",
+                            "location": "path",
+                            "pattern": "^[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}/rowAccessPolicies",
+                    "response": {
+                        "$ref": "ListRowAccessPoliciesResponse"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "setIamPolicy": {
+                    "description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}/rowAccessPolicies/{rowAccessPoliciesId}:setIamPolicy",
+                    "httpMethod": "POST",
+                    "id": "bigquery.rowAccessPolicies.setIamPolicy",
+                    "parameterOrder": [
+                        "resource"
+                    ],
+                    "parameters": {
+                        "resource": {
+                            "description": "REQUIRED: The resource for which the policy is being specified. See the operation documentation for the appropriate value for this field.",
+                            "location": "path",
+                            "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+/rowAccessPolicies/[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "{+resource}:setIamPolicy",
+                    "request": {
+                        "$ref": "SetIamPolicyRequest"
+                    },
+                    "response": {
+                        "$ref": "Policy"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "testIamPermissions": {
+                    "description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}/rowAccessPolicies/{rowAccessPoliciesId}:testIamPermissions",
+                    "httpMethod": "POST",
+                    "id": "bigquery.rowAccessPolicies.testIamPermissions",
+                    "parameterOrder": [
+                        "resource"
+                    ],
+                    "parameters": {
+                        "resource": {
+                            "description": "REQUIRED: The resource for which the policy detail is being requested. See the operation documentation for the appropriate value for this field.",
+                            "location": "path",
+                            "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+/rowAccessPolicies/[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "{+resource}:testIamPermissions",
+                    "request": {
+                        "$ref": "TestIamPermissionsRequest"
+                    },
+                    "response": {
+                        "$ref": "TestIamPermissionsResponse"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                }
+            }
+        },
+        "tabledata": {
+            "methods": {
+                "insertAll": {
+                    "description": "Streams data into BigQuery one record at a time without needing to run a load job. Requires the WRITER dataset role.",
+                    "httpMethod": "POST",
+                    "id": "bigquery.tabledata.insertAll",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "tableId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the destination table.",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the destination table.",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "tableId": {
+                            "description": "Table ID of the destination table.",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}/insertAll",
+                    "request": {
+                        "$ref": "TableDataInsertAllRequest"
+                    },
+                    "response": {
+                        "$ref": "TableDataInsertAllResponse"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.insertdata",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "list": {
+                    "description": "Retrieves table data from a specified set of rows. Requires the READER dataset role.",
+                    "httpMethod": "GET",
+                    "id": "bigquery.tabledata.list",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "tableId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the table to read",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "maxResults": {
+                            "description": "Maximum number of results to return",
+                            "format": "uint32",
+                            "location": "query",
+                            "type": "integer"
+                        },
+                        "pageToken": {
+                            "description": "Page token, returned by a previous call, identifying the result set",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the table to read",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "selectedFields": {
+                            "description": "List of fields to return (comma-separated). If unspecified, all fields are returned",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "startIndex": {
+                            "description": "Zero-based index of the starting row to read",
+                            "format": "uint64",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "tableId": {
+                            "description": "Table ID of the table to read",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}/data",
+                    "response": {
+                        "$ref": "TableDataList"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                }
+            }
+        },
+        "tables": {
+            "methods": {
+                "delete": {
+                    "description": "Deletes the table specified by tableId from the dataset. If the table contains data, all the data will be deleted.",
+                    "httpMethod": "DELETE",
+                    "id": "bigquery.tables.delete",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "tableId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the table to delete",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the table to delete",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "tableId": {
+                            "description": "Table ID of the table to delete",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}",
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "get": {
+                    "description": "Gets the specified table resource by table ID. This method does not return the data in the table, it only returns the table resource, which describes the structure of this table.",
+                    "httpMethod": "GET",
+                    "id": "bigquery.tables.get",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "tableId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the requested table",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the requested table",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "selectedFields": {
+                            "description": "List of fields to return (comma-separated). If unspecified, all fields are returned",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "tableId": {
+                            "description": "Table ID of the requested table",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}",
+                    "response": {
+                        "$ref": "Table"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "getIamPolicy": {
+                    "description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}:getIamPolicy",
+                    "httpMethod": "POST",
+                    "id": "bigquery.tables.getIamPolicy",
+                    "parameterOrder": [
+                        "resource"
+                    ],
+                    "parameters": {
+                        "resource": {
+                            "description": "REQUIRED: The resource for which the policy is being requested. See the operation documentation for the appropriate value for this field.",
+                            "location": "path",
+                            "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "{+resource}:getIamPolicy",
+                    "request": {
+                        "$ref": "GetIamPolicyRequest"
+                    },
+                    "response": {
+                        "$ref": "Policy"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "insert": {
+                    "description": "Creates a new, empty table in the dataset.",
+                    "httpMethod": "POST",
+                    "id": "bigquery.tables.insert",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the new table",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the new table",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}/tables",
+                    "request": {
+                        "$ref": "Table"
+                    },
+                    "response": {
+                        "$ref": "Table"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "list": {
+                    "description": "Lists all tables in the specified dataset. Requires the READER dataset role.",
+                    "httpMethod": "GET",
+                    "id": "bigquery.tables.list",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the tables to list",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "maxResults": {
+                            "description": "Maximum number of results to return",
+                            "format": "uint32",
+                            "location": "query",
+                            "type": "integer"
+                        },
+                        "pageToken": {
+                            "description": "Page token, returned by a previous call, to request the next page of results",
+                            "location": "query",
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the tables to list",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}/tables",
+                    "response": {
+                        "$ref": "TableList"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "patch": {
+                    "description": "Updates information in an existing table. The update method replaces the entire table resource, whereas the patch method only replaces fields that are provided in the submitted table resource. This method supports patch semantics.",
+                    "httpMethod": "PATCH",
+                    "id": "bigquery.tables.patch",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "tableId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the table to update",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the table to update",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "tableId": {
+                            "description": "Table ID of the table to update",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}",
+                    "request": {
+                        "$ref": "Table"
+                    },
+                    "response": {
+                        "$ref": "Table"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "setIamPolicy": {
+                    "description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}:setIamPolicy",
+                    "httpMethod": "POST",
+                    "id": "bigquery.tables.setIamPolicy",
+                    "parameterOrder": [
+                        "resource"
+                    ],
+                    "parameters": {
+                        "resource": {
+                            "description": "REQUIRED: The resource for which the policy is being specified. See the operation documentation for the appropriate value for this field.",
+                            "location": "path",
+                            "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "{+resource}:setIamPolicy",
+                    "request": {
+                        "$ref": "SetIamPolicyRequest"
+                    },
+                    "response": {
+                        "$ref": "Policy"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                },
+                "testIamPermissions": {
+                    "description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.",
+                    "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}:testIamPermissions",
+                    "httpMethod": "POST",
+                    "id": "bigquery.tables.testIamPermissions",
+                    "parameterOrder": [
+                        "resource"
+                    ],
+                    "parameters": {
+                        "resource": {
+                            "description": "REQUIRED: The resource for which the policy detail is being requested. See the operation documentation for the appropriate value for this field.",
+                            "location": "path",
+                            "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+$",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "{+resource}:testIamPermissions",
+                    "request": {
+                        "$ref": "TestIamPermissionsRequest"
+                    },
+                    "response": {
+                        "$ref": "TestIamPermissionsResponse"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/bigquery.readonly",
+                        "https://www.googleapis.com/auth/cloud-platform",
+                        "https://www.googleapis.com/auth/cloud-platform.read-only"
+                    ]
+                },
+                "update": {
+                    "description": "Updates information in an existing table. The update method replaces the entire table resource, whereas the patch method only replaces fields that are provided in the submitted table resource.",
+                    "httpMethod": "PUT",
+                    "id": "bigquery.tables.update",
+                    "parameterOrder": [
+                        "projectId",
+                        "datasetId",
+                        "tableId"
+                    ],
+                    "parameters": {
+                        "datasetId": {
+                            "description": "Dataset ID of the table to update",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "projectId": {
+                            "description": "Project ID of the table to update",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        },
+                        "tableId": {
+                            "description": "Table ID of the table to update",
+                            "location": "path",
+                            "required": true,
+                            "type": "string"
+                        }
+                    },
+                    "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}",
+                    "request": {
+                        "$ref": "Table"
+                    },
+                    "response": {
+                        "$ref": "Table"
+                    },
+                    "scopes": [
+                        "https://www.googleapis.com/auth/bigquery",
+                        "https://www.googleapis.com/auth/cloud-platform"
+                    ]
+                }
+            }
+        }
+    },
+    "revision": "20210313",
+    "rootUrl": "https://bigquery.googleapis.com/",
+    "schemas": {
+        "AggregateClassificationMetrics": {
+            "description": "Aggregate metrics for classification/classifier models. For multi-class models, the metrics are either macro-averaged or micro-averaged. When macro-averaged, the metrics are calculated for each label and then an unweighted average is taken of those values. When micro-averaged, the metric is calculated globally by counting the total number of correctly predicted rows.",
+            "id": "AggregateClassificationMetrics",
+            "properties": {
+                "accuracy": {
+                    "description": "Accuracy is the fraction of predictions given the correct label. For multiclass this is a micro-averaged metric.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "f1Score": {
+                    "description": "The F1 score is an average of recall and precision. For multiclass this is a macro-averaged metric.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "logLoss": {
+                    "description": "Logarithmic Loss. For multiclass this is a macro-averaged metric.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "precision": {
+                    "description": "Precision is the fraction of actual positive predictions that had positive actual labels. For multiclass this is a macro-averaged metric treating each class as a binary classifier.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "recall": {
+                    "description": "Recall is the fraction of actual positive labels that were given a positive prediction. For multiclass this is a macro-averaged metric.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "rocAuc": {
+                    "description": "Area Under a ROC Curve. For multiclass this is a macro-averaged metric.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "threshold": {
+                    "description": "Threshold at which the metrics are computed. For binary classification models this is the positive class threshold. For multi-class classfication models this is the confidence threshold.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "Argument": {
+            "description": "Input/output argument of a function or a stored procedure.",
+            "id": "Argument",
+            "properties": {
+                "argumentKind": {
+                    "description": "Optional. Defaults to FIXED_TYPE.",
+                    "enum": [
+                        "ARGUMENT_KIND_UNSPECIFIED",
+                        "FIXED_TYPE",
+                        "ANY_TYPE"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "The argument is a variable with fully specified type, which can be a struct or an array, but not a table.",
+                        "The argument is any type, including struct or array, but not a table. To be added: FIXED_TABLE, ANY_TABLE"
+                    ],
+                    "type": "string"
+                },
+                "dataType": {
+                    "$ref": "StandardSqlDataType",
+                    "description": "Required unless argument_kind = ANY_TYPE."
+                },
+                "mode": {
+                    "description": "Optional. Specifies whether the argument is input or output. Can be set for procedures only.",
+                    "enum": [
+                        "MODE_UNSPECIFIED",
+                        "IN",
+                        "OUT",
+                        "INOUT"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "The argument is input-only.",
+                        "The argument is output-only.",
+                        "The argument is both an input and an output."
+                    ],
+                    "type": "string"
+                },
+                "name": {
+                    "description": "Optional. The name of this argument. Can be absent for function return argument.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "ArimaCoefficients": {
+            "description": "Arima coefficients.",
+            "id": "ArimaCoefficients",
+            "properties": {
+                "autoRegressiveCoefficients": {
+                    "description": "Auto-regressive coefficients, an array of double.",
+                    "items": {
+                        "format": "double",
+                        "type": "number"
+                    },
+                    "type": "array"
+                },
+                "interceptCoefficient": {
+                    "description": "Intercept coefficient, just a double not an array.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "movingAverageCoefficients": {
+                    "description": "Moving-average coefficients, an array of double.",
+                    "items": {
+                        "format": "double",
+                        "type": "number"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "ArimaFittingMetrics": {
+            "description": "ARIMA model fitting metrics.",
+            "id": "ArimaFittingMetrics",
+            "properties": {
+                "aic": {
+                    "description": "AIC.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "logLikelihood": {
+                    "description": "Log-likelihood.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "variance": {
+                    "description": "Variance.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "ArimaForecastingMetrics": {
+            "description": "Model evaluation metrics for ARIMA forecasting models.",
+            "id": "ArimaForecastingMetrics",
+            "properties": {
+                "arimaFittingMetrics": {
+                    "description": "Arima model fitting metrics.",
+                    "items": {
+                        "$ref": "ArimaFittingMetrics"
+                    },
+                    "type": "array"
+                },
+                "arimaSingleModelForecastingMetrics": {
+                    "description": "Repeated as there can be many metric sets (one for each model) in auto-arima and the large-scale case.",
+                    "items": {
+                        "$ref": "ArimaSingleModelForecastingMetrics"
+                    },
+                    "type": "array"
+                },
+                "hasDrift": {
+                    "description": "Whether Arima model fitted with drift or not. It is always false when d is not 1.",
+                    "items": {
+                        "type": "boolean"
+                    },
+                    "type": "array"
+                },
+                "nonSeasonalOrder": {
+                    "description": "Non-seasonal order.",
+                    "items": {
+                        "$ref": "ArimaOrder"
+                    },
+                    "type": "array"
+                },
+                "seasonalPeriods": {
+                    "description": "Seasonal periods. Repeated because multiple periods are supported for one time series.",
+                    "items": {
+                        "enum": [
+                            "SEASONAL_PERIOD_TYPE_UNSPECIFIED",
+                            "NO_SEASONALITY",
+                            "DAILY",
+                            "WEEKLY",
+                            "MONTHLY",
+                            "QUARTERLY",
+                            "YEARLY"
+                        ],
+                        "enumDescriptions": [
+                            "",
+                            "No seasonality",
+                            "Daily period, 24 hours.",
+                            "Weekly period, 7 days.",
+                            "Monthly period, 30 days or irregular.",
+                            "Quarterly period, 90 days or irregular.",
+                            "Yearly period, 365 days or irregular."
+                        ],
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "timeSeriesId": {
+                    "description": "Id to differentiate different time series for the large-scale case.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "ArimaModelInfo": {
+            "description": "Arima model information.",
+            "id": "ArimaModelInfo",
+            "properties": {
+                "arimaCoefficients": {
+                    "$ref": "ArimaCoefficients",
+                    "description": "Arima coefficients."
+                },
+                "arimaFittingMetrics": {
+                    "$ref": "ArimaFittingMetrics",
+                    "description": "Arima fitting metrics."
+                },
+                "hasDrift": {
+                    "description": "Whether Arima model fitted with drift or not. It is always false when d is not 1.",
+                    "type": "boolean"
+                },
+                "nonSeasonalOrder": {
+                    "$ref": "ArimaOrder",
+                    "description": "Non-seasonal order."
+                },
+                "seasonalPeriods": {
+                    "description": "Seasonal periods. Repeated because multiple periods are supported for one time series.",
+                    "items": {
+                        "enum": [
+                            "SEASONAL_PERIOD_TYPE_UNSPECIFIED",
+                            "NO_SEASONALITY",
+                            "DAILY",
+                            "WEEKLY",
+                            "MONTHLY",
+                            "QUARTERLY",
+                            "YEARLY"
+                        ],
+                        "enumDescriptions": [
+                            "",
+                            "No seasonality",
+                            "Daily period, 24 hours.",
+                            "Weekly period, 7 days.",
+                            "Monthly period, 30 days or irregular.",
+                            "Quarterly period, 90 days or irregular.",
+                            "Yearly period, 365 days or irregular."
+                        ],
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "timeSeriesId": {
+                    "description": "The time_series_id value for this time series. It will be one of the unique values from the time_series_id_column specified during ARIMA model training. Only present when time_series_id_column training option was used.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "ArimaOrder": {
+            "description": "Arima order, can be used for both non-seasonal and seasonal parts.",
+            "id": "ArimaOrder",
+            "properties": {
+                "d": {
+                    "description": "Order of the differencing part.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "p": {
+                    "description": "Order of the autoregressive part.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "q": {
+                    "description": "Order of the moving-average part.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "ArimaResult": {
+            "description": "(Auto-)arima fitting result. Wrap everything in ArimaResult for easier refactoring if we want to use model-specific iteration results.",
+            "id": "ArimaResult",
+            "properties": {
+                "arimaModelInfo": {
+                    "description": "This message is repeated because there are multiple arima models fitted in auto-arima. For non-auto-arima model, its size is one.",
+                    "items": {
+                        "$ref": "ArimaModelInfo"
+                    },
+                    "type": "array"
+                },
+                "seasonalPeriods": {
+                    "description": "Seasonal periods. Repeated because multiple periods are supported for one time series.",
+                    "items": {
+                        "enum": [
+                            "SEASONAL_PERIOD_TYPE_UNSPECIFIED",
+                            "NO_SEASONALITY",
+                            "DAILY",
+                            "WEEKLY",
+                            "MONTHLY",
+                            "QUARTERLY",
+                            "YEARLY"
+                        ],
+                        "enumDescriptions": [
+                            "",
+                            "No seasonality",
+                            "Daily period, 24 hours.",
+                            "Weekly period, 7 days.",
+                            "Monthly period, 30 days or irregular.",
+                            "Quarterly period, 90 days or irregular.",
+                            "Yearly period, 365 days or irregular."
+                        ],
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "ArimaSingleModelForecastingMetrics": {
+            "description": "Model evaluation metrics for a single ARIMA forecasting model.",
+            "id": "ArimaSingleModelForecastingMetrics",
+            "properties": {
+                "arimaFittingMetrics": {
+                    "$ref": "ArimaFittingMetrics",
+                    "description": "Arima fitting metrics."
+                },
+                "hasDrift": {
+                    "description": "Is arima model fitted with drift or not. It is always false when d is not 1.",
+                    "type": "boolean"
+                },
+                "nonSeasonalOrder": {
+                    "$ref": "ArimaOrder",
+                    "description": "Non-seasonal order."
+                },
+                "seasonalPeriods": {
+                    "description": "Seasonal periods. Repeated because multiple periods are supported for one time series.",
+                    "items": {
+                        "enum": [
+                            "SEASONAL_PERIOD_TYPE_UNSPECIFIED",
+                            "NO_SEASONALITY",
+                            "DAILY",
+                            "WEEKLY",
+                            "MONTHLY",
+                            "QUARTERLY",
+                            "YEARLY"
+                        ],
+                        "enumDescriptions": [
+                            "",
+                            "No seasonality",
+                            "Daily period, 24 hours.",
+                            "Weekly period, 7 days.",
+                            "Monthly period, 30 days or irregular.",
+                            "Quarterly period, 90 days or irregular.",
+                            "Yearly period, 365 days or irregular."
+                        ],
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "timeSeriesId": {
+                    "description": "The time_series_id value for this time series. It will be one of the unique values from the time_series_id_column specified during ARIMA model training. Only present when time_series_id_column training option was used.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "AuditConfig": {
+            "description": "Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { \"audit_configs\": [ { \"service\": \"allServices\", \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\", \"exempted_members\": [ \"user:jose@example.com\" ] }, { \"log_type\": \"DATA_WRITE\" }, { \"log_type\": \"ADMIN_READ\" } ] }, { \"service\": \"sampleservice.googleapis.com\", \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\" }, { \"log_type\": \"DATA_WRITE\", \"exempted_members\": [ \"user:aliya@example.com\" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts jose@example.com from DATA_READ logging, and aliya@example.com from DATA_WRITE logging.",
+            "id": "AuditConfig",
+            "properties": {
+                "auditLogConfigs": {
+                    "description": "The configuration for logging of each type of permission.",
+                    "items": {
+                        "$ref": "AuditLogConfig"
+                    },
+                    "type": "array"
+                },
+                "service": {
+                    "description": "Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "AuditLogConfig": {
+            "description": "Provides the configuration for logging a type of permissions. Example: { \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\", \"exempted_members\": [ \"user:jose@example.com\" ] }, { \"log_type\": \"DATA_WRITE\" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.",
+            "id": "AuditLogConfig",
+            "properties": {
+                "exemptedMembers": {
+                    "description": "Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "logType": {
+                    "description": "The log type that this config enables.",
+                    "enum": [
+                        "LOG_TYPE_UNSPECIFIED",
+                        "ADMIN_READ",
+                        "DATA_WRITE",
+                        "DATA_READ"
+                    ],
+                    "enumDescriptions": [
+                        "Default case. Should never be this.",
+                        "Admin reads. Example: CloudIAM getIamPolicy",
+                        "Data writes. Example: CloudSQL Users create",
+                        "Data reads. Example: CloudSQL Users list"
+                    ],
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "BigQueryModelTraining": {
+            "id": "BigQueryModelTraining",
+            "properties": {
+                "currentIteration": {
+                    "description": "[Output-only, Beta] Index of current ML training iteration. Updated during create model query job to show job progress.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "expectedTotalIterations": {
+                    "description": "[Output-only, Beta] Expected number of iterations for the create model query job specified as num_iterations in the input query. The actual total number of iterations may be less than this number due to early stop.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "BigtableColumn": {
+            "id": "BigtableColumn",
+            "properties": {
+                "encoding": {
+                    "description": "[Optional] The encoding of the values when the type is not STRING. Acceptable encoding values are: TEXT - indicates values are alphanumeric text strings. BINARY - indicates values are encoded using HBase Bytes.toBytes family of functions. 'encoding' can also be set at the column family level. However, the setting at this level takes precedence if 'encoding' is set at both levels.",
+                    "type": "string"
+                },
+                "fieldName": {
+                    "description": "[Optional] If the qualifier is not a valid BigQuery field identifier i.e. does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as the column field name and is used as field name in queries.",
+                    "type": "string"
+                },
+                "onlyReadLatest": {
+                    "description": "[Optional] If this is set, only the latest version of value in this column are exposed. 'onlyReadLatest' can also be set at the column family level. However, the setting at this level takes precedence if 'onlyReadLatest' is set at both levels.",
+                    "type": "boolean"
+                },
+                "qualifierEncoded": {
+                    "description": "[Required] Qualifier of the column. Columns in the parent column family that has this exact qualifier are exposed as . field. If the qualifier is valid UTF-8 string, it can be specified in the qualifier_string field. Otherwise, a base-64 encoded value must be set to qualifier_encoded. The column field name is the same as the column qualifier. However, if the qualifier is not a valid BigQuery field identifier i.e. does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as field_name.",
+                    "format": "byte",
+                    "type": "string"
+                },
+                "qualifierString": {
+                    "type": "string"
+                },
+                "type": {
+                    "description": "[Optional] The type to convert the value in cells of this column. The values are expected to be encoded using HBase Bytes.toBytes function when using the BINARY encoding value. Following BigQuery types are allowed (case-sensitive) - BYTES STRING INTEGER FLOAT BOOLEAN Default type is BYTES. 'type' can also be set at the column family level. However, the setting at this level takes precedence if 'type' is set at both levels.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "BigtableColumnFamily": {
+            "id": "BigtableColumnFamily",
+            "properties": {
+                "columns": {
+                    "description": "[Optional] Lists of columns that should be exposed as individual fields as opposed to a list of (column name, value) pairs. All columns whose qualifier matches a qualifier in this list can be accessed as .. Other columns can be accessed as a list through .Column field.",
+                    "items": {
+                        "$ref": "BigtableColumn"
+                    },
+                    "type": "array"
+                },
+                "encoding": {
+                    "description": "[Optional] The encoding of the values when the type is not STRING. Acceptable encoding values are: TEXT - indicates values are alphanumeric text strings. BINARY - indicates values are encoded using HBase Bytes.toBytes family of functions. This can be overridden for a specific column by listing that column in 'columns' and specifying an encoding for it.",
+                    "type": "string"
+                },
+                "familyId": {
+                    "description": "Identifier of the column family.",
+                    "type": "string"
+                },
+                "onlyReadLatest": {
+                    "description": "[Optional] If this is set only the latest version of value are exposed for all columns in this column family. This can be overridden for a specific column by listing that column in 'columns' and specifying a different setting for that column.",
+                    "type": "boolean"
+                },
+                "type": {
+                    "description": "[Optional] The type to convert the value in cells of this column family. The values are expected to be encoded using HBase Bytes.toBytes function when using the BINARY encoding value. Following BigQuery types are allowed (case-sensitive) - BYTES STRING INTEGER FLOAT BOOLEAN Default type is BYTES. This can be overridden for a specific column by listing that column in 'columns' and specifying a type for it.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "BigtableOptions": {
+            "id": "BigtableOptions",
+            "properties": {
+                "columnFamilies": {
+                    "description": "[Optional] List of column families to expose in the table schema along with their types. This list restricts the column families that can be referenced in queries and specifies their value types. You can use this list to do type conversions - see the 'type' field for more details. If you leave this list empty, all column families are present in the table schema and their values are read as BYTES. During a query only the column families referenced in that query are read from Bigtable.",
+                    "items": {
+                        "$ref": "BigtableColumnFamily"
+                    },
+                    "type": "array"
+                },
+                "ignoreUnspecifiedColumnFamilies": {
+                    "description": "[Optional] If field is true, then the column families that are not specified in columnFamilies list are not exposed in the table schema. Otherwise, they are read with BYTES type values. The default value is false.",
+                    "type": "boolean"
+                },
+                "readRowkeyAsString": {
+                    "description": "[Optional] If field is true, then the rowkey column families will be read and converted to string. Otherwise they are read with BYTES type values and users need to manually cast them with CAST if necessary. The default value is false.",
+                    "type": "boolean"
+                }
+            },
+            "type": "object"
+        },
+        "BinaryClassificationMetrics": {
+            "description": "Evaluation metrics for binary classification/classifier models.",
+            "id": "BinaryClassificationMetrics",
+            "properties": {
+                "aggregateClassificationMetrics": {
+                    "$ref": "AggregateClassificationMetrics",
+                    "description": "Aggregate classification metrics."
+                },
+                "binaryConfusionMatrixList": {
+                    "description": "Binary confusion matrix at multiple thresholds.",
+                    "items": {
+                        "$ref": "BinaryConfusionMatrix"
+                    },
+                    "type": "array"
+                },
+                "negativeLabel": {
+                    "description": "Label representing the negative class.",
+                    "type": "string"
+                },
+                "positiveLabel": {
+                    "description": "Label representing the positive class.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "BinaryConfusionMatrix": {
+            "description": "Confusion matrix for binary classification models.",
+            "id": "BinaryConfusionMatrix",
+            "properties": {
+                "accuracy": {
+                    "description": "The fraction of predictions given the correct label.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "f1Score": {
+                    "description": "The equally weighted average of recall and precision.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "falseNegatives": {
+                    "description": "Number of false samples predicted as false.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "falsePositives": {
+                    "description": "Number of false samples predicted as true.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "positiveClassThreshold": {
+                    "description": "Threshold value used when computing each of the following metric.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "precision": {
+                    "description": "The fraction of actual positive predictions that had positive actual labels.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "recall": {
+                    "description": "The fraction of actual positive labels that were given a positive prediction.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "trueNegatives": {
+                    "description": "Number of true samples predicted as false.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "truePositives": {
+                    "description": "Number of true samples predicted as true.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "Binding": {
+            "description": "Associates `members` with a `role`.",
+            "id": "Binding",
+            "properties": {
+                "condition": {
+                    "$ref": "Expr",
+                    "description": "The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the members in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies)."
+                },
+                "members": {
+                    "description": "Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. ",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "role": {
+                    "description": "Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "BqmlIterationResult": {
+            "id": "BqmlIterationResult",
+            "properties": {
+                "durationMs": {
+                    "description": "[Output-only, Beta] Time taken to run the training iteration in milliseconds.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "evalLoss": {
+                    "description": "[Output-only, Beta] Eval loss computed on the eval data at the end of the iteration. The eval loss is used for early stopping to avoid overfitting. No eval loss if eval_split_method option is specified as no_split or auto_split with input data size less than 500 rows.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "index": {
+                    "description": "[Output-only, Beta] Index of the ML training iteration, starting from zero for each training run.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "learnRate": {
+                    "description": "[Output-only, Beta] Learning rate used for this iteration, it varies for different training iterations if learn_rate_strategy option is not constant.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "trainingLoss": {
+                    "description": "[Output-only, Beta] Training loss computed on the training data at the end of the iteration. The training loss function is defined by model type.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "BqmlTrainingRun": {
+            "id": "BqmlTrainingRun",
+            "properties": {
+                "iterationResults": {
+                    "description": "[Output-only, Beta] List of each iteration results.",
+                    "items": {
+                        "$ref": "BqmlIterationResult"
+                    },
+                    "type": "array"
+                },
+                "startTime": {
+                    "description": "[Output-only, Beta] Training run start time in milliseconds since the epoch.",
+                    "format": "date-time",
+                    "type": "string"
+                },
+                "state": {
+                    "description": "[Output-only, Beta] Different state applicable for a training run. IN PROGRESS: Training run is in progress. FAILED: Training run ended due to a non-retryable failure. SUCCEEDED: Training run successfully completed. CANCELLED: Training run cancelled by the user.",
+                    "type": "string"
+                },
+                "trainingOptions": {
+                    "description": "[Output-only, Beta] Training options used by this training run. These options are mutable for subsequent training runs. Default values are explicitly stored for options not specified in the input query of the first training run. For subsequent training runs, any option not explicitly specified in the input query will be copied from the previous training run.",
+                    "properties": {
+                        "earlyStop": {
+                            "type": "boolean"
+                        },
+                        "l1Reg": {
+                            "format": "double",
+                            "type": "number"
+                        },
+                        "l2Reg": {
+                            "format": "double",
+                            "type": "number"
+                        },
+                        "learnRate": {
+                            "format": "double",
+                            "type": "number"
+                        },
+                        "learnRateStrategy": {
+                            "type": "string"
+                        },
+                        "lineSearchInitLearnRate": {
+                            "format": "double",
+                            "type": "number"
+                        },
+                        "maxIteration": {
+                            "format": "int64",
+                            "type": "string"
+                        },
+                        "minRelProgress": {
+                            "format": "double",
+                            "type": "number"
+                        },
+                        "warmStart": {
+                            "type": "boolean"
+                        }
+                    },
+                    "type": "object"
+                }
+            },
+            "type": "object"
+        },
+        "CategoricalValue": {
+            "description": "Representative value of a categorical feature.",
+            "id": "CategoricalValue",
+            "properties": {
+                "categoryCounts": {
+                    "description": "Counts of all categories for the categorical feature. If there are more than ten categories, we return top ten (by count) and return one more CategoryCount with category \"_OTHER_\" and count as aggregate counts of remaining categories.",
+                    "items": {
+                        "$ref": "CategoryCount"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "CategoryCount": {
+            "description": "Represents the count of a single category within the cluster.",
+            "id": "CategoryCount",
+            "properties": {
+                "category": {
+                    "description": "The name of category.",
+                    "type": "string"
+                },
+                "count": {
+                    "description": "The count of training samples matching the category within the cluster.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "Cluster": {
+            "description": "Message containing the information about one cluster.",
+            "id": "Cluster",
+            "properties": {
+                "centroidId": {
+                    "description": "Centroid id.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "count": {
+                    "description": "Count of training data rows that were assigned to this cluster.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "featureValues": {
+                    "description": "Values of highly variant features for this cluster.",
+                    "items": {
+                        "$ref": "FeatureValue"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "ClusterInfo": {
+            "description": "Information about a single cluster for clustering model.",
+            "id": "ClusterInfo",
+            "properties": {
+                "centroidId": {
+                    "description": "Centroid id.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "clusterRadius": {
+                    "description": "Cluster radius, the average distance from centroid to each point assigned to the cluster.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "clusterSize": {
+                    "description": "Cluster size, the total number of points assigned to the cluster.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "Clustering": {
+            "id": "Clustering",
+            "properties": {
+                "fields": {
+                    "description": "[Repeated] One or more fields on which data should be clustered. Only top-level, non-repeated, simple-type fields are supported. When you cluster a table using multiple columns, the order of columns you specify is important. The order of the specified columns determines the sort order of the data.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "ClusteringMetrics": {
+            "description": "Evaluation metrics for clustering models.",
+            "id": "ClusteringMetrics",
+            "properties": {
+                "clusters": {
+                    "description": "Information for all clusters.",
+                    "items": {
+                        "$ref": "Cluster"
+                    },
+                    "type": "array"
+                },
+                "daviesBouldinIndex": {
+                    "description": "Davies-Bouldin index.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "meanSquaredDistance": {
+                    "description": "Mean of squared distances between each sample to its cluster centroid.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "ConfusionMatrix": {
+            "description": "Confusion matrix for multi-class classification models.",
+            "id": "ConfusionMatrix",
+            "properties": {
+                "confidenceThreshold": {
+                    "description": "Confidence threshold used when computing the entries of the confusion matrix.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "rows": {
+                    "description": "One row per actual label.",
+                    "items": {
+                        "$ref": "Row"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "ConnectionProperty": {
+            "id": "ConnectionProperty",
+            "properties": {
+                "key": {
+                    "description": "[Required] Name of the connection property to set.",
+                    "type": "string"
+                },
+                "value": {
+                    "description": "[Required] Value of the connection property.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "CsvOptions": {
+            "id": "CsvOptions",
+            "properties": {
+                "allowJaggedRows": {
+                    "description": "[Optional] Indicates if BigQuery should accept rows that are missing trailing optional columns. If true, BigQuery treats missing trailing columns as null values. If false, records with missing trailing columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false.",
+                    "type": "boolean"
+                },
+                "allowQuotedNewlines": {
+                    "description": "[Optional] Indicates if BigQuery should allow quoted data sections that contain newline characters in a CSV file. The default value is false.",
+                    "type": "boolean"
+                },
+                "encoding": {
+                    "description": "[Optional] The character encoding of the data. The supported values are UTF-8 or ISO-8859-1. The default value is UTF-8. BigQuery decodes the data after the raw, binary data has been split using the values of the quote and fieldDelimiter properties.",
+                    "type": "string"
+                },
+                "fieldDelimiter": {
+                    "description": "[Optional] The separator for fields in a CSV file. BigQuery converts the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the data in its raw, binary state. BigQuery also supports the escape sequence \"\\t\" to specify a tab separator. The default value is a comma (',').",
+                    "type": "string"
+                },
+                "quote": {
+                    "default": "\"",
+                    "description": "[Optional] The value that is used to quote data sections in a CSV file. BigQuery converts the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the data in its raw, binary state. The default value is a double-quote ('\"'). If your data does not contain quoted sections, set the property value to an empty string. If your data contains quoted newline characters, you must also set the allowQuotedNewlines property to true.",
+                    "pattern": ".?",
+                    "type": "string"
+                },
+                "skipLeadingRows": {
+                    "description": "[Optional] The number of rows at the top of a CSV file that BigQuery will skip when reading the data. The default value is 0. This property is useful if you have header rows in the file that should be skipped. When autodetect is on, the behavior is the following: * skipLeadingRows unspecified - Autodetect tries to detect headers in the first row. If they are not detected, the row is read as data. Otherwise data is read starting from the second row. * skipLeadingRows is 0 - Instructs autodetect that there are no headers and data should be read starting from the first row. * skipLeadingRows = N > 0 - Autodetect skips N-1 rows and tries to detect headers in row N. If headers are not detected, row N is just skipped. Otherwise row N is used to extract column names for the detected schema.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "DataSplitResult": {
+            "description": "Data split result. This contains references to the training and evaluation data tables that were used to train the model.",
+            "id": "DataSplitResult",
+            "properties": {
+                "evaluationTable": {
+                    "$ref": "TableReference",
+                    "description": "Table reference of the evaluation data after split."
+                },
+                "trainingTable": {
+                    "$ref": "TableReference",
+                    "description": "Table reference of the training data after split."
+                }
+            },
+            "type": "object"
+        },
+        "Dataset": {
+            "id": "Dataset",
+            "properties": {
+                "access": {
+                    "description": "[Optional] An array of objects that define dataset access for one or more entities. You can set this property when inserting or updating a dataset in order to control who is allowed to access the data. If unspecified at dataset creation time, BigQuery adds default dataset access for the following entities: access.specialGroup: projectReaders; access.role: READER; access.specialGroup: projectWriters; access.role: WRITER; access.specialGroup: projectOwners; access.role: OWNER; access.userByEmail: [dataset creator email]; access.role: OWNER;",
+                    "items": {
+                        "properties": {
+                            "dataset": {
+                                "$ref": "DatasetAccessEntry",
+                                "description": "[Pick one] A grant authorizing all resources of a particular type in a particular dataset access to this dataset. Only views are supported for now. The role field is not required when this field is set. If that dataset is deleted and re-created, its access needs to be granted again via an update operation."
+                            },
+                            "domain": {
+                                "description": "[Pick one] A domain to grant access to. Any users signed in with the domain specified will be granted the specified access. Example: \"example.com\". Maps to IAM policy member \"domain:DOMAIN\".",
+                                "type": "string"
+                            },
+                            "groupByEmail": {
+                                "description": "[Pick one] An email address of a Google Group to grant access to. Maps to IAM policy member \"group:GROUP\".",
+                                "type": "string"
+                            },
+                            "iamMember": {
+                                "description": "[Pick one] Some other type of member that appears in the IAM Policy but isn't a user, group, domain, or special group.",
+                                "type": "string"
+                            },
+                            "role": {
+                                "description": "[Required] An IAM role ID that should be granted to the user, group, or domain specified in this access entry. The following legacy mappings will be applied: OWNER  roles/bigquery.dataOwner WRITER  roles/bigquery.dataEditor READER  roles/bigquery.dataViewer This field will accept any of the above formats, but will return only the legacy format. For example, if you set this field to \"roles/bigquery.dataOwner\", it will be returned back as \"OWNER\".",
+                                "type": "string"
+                            },
+                            "routine": {
+                                "$ref": "RoutineReference",
+                                "description": "[Pick one] A routine from a different dataset to grant access to. Queries executed against that routine will have read access to views/tables/routines in this dataset. Only UDF is supported for now. The role field is not required when this field is set. If that routine is updated by any user, access to the routine needs to be granted again via an update operation."
+                            },
+                            "specialGroup": {
+                                "description": "[Pick one] A special group to grant access to. Possible values include: projectOwners: Owners of the enclosing project. projectReaders: Readers of the enclosing project. projectWriters: Writers of the enclosing project. allAuthenticatedUsers: All authenticated BigQuery users. Maps to similarly-named IAM members.",
+                                "type": "string"
+                            },
+                            "userByEmail": {
+                                "description": "[Pick one] An email address of a user to grant access to. For example: fred@example.com. Maps to IAM policy member \"user:EMAIL\" or \"serviceAccount:EMAIL\".",
+                                "type": "string"
+                            },
+                            "view": {
+                                "$ref": "TableReference",
+                                "description": "[Pick one] A view from a different dataset to grant access to. Queries executed against that view will have read access to tables in this dataset. The role field is not required when this field is set. If that view is updated by any user, access to the view needs to be granted again via an update operation."
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                },
+                "creationTime": {
+                    "description": "[Output-only] The time when this dataset was created, in milliseconds since the epoch.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "datasetReference": {
+                    "$ref": "DatasetReference",
+                    "description": "[Required] A reference that identifies the dataset."
+                },
+                "defaultEncryptionConfiguration": {
+                    "$ref": "EncryptionConfiguration"
+                },
+                "defaultPartitionExpirationMs": {
+                    "description": "[Optional] The default partition expiration for all partitioned tables in the dataset, in milliseconds. Once this property is set, all newly-created partitioned tables in the dataset will have an expirationMs property in the timePartitioning settings set to this value, and changing the value will only affect new tables, not existing ones. The storage in a partition will have an expiration time of its partition time plus this value. Setting this property overrides the use of defaultTableExpirationMs for partitioned tables: only one of defaultTableExpirationMs and defaultPartitionExpirationMs will be used for any new partitioned table. If you provide an explicit timePartitioning.expirationMs when creating or updating a partitioned table, that value takes precedence over the default partition expiration time indicated by this property.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "defaultTableExpirationMs": {
+                    "description": "[Optional] The default lifetime of all tables in the dataset, in milliseconds. The minimum value is 3600000 milliseconds (one hour). Once this property is set, all newly-created tables in the dataset will have an expirationTime property set to the creation time plus the value in this property, and changing the value will only affect new tables, not existing ones. When the expirationTime for a given table is reached, that table will be deleted automatically. If a table's expirationTime is modified or removed before the table expires, or if you provide an explicit expirationTime when creating a table, that value takes precedence over the default expiration time indicated by this property.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "description": {
+                    "description": "[Optional] A user-friendly description of the dataset.",
+                    "type": "string"
+                },
+                "etag": {
+                    "description": "[Output-only] A hash of the resource.",
+                    "type": "string"
+                },
+                "friendlyName": {
+                    "description": "[Optional] A descriptive name for the dataset.",
+                    "type": "string"
+                },
+                "id": {
+                    "description": "[Output-only] The fully-qualified unique name of the dataset in the format projectId:datasetId. The dataset name without the project name is given in the datasetId field. When creating a new dataset, leave this field blank, and instead specify the datasetId field.",
+                    "type": "string"
+                },
+                "kind": {
+                    "default": "bigquery#dataset",
+                    "description": "[Output-only] The resource type.",
+                    "type": "string"
+                },
+                "labels": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "description": "The labels associated with this dataset. You can use these to organize and group your datasets. You can set this property when inserting or updating a dataset. See Creating and Updating Dataset Labels for more information.",
+                    "type": "object"
+                },
+                "lastModifiedTime": {
+                    "description": "[Output-only] The date when this dataset or any of its tables was last modified, in milliseconds since the epoch.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "location": {
+                    "description": "The geographic location where the dataset should reside. The default value is US. See details at https://cloud.google.com/bigquery/docs/locations.",
+                    "type": "string"
+                },
+                "satisfiesPZS": {
+                    "description": "[Output-only] Reserved for future use.",
+                    "type": "boolean"
+                },
+                "selfLink": {
+                    "description": "[Output-only] A URL that can be used to access the resource again. You can use this URL in Get or Update requests to the resource.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "DatasetAccessEntry": {
+            "id": "DatasetAccessEntry",
+            "properties": {
+                "dataset": {
+                    "$ref": "DatasetReference",
+                    "description": "[Required] The dataset this entry applies to."
+                },
+                "target_types": {
+                    "items": {
+                        "properties": {
+                            "targetType": {
+                                "description": "[Required] Which resources in the dataset this entry applies to. Currently, only views are supported, but additional target types may be added in the future. Possible values: VIEWS: This entry applies to all views in the dataset.",
+                                "type": "string"
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "DatasetList": {
+            "id": "DatasetList",
+            "properties": {
+                "datasets": {
+                    "description": "An array of the dataset resources in the project. Each resource contains basic information. For full information about a particular dataset resource, use the Datasets: get method. This property is omitted when there are no datasets in the project.",
+                    "items": {
+                        "properties": {
+                            "datasetReference": {
+                                "$ref": "DatasetReference",
+                                "description": "The dataset reference. Use this property to access specific parts of the dataset's ID, such as project ID or dataset ID."
+                            },
+                            "friendlyName": {
+                                "description": "A descriptive name for the dataset, if one exists.",
+                                "type": "string"
+                            },
+                            "id": {
+                                "description": "The fully-qualified, unique, opaque ID of the dataset.",
+                                "type": "string"
+                            },
+                            "kind": {
+                                "default": "bigquery#dataset",
+                                "description": "The resource type. This property always returns the value \"bigquery#dataset\".",
+                                "type": "string"
+                            },
+                            "labels": {
+                                "additionalProperties": {
+                                    "type": "string"
+                                },
+                                "description": "The labels associated with this dataset. You can use these to organize and group your datasets.",
+                                "type": "object"
+                            },
+                            "location": {
+                                "description": "The geographic location where the data resides.",
+                                "type": "string"
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                },
+                "etag": {
+                    "description": "A hash value of the results page. You can use this property to determine if the page has changed since the last request.",
+                    "type": "string"
+                },
+                "kind": {
+                    "default": "bigquery#datasetList",
+                    "description": "The list type. This property always returns the value \"bigquery#datasetList\".",
+                    "type": "string"
+                },
+                "nextPageToken": {
+                    "description": "A token that can be used to request the next results page. This property is omitted on the final results page.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "DatasetReference": {
+            "id": "DatasetReference",
+            "properties": {
+                "datasetId": {
+                    "annotations": {
+                        "required": [
+                            "bigquery.datasets.update"
+                        ]
+                    },
+                    "description": "[Required] A unique ID for this dataset, without the project name. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 1,024 characters.",
+                    "type": "string"
+                },
+                "projectId": {
+                    "annotations": {
+                        "required": [
+                            "bigquery.datasets.update"
+                        ]
+                    },
+                    "description": "[Optional] The ID of the project containing this dataset.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "DestinationTableProperties": {
+            "id": "DestinationTableProperties",
+            "properties": {
+                "description": {
+                    "description": "[Optional] The description for the destination table. This will only be used if the destination table is newly created. If the table already exists and a value different than the current description is provided, the job will fail.",
+                    "type": "string"
+                },
+                "friendlyName": {
+                    "description": "[Optional] The friendly name for the destination table. This will only be used if the destination table is newly created. If the table already exists and a value different than the current friendly name is provided, the job will fail.",
+                    "type": "string"
+                },
+                "labels": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "description": "[Optional] The labels associated with this table. You can use these to organize and group your tables. This will only be used if the destination table is newly created. If the table already exists and labels are different than the current labels are provided, the job will fail.",
+                    "type": "object"
+                }
+            },
+            "type": "object"
+        },
+        "DimensionalityReductionMetrics": {
+            "description": "Model evaluation metrics for dimensionality reduction models.",
+            "id": "DimensionalityReductionMetrics",
+            "properties": {
+                "totalExplainedVarianceRatio": {
+                    "description": "Total percentage of variance explained by the selected principal components.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "EncryptionConfiguration": {
+            "id": "EncryptionConfiguration",
+            "properties": {
+                "kmsKeyName": {
+                    "description": "[Optional] Describes the Cloud KMS encryption key that will be used to protect destination BigQuery table. The BigQuery Service Account associated with your project requires access to this encryption key.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "Entry": {
+            "description": "A single entry in the confusion matrix.",
+            "id": "Entry",
+            "properties": {
+                "itemCount": {
+                    "description": "Number of items being predicted as this label.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "predictedLabel": {
+                    "description": "The predicted label. For confidence_threshold > 0, we will also add an entry indicating the number of items under the confidence threshold.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "ErrorProto": {
+            "id": "ErrorProto",
+            "properties": {
+                "debugInfo": {
+                    "description": "Debugging information. This property is internal to Google and should not be used.",
+                    "type": "string"
+                },
+                "location": {
+                    "description": "Specifies where the error occurred, if present.",
+                    "type": "string"
+                },
+                "message": {
+                    "description": "A human-readable description of the error.",
+                    "type": "string"
+                },
+                "reason": {
+                    "description": "A short error code that summarizes the error.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "EvaluationMetrics": {
+            "description": "Evaluation metrics of a model. These are either computed on all training data or just the eval data based on whether eval data was used during training. These are not present for imported models.",
+            "id": "EvaluationMetrics",
+            "properties": {
+                "arimaForecastingMetrics": {
+                    "$ref": "ArimaForecastingMetrics",
+                    "description": "Populated for ARIMA models."
+                },
+                "binaryClassificationMetrics": {
+                    "$ref": "BinaryClassificationMetrics",
+                    "description": "Populated for binary classification/classifier models."
+                },
+                "clusteringMetrics": {
+                    "$ref": "ClusteringMetrics",
+                    "description": "Populated for clustering models."
+                },
+                "dimensionalityReductionMetrics": {
+                    "$ref": "DimensionalityReductionMetrics",
+                    "description": "Evaluation metrics when the model is a dimensionality reduction model, which currently includes PCA."
+                },
+                "multiClassClassificationMetrics": {
+                    "$ref": "MultiClassClassificationMetrics",
+                    "description": "Populated for multi-class classification/classifier models."
+                },
+                "rankingMetrics": {
+                    "$ref": "RankingMetrics",
+                    "description": "Populated for implicit feedback type matrix factorization models."
+                },
+                "regressionMetrics": {
+                    "$ref": "RegressionMetrics",
+                    "description": "Populated for regression models and explicit feedback type matrix factorization models."
+                }
+            },
+            "type": "object"
+        },
+        "ExplainQueryStage": {
+            "id": "ExplainQueryStage",
+            "properties": {
+                "completedParallelInputs": {
+                    "description": "Number of parallel input segments completed.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "computeMsAvg": {
+                    "description": "Milliseconds the average shard spent on CPU-bound tasks.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "computeMsMax": {
+                    "description": "Milliseconds the slowest shard spent on CPU-bound tasks.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "computeRatioAvg": {
+                    "description": "Relative amount of time the average shard spent on CPU-bound tasks.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "computeRatioMax": {
+                    "description": "Relative amount of time the slowest shard spent on CPU-bound tasks.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "endMs": {
+                    "description": "Stage end time represented as milliseconds since epoch.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "id": {
+                    "description": "Unique ID for stage within plan.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "inputStages": {
+                    "description": "IDs for stages that are inputs to this stage.",
+                    "items": {
+                        "format": "int64",
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "name": {
+                    "description": "Human-readable name for stage.",
+                    "type": "string"
+                },
+                "parallelInputs": {
+                    "description": "Number of parallel input segments to be processed.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "readMsAvg": {
+                    "description": "Milliseconds the average shard spent reading input.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "readMsMax": {
+                    "description": "Milliseconds the slowest shard spent reading input.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "readRatioAvg": {
+                    "description": "Relative amount of time the average shard spent reading input.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "readRatioMax": {
+                    "description": "Relative amount of time the slowest shard spent reading input.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "recordsRead": {
+                    "description": "Number of records read into the stage.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "recordsWritten": {
+                    "description": "Number of records written by the stage.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "shuffleOutputBytes": {
+                    "description": "Total number of bytes written to shuffle.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "shuffleOutputBytesSpilled": {
+                    "description": "Total number of bytes written to shuffle and spilled to disk.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "slotMs": {
+                    "description": "Slot-milliseconds used by the stage.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "startMs": {
+                    "description": "Stage start time represented as milliseconds since epoch.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "status": {
+                    "description": "Current status for the stage.",
+                    "type": "string"
+                },
+                "steps": {
+                    "description": "List of operations within the stage in dependency order (approximately chronological).",
+                    "items": {
+                        "$ref": "ExplainQueryStep"
+                    },
+                    "type": "array"
+                },
+                "waitMsAvg": {
+                    "description": "Milliseconds the average shard spent waiting to be scheduled.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "waitMsMax": {
+                    "description": "Milliseconds the slowest shard spent waiting to be scheduled.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "waitRatioAvg": {
+                    "description": "Relative amount of time the average shard spent waiting to be scheduled.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "waitRatioMax": {
+                    "description": "Relative amount of time the slowest shard spent waiting to be scheduled.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "writeMsAvg": {
+                    "description": "Milliseconds the average shard spent on writing output.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "writeMsMax": {
+                    "description": "Milliseconds the slowest shard spent on writing output.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "writeRatioAvg": {
+                    "description": "Relative amount of time the average shard spent on writing output.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "writeRatioMax": {
+                    "description": "Relative amount of time the slowest shard spent on writing output.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "ExplainQueryStep": {
+            "id": "ExplainQueryStep",
+            "properties": {
+                "kind": {
+                    "description": "Machine-readable operation type.",
+                    "type": "string"
+                },
+                "substeps": {
+                    "description": "Human-readable stage descriptions.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "Explanation": {
+            "description": "Explanation for a single feature.",
+            "id": "Explanation",
+            "properties": {
+                "attribution": {
+                    "description": "Attribution of feature.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "featureName": {
+                    "description": "Full name of the feature. For non-numerical features, will be formatted like .. Overall size of feature name will always be truncated to first 120 characters.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "Expr": {
+            "description": "Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: \"Summary size limit\" description: \"Determines if a summary is less than 100 chars\" expression: \"document.summary.size() < 100\" Example (Equality): title: \"Requestor is owner\" description: \"Determines if requestor is the document owner\" expression: \"document.owner == request.auth.claims.email\" Example (Logic): title: \"Public documents\" description: \"Determine whether the document should be publicly visible\" expression: \"document.type != 'private' && document.type != 'internal'\" Example (Data Manipulation): title: \"Notification string\" description: \"Create a notification string with a timestamp.\" expression: \"'New message received at ' + string(document.create_time)\" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.",
+            "id": "Expr",
+            "properties": {
+                "description": {
+                    "description": "Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.",
+                    "type": "string"
+                },
+                "expression": {
+                    "description": "Textual representation of an expression in Common Expression Language syntax.",
+                    "type": "string"
+                },
+                "location": {
+                    "description": "Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.",
+                    "type": "string"
+                },
+                "title": {
+                    "description": "Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "ExternalDataConfiguration": {
+            "id": "ExternalDataConfiguration",
+            "properties": {
+                "autodetect": {
+                    "description": "Try to detect schema and format options automatically. Any option specified explicitly will be honored.",
+                    "type": "boolean"
+                },
+                "bigtableOptions": {
+                    "$ref": "BigtableOptions",
+                    "description": "[Optional] Additional options if sourceFormat is set to BIGTABLE."
+                },
+                "compression": {
+                    "description": "[Optional] The compression type of the data source. Possible values include GZIP and NONE. The default value is NONE. This setting is ignored for Google Cloud Bigtable, Google Cloud Datastore backups and Avro formats.",
+                    "type": "string"
+                },
+                "connectionId": {
+                    "description": "[Optional, Trusted Tester] Connection for external data source.",
+                    "type": "string"
+                },
+                "csvOptions": {
+                    "$ref": "CsvOptions",
+                    "description": "Additional properties to set if sourceFormat is set to CSV."
+                },
+                "googleSheetsOptions": {
+                    "$ref": "GoogleSheetsOptions",
+                    "description": "[Optional] Additional options if sourceFormat is set to GOOGLE_SHEETS."
+                },
+                "hivePartitioningOptions": {
+                    "$ref": "HivePartitioningOptions",
+                    "description": "[Optional] Options to configure hive partitioning support."
+                },
+                "ignoreUnknownValues": {
+                    "description": "[Optional] Indicates if BigQuery should allow extra values that are not represented in the table schema. If true, the extra values are ignored. If false, records with extra columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false. The sourceFormat property determines what BigQuery treats as an extra value: CSV: Trailing columns JSON: Named values that don't match any column names Google Cloud Bigtable: This setting is ignored. Google Cloud Datastore backups: This setting is ignored. Avro: This setting is ignored.",
+                    "type": "boolean"
+                },
+                "maxBadRecords": {
+                    "description": "[Optional] The maximum number of bad records that BigQuery can ignore when reading data. If the number of bad records exceeds this value, an invalid error is returned in the job result. This is only valid for CSV, JSON, and Google Sheets. The default value is 0, which requires that all records are valid. This setting is ignored for Google Cloud Bigtable, Google Cloud Datastore backups and Avro formats.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "parquetOptions": {
+                    "$ref": "ParquetOptions",
+                    "description": "Additional properties to set if sourceFormat is set to Parquet."
+                },
+                "schema": {
+                    "$ref": "TableSchema",
+                    "description": "[Optional] The schema for the data. Schema is required for CSV and JSON formats. Schema is disallowed for Google Cloud Bigtable, Cloud Datastore backups, and Avro formats."
+                },
+                "sourceFormat": {
+                    "description": "[Required] The data format. For CSV files, specify \"CSV\". For Google sheets, specify \"GOOGLE_SHEETS\". For newline-delimited JSON, specify \"NEWLINE_DELIMITED_JSON\". For Avro files, specify \"AVRO\". For Google Cloud Datastore backups, specify \"DATASTORE_BACKUP\". [Beta] For Google Cloud Bigtable, specify \"BIGTABLE\".",
+                    "type": "string"
+                },
+                "sourceUris": {
+                    "description": "[Required] The fully-qualified URIs that point to your data in Google Cloud. For Google Cloud Storage URIs: Each URI can contain one '*' wildcard character and it must come after the 'bucket' name. Size limits related to load jobs apply to external data sources. For Google Cloud Bigtable URIs: Exactly one URI can be specified and it has be a fully specified and valid HTTPS URL for a Google Cloud Bigtable table. For Google Cloud Datastore backups, exactly one URI can be specified. Also, the '*' wildcard character is not allowed.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "FeatureValue": {
+            "description": "Representative value of a single feature within the cluster.",
+            "id": "FeatureValue",
+            "properties": {
+                "categoricalValue": {
+                    "$ref": "CategoricalValue",
+                    "description": "The categorical feature value."
+                },
+                "featureColumn": {
+                    "description": "The feature column name.",
+                    "type": "string"
+                },
+                "numericalValue": {
+                    "description": "The numerical feature value. This is the centroid value for this feature.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "GetIamPolicyRequest": {
+            "description": "Request message for `GetIamPolicy` method.",
+            "id": "GetIamPolicyRequest",
+            "properties": {
+                "options": {
+                    "$ref": "GetPolicyOptions",
+                    "description": "OPTIONAL: A `GetPolicyOptions` object for specifying options to `GetIamPolicy`."
+                }
+            },
+            "type": "object"
+        },
+        "GetPolicyOptions": {
+            "description": "Encapsulates settings provided to GetIamPolicy.",
+            "id": "GetPolicyOptions",
+            "properties": {
+                "requestedPolicyVersion": {
+                    "description": "Optional. The policy format version to be returned. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional bindings must specify version 3. Policies without any conditional bindings may specify any valid value or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).",
+                    "format": "int32",
+                    "type": "integer"
+                }
+            },
+            "type": "object"
+        },
+        "GetQueryResultsResponse": {
+            "id": "GetQueryResultsResponse",
+            "properties": {
+                "cacheHit": {
+                    "description": "Whether the query result was fetched from the query cache.",
+                    "type": "boolean"
+                },
+                "errors": {
+                    "description": "[Output-only] The first errors or warnings encountered during the running of the job. The final message includes the number of errors that caused the process to stop. Errors here do not necessarily mean that the job has completed or was unsuccessful.",
+                    "items": {
+                        "$ref": "ErrorProto"
+                    },
+                    "type": "array"
+                },
+                "etag": {
+                    "description": "A hash of this response.",
+                    "type": "string"
+                },
+                "jobComplete": {
+                    "description": "Whether the query has completed or not. If rows or totalRows are present, this will always be true. If this is false, totalRows will not be available.",
+                    "type": "boolean"
+                },
+                "jobReference": {
+                    "$ref": "JobReference",
+                    "description": "Reference to the BigQuery Job that was created to run the query. This field will be present even if the original request timed out, in which case GetQueryResults can be used to read the results once the query has completed. Since this API only returns the first page of results, subsequent pages can be fetched via the same mechanism (GetQueryResults)."
+                },
+                "kind": {
+                    "default": "bigquery#getQueryResultsResponse",
+                    "description": "The resource type of the response.",
+                    "type": "string"
+                },
+                "numDmlAffectedRows": {
+                    "description": "[Output-only] The number of rows affected by a DML statement. Present only for DML statements INSERT, UPDATE or DELETE.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "pageToken": {
+                    "description": "A token used for paging results.",
+                    "type": "string"
+                },
+                "rows": {
+                    "description": "An object with as many results as can be contained within the maximum permitted reply size. To get any additional rows, you can call GetQueryResults and specify the jobReference returned above. Present only when the query completes successfully.",
+                    "items": {
+                        "$ref": "TableRow"
+                    },
+                    "type": "array"
+                },
+                "schema": {
+                    "$ref": "TableSchema",
+                    "description": "The schema of the results. Present only when the query completes successfully."
+                },
+                "totalBytesProcessed": {
+                    "description": "The total number of bytes processed for this query.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "totalRows": {
+                    "description": "The total number of rows in the complete query result set, which can be more than the number of rows in this single page of results. Present only when the query completes successfully.",
+                    "format": "uint64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "GetServiceAccountResponse": {
+            "id": "GetServiceAccountResponse",
+            "properties": {
+                "email": {
+                    "description": "The service account email address.",
+                    "type": "string"
+                },
+                "kind": {
+                    "default": "bigquery#getServiceAccountResponse",
+                    "description": "The resource type of the response.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "GlobalExplanation": {
+            "description": "Global explanations containing the top most important features after training.",
+            "id": "GlobalExplanation",
+            "properties": {
+                "classLabel": {
+                    "description": "Class label for this set of global explanations. Will be empty/null for binary logistic and linear regression models. Sorted alphabetically in descending order.",
+                    "type": "string"
+                },
+                "explanations": {
+                    "description": "A list of the top global explanations. Sorted by absolute value of attribution in descending order.",
+                    "items": {
+                        "$ref": "Explanation"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "GoogleSheetsOptions": {
+            "id": "GoogleSheetsOptions",
+            "properties": {
+                "range": {
+                    "description": "[Optional] Range of a sheet to query from. Only used when non-empty. Typical format: sheet_name!top_left_cell_id:bottom_right_cell_id For example: sheet1!A1:B20",
+                    "type": "string"
+                },
+                "skipLeadingRows": {
+                    "description": "[Optional] The number of rows at the top of a sheet that BigQuery will skip when reading the data. The default value is 0. This property is useful if you have header rows that should be skipped. When autodetect is on, behavior is the following: * skipLeadingRows unspecified - Autodetect tries to detect headers in the first row. If they are not detected, the row is read as data. Otherwise data is read starting from the second row. * skipLeadingRows is 0 - Instructs autodetect that there are no headers and data should be read starting from the first row. * skipLeadingRows = N > 0 - Autodetect skips N-1 rows and tries to detect headers in row N. If headers are not detected, row N is just skipped. Otherwise row N is used to extract column names for the detected schema.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "HivePartitioningOptions": {
+            "id": "HivePartitioningOptions",
+            "properties": {
+                "mode": {
+                    "description": "[Optional] When set, what mode of hive partitioning to use when reading data. The following modes are supported. (1) AUTO: automatically infer partition key name(s) and type(s). (2) STRINGS: automatically infer partition key name(s). All types are interpreted as strings. (3) CUSTOM: partition key schema is encoded in the source URI prefix. Not all storage formats support hive partitioning. Requesting hive partitioning on an unsupported format will lead to an error. Currently supported types include: AVRO, CSV, JSON, ORC and Parquet.",
+                    "type": "string"
+                },
+                "requirePartitionFilter": {
+                    "description": "[Optional] If set to true, queries over this table require a partition filter that can be used for partition elimination to be specified. Note that this field should only be true when creating a permanent external table or querying a temporary external table. Hive-partitioned loads with requirePartitionFilter explicitly set to true will fail.",
+                    "type": "boolean"
+                },
+                "sourceUriPrefix": {
+                    "description": "[Optional] When hive partition detection is requested, a common prefix for all source uris should be supplied. The prefix must end immediately before the partition key encoding begins. For example, consider files following this data layout. gs://bucket/path_to_table/dt=2019-01-01/country=BR/id=7/file.avro gs://bucket/path_to_table/dt=2018-12-31/country=CA/id=3/file.avro When hive partitioning is requested with either AUTO or STRINGS detection, the common prefix can be either of gs://bucket/path_to_table or gs://bucket/path_to_table/ (trailing slash does not matter).",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "IterationResult": {
+            "description": "Information about a single iteration of the training run.",
+            "id": "IterationResult",
+            "properties": {
+                "arimaResult": {
+                    "$ref": "ArimaResult"
+                },
+                "clusterInfos": {
+                    "description": "Information about top clusters for clustering models.",
+                    "items": {
+                        "$ref": "ClusterInfo"
+                    },
+                    "type": "array"
+                },
+                "durationMs": {
+                    "description": "Time taken to run the iteration in milliseconds.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "evalLoss": {
+                    "description": "Loss computed on the eval data at the end of iteration.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "index": {
+                    "description": "Index of the iteration, 0 based.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "learnRate": {
+                    "description": "Learn rate used for this iteration.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "principalComponentInfos": {
+                    "description": "The information of the principal components.",
+                    "items": {
+                        "$ref": "PrincipalComponentInfo"
+                    },
+                    "type": "array"
+                },
+                "trainingLoss": {
+                    "description": "Loss computed on the training data at the end of iteration.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "Job": {
+            "id": "Job",
+            "properties": {
+                "configuration": {
+                    "$ref": "JobConfiguration",
+                    "description": "[Required] Describes the job configuration."
+                },
+                "etag": {
+                    "description": "[Output-only] A hash of this resource.",
+                    "type": "string"
+                },
+                "id": {
+                    "description": "[Output-only] Opaque ID field of the job",
+                    "type": "string"
+                },
+                "jobReference": {
+                    "$ref": "JobReference",
+                    "description": "[Optional] Reference describing the unique-per-user name of the job."
+                },
+                "kind": {
+                    "default": "bigquery#job",
+                    "description": "[Output-only] The type of the resource.",
+                    "type": "string"
+                },
+                "selfLink": {
+                    "description": "[Output-only] A URL that can be used to access this resource again.",
+                    "type": "string"
+                },
+                "statistics": {
+                    "$ref": "JobStatistics",
+                    "description": "[Output-only] Information about the job, including starting time and ending time of the job."
+                },
+                "status": {
+                    "$ref": "JobStatus",
+                    "description": "[Output-only] The status of this job. Examine this value when polling an asynchronous job to see if the job is complete."
+                },
+                "user_email": {
+                    "description": "[Output-only] Email address of the user who ran the job.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "JobCancelResponse": {
+            "id": "JobCancelResponse",
+            "properties": {
+                "job": {
+                    "$ref": "Job",
+                    "description": "The final state of the job."
+                },
+                "kind": {
+                    "default": "bigquery#jobCancelResponse",
+                    "description": "The resource type of the response.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "JobConfiguration": {
+            "id": "JobConfiguration",
+            "properties": {
+                "copy": {
+                    "$ref": "JobConfigurationTableCopy",
+                    "description": "[Pick one] Copies a table."
+                },
+                "dryRun": {
+                    "description": "[Optional] If set, don't actually run this job. A valid query will return a mostly empty response with some processing statistics, while an invalid query will return the same error it would if it wasn't a dry run. Behavior of non-query jobs is undefined.",
+                    "type": "boolean"
+                },
+                "extract": {
+                    "$ref": "JobConfigurationExtract",
+                    "description": "[Pick one] Configures an extract job."
+                },
+                "jobTimeoutMs": {
+                    "description": "[Optional] Job timeout in milliseconds. If this time limit is exceeded, BigQuery may attempt to terminate the job.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "jobType": {
+                    "description": "[Output-only] The type of the job. Can be QUERY, LOAD, EXTRACT, COPY or UNKNOWN.",
+                    "type": "string"
+                },
+                "labels": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "description": "The labels associated with this job. You can use these to organize and group your jobs. Label keys and values can be no longer than 63 characters, can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. Label values are optional. Label keys must start with a letter and each label in the list must have a different key.",
+                    "type": "object"
+                },
+                "load": {
+                    "$ref": "JobConfigurationLoad",
+                    "description": "[Pick one] Configures a load job."
+                },
+                "query": {
+                    "$ref": "JobConfigurationQuery",
+                    "description": "[Pick one] Configures a query job."
+                }
+            },
+            "type": "object"
+        },
+        "JobConfigurationExtract": {
+            "id": "JobConfigurationExtract",
+            "properties": {
+                "compression": {
+                    "description": "[Optional] The compression type to use for exported files. Possible values include GZIP, DEFLATE, SNAPPY, and NONE. The default value is NONE. DEFLATE and SNAPPY are only supported for Avro. Not applicable when extracting models.",
+                    "type": "string"
+                },
+                "destinationFormat": {
+                    "description": "[Optional] The exported file format. Possible values include CSV, NEWLINE_DELIMITED_JSON, PARQUET or AVRO for tables and ML_TF_SAVED_MODEL or ML_XGBOOST_BOOSTER for models. The default value for tables is CSV. Tables with nested or repeated fields cannot be exported as CSV. The default value for models is ML_TF_SAVED_MODEL.",
+                    "type": "string"
+                },
+                "destinationUri": {
+                    "description": "[Pick one] DEPRECATED: Use destinationUris instead, passing only one URI as necessary. The fully-qualified Google Cloud Storage URI where the extracted table should be written.",
+                    "type": "string"
+                },
+                "destinationUris": {
+                    "description": "[Pick one] A list of fully-qualified Google Cloud Storage URIs where the extracted table should be written.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "fieldDelimiter": {
+                    "description": "[Optional] Delimiter to use between fields in the exported data. Default is ','. Not applicable when extracting models.",
+                    "type": "string"
+                },
+                "printHeader": {
+                    "default": "true",
+                    "description": "[Optional] Whether to print out a header row in the results. Default is true. Not applicable when extracting models.",
+                    "type": "boolean"
+                },
+                "sourceModel": {
+                    "$ref": "ModelReference",
+                    "description": "A reference to the model being exported."
+                },
+                "sourceTable": {
+                    "$ref": "TableReference",
+                    "description": "A reference to the table being exported."
+                },
+                "useAvroLogicalTypes": {
+                    "description": "[Optional] If destinationFormat is set to \"AVRO\", this flag indicates whether to enable extracting applicable column types (such as TIMESTAMP) to their corresponding AVRO logical types (timestamp-micros), instead of only using their raw types (avro-long). Not applicable when extracting models.",
+                    "type": "boolean"
+                }
+            },
+            "type": "object"
+        },
+        "JobConfigurationLoad": {
+            "id": "JobConfigurationLoad",
+            "properties": {
+                "allowJaggedRows": {
+                    "description": "[Optional] Accept rows that are missing trailing optional columns. The missing values are treated as nulls. If false, records with missing trailing columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false. Only applicable to CSV, ignored for other formats.",
+                    "type": "boolean"
+                },
+                "allowQuotedNewlines": {
+                    "description": "Indicates if BigQuery should allow quoted data sections that contain newline characters in a CSV file. The default value is false.",
+                    "type": "boolean"
+                },
+                "autodetect": {
+                    "description": "[Optional] Indicates if we should automatically infer the options and schema for CSV and JSON sources.",
+                    "type": "boolean"
+                },
+                "clustering": {
+                    "$ref": "Clustering",
+                    "description": "[Beta] Clustering specification for the destination table. Must be specified with time-based partitioning, data in the table will be first partitioned and subsequently clustered."
+                },
+                "createDisposition": {
+                    "description": "[Optional] Specifies whether the job is allowed to create new tables. The following values are supported: CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table. CREATE_NEVER: The table must already exist. If it does not, a 'notFound' error is returned in the job result. The default value is CREATE_IF_NEEDED. Creation, truncation and append actions occur as one atomic update upon job completion.",
+                    "type": "string"
+                },
+                "decimalTargetTypes": {
+                    "description": "Defines the list of possible SQL data types to which the source decimal values are converted. This list and the precision and the scale parameters of the decimal field determine the target type. In the order of NUMERIC, BIGNUMERIC ([Preview](/products/#product-launch-stages)), and STRING, a type is picked if it is in the specified list and if it supports the precision and the scale. STRING supports all precision and scale values. If none of the listed types supports the precision and the scale, the type supporting the widest range in the specified list is picked, and if a value exceeds the supported range when reading the data, an error will be thrown. Example: Suppose the value of this field is [\"NUMERIC\", \"BIGNUMERIC\"]. If (precision,scale) is: * (38,9) -> NUMERIC; * (39,9) -> BIGNUMERIC (NUMERIC cannot hold 30 integer digits); * (38,10) -> BIGNUMERIC (NUMERIC cannot hold 10 fractional digits); * (76,38) -> BIGNUMERIC; * (77,38) -> BIGNUMERIC (error if value exeeds supported range). This field cannot contain duplicate types. The order of the types in this field is ignored. For example, [\"BIGNUMERIC\", \"NUMERIC\"] is the same as [\"NUMERIC\", \"BIGNUMERIC\"] and NUMERIC always takes precedence over BIGNUMERIC. Defaults to [\"NUMERIC\", \"STRING\"] for ORC and [\"NUMERIC\"] for the other file formats.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "destinationEncryptionConfiguration": {
+                    "$ref": "EncryptionConfiguration",
+                    "description": "Custom encryption configuration (e.g., Cloud KMS keys)."
+                },
+                "destinationTable": {
+                    "$ref": "TableReference",
+                    "description": "[Required] The destination table to load the data into."
+                },
+                "destinationTableProperties": {
+                    "$ref": "DestinationTableProperties",
+                    "description": "[Beta] [Optional] Properties with which to create the destination table if it is new."
+                },
+                "encoding": {
+                    "description": "[Optional] The character encoding of the data. The supported values are UTF-8 or ISO-8859-1. The default value is UTF-8. BigQuery decodes the data after the raw, binary data has been split using the values of the quote and fieldDelimiter properties.",
+                    "type": "string"
+                },
+                "fieldDelimiter": {
+                    "description": "[Optional] The separator for fields in a CSV file. The separator can be any ISO-8859-1 single-byte character. To use a character in the range 128-255, you must encode the character as UTF8. BigQuery converts the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the data in its raw, binary state. BigQuery also supports the escape sequence \"\\t\" to specify a tab separator. The default value is a comma (',').",
+                    "type": "string"
+                },
+                "hivePartitioningOptions": {
+                    "$ref": "HivePartitioningOptions",
+                    "description": "[Optional] Options to configure hive partitioning support."
+                },
+                "ignoreUnknownValues": {
+                    "description": "[Optional] Indicates if BigQuery should allow extra values that are not represented in the table schema. If true, the extra values are ignored. If false, records with extra columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false. The sourceFormat property determines what BigQuery treats as an extra value: CSV: Trailing columns JSON: Named values that don't match any column names",
+                    "type": "boolean"
+                },
+                "jsonExtension": {
+                    "description": "[Optional] If sourceFormat is set to newline-delimited JSON, indicates whether it should be processed as a JSON variant such as GeoJSON. For a sourceFormat other than JSON, omit this field. If the sourceFormat is newline-delimited JSON: - for newline-delimited GeoJSON: set to GEOJSON.",
+                    "type": "string"
+                },
+                "maxBadRecords": {
+                    "description": "[Optional] The maximum number of bad records that BigQuery can ignore when running the job. If the number of bad records exceeds this value, an invalid error is returned in the job result. This is only valid for CSV and JSON. The default value is 0, which requires that all records are valid.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "nullMarker": {
+                    "description": "[Optional] Specifies a string that represents a null value in a CSV file. For example, if you specify \"\\N\", BigQuery interprets \"\\N\" as a null value when loading a CSV file. The default value is the empty string. If you set this property to a custom value, BigQuery throws an error if an empty string is present for all data types except for STRING and BYTE. For STRING and BYTE columns, BigQuery interprets the empty string as an empty value.",
+                    "type": "string"
+                },
+                "parquetOptions": {
+                    "$ref": "ParquetOptions",
+                    "description": "[Optional] Options to configure parquet support."
+                },
+                "projectionFields": {
+                    "description": "If sourceFormat is set to \"DATASTORE_BACKUP\", indicates which entity properties to load into BigQuery from a Cloud Datastore backup. Property names are case sensitive and must be top-level properties. If no properties are specified, BigQuery loads all properties. If any named property isn't found in the Cloud Datastore backup, an invalid error is returned in the job result.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "quote": {
+                    "default": "\"",
+                    "description": "[Optional] The value that is used to quote data sections in a CSV file. BigQuery converts the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the data in its raw, binary state. The default value is a double-quote ('\"'). If your data does not contain quoted sections, set the property value to an empty string. If your data contains quoted newline characters, you must also set the allowQuotedNewlines property to true.",
+                    "pattern": ".?",
+                    "type": "string"
+                },
+                "rangePartitioning": {
+                    "$ref": "RangePartitioning",
+                    "description": "[TrustedTester] Range partitioning specification for this table. Only one of timePartitioning and rangePartitioning should be specified."
+                },
+                "schema": {
+                    "$ref": "TableSchema",
+                    "description": "[Optional] The schema for the destination table. The schema can be omitted if the destination table already exists, or if you're loading data from Google Cloud Datastore."
+                },
+                "schemaInline": {
+                    "description": "[Deprecated] The inline schema. For CSV schemas, specify as \"Field1:Type1[,Field2:Type2]*\". For example, \"foo:STRING, bar:INTEGER, baz:FLOAT\".",
+                    "type": "string"
+                },
+                "schemaInlineFormat": {
+                    "description": "[Deprecated] The format of the schemaInline property.",
+                    "type": "string"
+                },
+                "schemaUpdateOptions": {
+                    "description": "Allows the schema of the destination table to be updated as a side effect of the load job if a schema is autodetected or supplied in the job configuration. Schema update options are supported in two cases: when writeDisposition is WRITE_APPEND; when writeDisposition is WRITE_TRUNCATE and the destination table is a partition of a table, specified by partition decorators. For normal tables, WRITE_TRUNCATE will always overwrite the schema. One or more of the following values are specified: ALLOW_FIELD_ADDITION: allow adding a nullable field to the schema. ALLOW_FIELD_RELAXATION: allow relaxing a required field in the original schema to nullable.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "skipLeadingRows": {
+                    "description": "[Optional] The number of rows at the top of a CSV file that BigQuery will skip when loading the data. The default value is 0. This property is useful if you have header rows in the file that should be skipped.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "sourceFormat": {
+                    "description": "[Optional] The format of the data files. For CSV files, specify \"CSV\". For datastore backups, specify \"DATASTORE_BACKUP\". For newline-delimited JSON, specify \"NEWLINE_DELIMITED_JSON\". For Avro, specify \"AVRO\". For parquet, specify \"PARQUET\". For orc, specify \"ORC\". The default value is CSV.",
+                    "type": "string"
+                },
+                "sourceUris": {
+                    "description": "[Required] The fully-qualified URIs that point to your data in Google Cloud. For Google Cloud Storage URIs: Each URI can contain one '*' wildcard character and it must come after the 'bucket' name. Size limits related to load jobs apply to external data sources. For Google Cloud Bigtable URIs: Exactly one URI can be specified and it has be a fully specified and valid HTTPS URL for a Google Cloud Bigtable table. For Google Cloud Datastore backups: Exactly one URI can be specified. Also, the '*' wildcard character is not allowed.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "timePartitioning": {
+                    "$ref": "TimePartitioning",
+                    "description": "Time-based partitioning specification for the destination table. Only one of timePartitioning and rangePartitioning should be specified."
+                },
+                "useAvroLogicalTypes": {
+                    "description": "[Optional] If sourceFormat is set to \"AVRO\", indicates whether to enable interpreting logical types into their corresponding types (ie. TIMESTAMP), instead of only using their raw types (ie. INTEGER).",
+                    "type": "boolean"
+                },
+                "writeDisposition": {
+                    "description": "[Optional] Specifies the action that occurs if the destination table already exists. The following values are supported: WRITE_TRUNCATE: If the table already exists, BigQuery overwrites the table data. WRITE_APPEND: If the table already exists, BigQuery appends the data to the table. WRITE_EMPTY: If the table already exists and contains data, a 'duplicate' error is returned in the job result. The default value is WRITE_APPEND. Each action is atomic and only occurs if BigQuery is able to complete the job successfully. Creation, truncation and append actions occur as one atomic update upon job completion.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "JobConfigurationQuery": {
+            "id": "JobConfigurationQuery",
+            "properties": {
+                "allowLargeResults": {
+                    "default": "false",
+                    "description": "[Optional] If true and query uses legacy SQL dialect, allows the query to produce arbitrarily large result tables at a slight cost in performance. Requires destinationTable to be set. For standard SQL queries, this flag is ignored and large results are always allowed. However, you must still set destinationTable when result size exceeds the allowed maximum response size.",
+                    "type": "boolean"
+                },
+                "clustering": {
+                    "$ref": "Clustering",
+                    "description": "[Beta] Clustering specification for the destination table. Must be specified with time-based partitioning, data in the table will be first partitioned and subsequently clustered."
+                },
+                "connectionProperties": {
+                    "description": "Connection properties.",
+                    "items": {
+                        "$ref": "ConnectionProperty"
+                    },
+                    "type": "array"
+                },
+                "createDisposition": {
+                    "description": "[Optional] Specifies whether the job is allowed to create new tables. The following values are supported: CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table. CREATE_NEVER: The table must already exist. If it does not, a 'notFound' error is returned in the job result. The default value is CREATE_IF_NEEDED. Creation, truncation and append actions occur as one atomic update upon job completion.",
+                    "type": "string"
+                },
+                "createSession": {
+                    "description": "If true, creates a new session, where session id will be a server generated random id. If false, runs query with an existing session_id passed in ConnectionProperty, otherwise runs query in non-session mode.",
+                    "type": "boolean"
+                },
+                "defaultDataset": {
+                    "$ref": "DatasetReference",
+                    "description": "[Optional] Specifies the default dataset to use for unqualified table names in the query. Note that this does not alter behavior of unqualified dataset names."
+                },
+                "destinationEncryptionConfiguration": {
+                    "$ref": "EncryptionConfiguration",
+                    "description": "Custom encryption configuration (e.g., Cloud KMS keys)."
+                },
+                "destinationTable": {
+                    "$ref": "TableReference",
+                    "description": "[Optional] Describes the table where the query results should be stored. If not present, a new table will be created to store the results. This property must be set for large results that exceed the maximum response size."
+                },
+                "flattenResults": {
+                    "default": "true",
+                    "description": "[Optional] If true and query uses legacy SQL dialect, flattens all nested and repeated fields in the query results. allowLargeResults must be true if this is set to false. For standard SQL queries, this flag is ignored and results are never flattened.",
+                    "type": "boolean"
+                },
+                "maximumBillingTier": {
+                    "default": "1",
+                    "description": "[Optional] Limits the billing tier for this job. Queries that have resource usage beyond this tier will fail (without incurring a charge). If unspecified, this will be set to your project default.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "maximumBytesBilled": {
+                    "description": "[Optional] Limits the bytes billed for this job. Queries that will have bytes billed beyond this limit will fail (without incurring a charge). If unspecified, this will be set to your project default.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "parameterMode": {
+                    "description": "Standard SQL only. Set to POSITIONAL to use positional (?) query parameters or to NAMED to use named (@myparam) query parameters in this query.",
+                    "type": "string"
+                },
+                "preserveNulls": {
+                    "description": "[Deprecated] This property is deprecated.",
+                    "type": "boolean"
+                },
+                "priority": {
+                    "description": "[Optional] Specifies a priority for the query. Possible values include INTERACTIVE and BATCH. The default value is INTERACTIVE.",
+                    "type": "string"
+                },
+                "query": {
+                    "description": "[Required] SQL query text to execute. The useLegacySql field can be used to indicate whether the query uses legacy SQL or standard SQL.",
+                    "type": "string"
+                },
+                "queryParameters": {
+                    "description": "Query parameters for standard SQL queries.",
+                    "items": {
+                        "$ref": "QueryParameter"
+                    },
+                    "type": "array"
+                },
+                "rangePartitioning": {
+                    "$ref": "RangePartitioning",
+                    "description": "[TrustedTester] Range partitioning specification for this table. Only one of timePartitioning and rangePartitioning should be specified."
+                },
+                "schemaUpdateOptions": {
+                    "description": "Allows the schema of the destination table to be updated as a side effect of the query job. Schema update options are supported in two cases: when writeDisposition is WRITE_APPEND; when writeDisposition is WRITE_TRUNCATE and the destination table is a partition of a table, specified by partition decorators. For normal tables, WRITE_TRUNCATE will always overwrite the schema. One or more of the following values are specified: ALLOW_FIELD_ADDITION: allow adding a nullable field to the schema. ALLOW_FIELD_RELAXATION: allow relaxing a required field in the original schema to nullable.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "tableDefinitions": {
+                    "additionalProperties": {
+                        "$ref": "ExternalDataConfiguration"
+                    },
+                    "description": "[Optional] If querying an external data source outside of BigQuery, describes the data format, location and other properties of the data source. By defining these properties, the data source can then be queried as if it were a standard BigQuery table.",
+                    "type": "object"
+                },
+                "timePartitioning": {
+                    "$ref": "TimePartitioning",
+                    "description": "Time-based partitioning specification for the destination table. Only one of timePartitioning and rangePartitioning should be specified."
+                },
+                "useLegacySql": {
+                    "default": "true",
+                    "description": "Specifies whether to use BigQuery's legacy SQL dialect for this query. The default value is true. If set to false, the query will use BigQuery's standard SQL: https://cloud.google.com/bigquery/sql-reference/ When useLegacySql is set to false, the value of flattenResults is ignored; query will be run as if flattenResults is false.",
+                    "type": "boolean"
+                },
+                "useQueryCache": {
+                    "default": "true",
+                    "description": "[Optional] Whether to look for the result in the query cache. The query cache is a best-effort cache that will be flushed whenever tables in the query are modified. Moreover, the query cache is only available when a query does not have a destination table specified. The default value is true.",
+                    "type": "boolean"
+                },
+                "userDefinedFunctionResources": {
+                    "description": "Describes user-defined function resources used in the query.",
+                    "items": {
+                        "$ref": "UserDefinedFunctionResource"
+                    },
+                    "type": "array"
+                },
+                "writeDisposition": {
+                    "description": "[Optional] Specifies the action that occurs if the destination table already exists. The following values are supported: WRITE_TRUNCATE: If the table already exists, BigQuery overwrites the table data and uses the schema from the query result. WRITE_APPEND: If the table already exists, BigQuery appends the data to the table. WRITE_EMPTY: If the table already exists and contains data, a 'duplicate' error is returned in the job result. The default value is WRITE_EMPTY. Each action is atomic and only occurs if BigQuery is able to complete the job successfully. Creation, truncation and append actions occur as one atomic update upon job completion.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "JobConfigurationTableCopy": {
+            "id": "JobConfigurationTableCopy",
+            "properties": {
+                "createDisposition": {
+                    "description": "[Optional] Specifies whether the job is allowed to create new tables. The following values are supported: CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table. CREATE_NEVER: The table must already exist. If it does not, a 'notFound' error is returned in the job result. The default value is CREATE_IF_NEEDED. Creation, truncation and append actions occur as one atomic update upon job completion.",
+                    "type": "string"
+                },
+                "destinationEncryptionConfiguration": {
+                    "$ref": "EncryptionConfiguration",
+                    "description": "Custom encryption configuration (e.g., Cloud KMS keys)."
+                },
+                "destinationExpirationTime": {
+                    "description": "[Optional] The time when the destination table expires. Expired tables will be deleted and their storage reclaimed.",
+                    "type": "any"
+                },
+                "destinationTable": {
+                    "$ref": "TableReference",
+                    "description": "[Required] The destination table"
+                },
+                "operationType": {
+                    "description": "[Optional] Supported operation types in table copy job.",
+                    "type": "string"
+                },
+                "sourceTable": {
+                    "$ref": "TableReference",
+                    "description": "[Pick one] Source table to copy."
+                },
+                "sourceTables": {
+                    "description": "[Pick one] Source tables to copy.",
+                    "items": {
+                        "$ref": "TableReference"
+                    },
+                    "type": "array"
+                },
+                "writeDisposition": {
+                    "description": "[Optional] Specifies the action that occurs if the destination table already exists. The following values are supported: WRITE_TRUNCATE: If the table already exists, BigQuery overwrites the table data. WRITE_APPEND: If the table already exists, BigQuery appends the data to the table. WRITE_EMPTY: If the table already exists and contains data, a 'duplicate' error is returned in the job result. The default value is WRITE_EMPTY. Each action is atomic and only occurs if BigQuery is able to complete the job successfully. Creation, truncation and append actions occur as one atomic update upon job completion.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "JobList": {
+            "id": "JobList",
+            "properties": {
+                "etag": {
+                    "description": "A hash of this page of results.",
+                    "type": "string"
+                },
+                "jobs": {
+                    "description": "List of jobs that were requested.",
+                    "items": {
+                        "properties": {
+                            "configuration": {
+                                "$ref": "JobConfiguration",
+                                "description": "[Full-projection-only] Specifies the job configuration."
+                            },
+                            "errorResult": {
+                                "$ref": "ErrorProto",
+                                "description": "A result object that will be present only if the job has failed."
+                            },
+                            "id": {
+                                "description": "Unique opaque ID of the job.",
+                                "type": "string"
+                            },
+                            "jobReference": {
+                                "$ref": "JobReference",
+                                "description": "Job reference uniquely identifying the job."
+                            },
+                            "kind": {
+                                "default": "bigquery#job",
+                                "description": "The resource type.",
+                                "type": "string"
+                            },
+                            "state": {
+                                "description": "Running state of the job. When the state is DONE, errorResult can be checked to determine whether the job succeeded or failed.",
+                                "type": "string"
+                            },
+                            "statistics": {
+                                "$ref": "JobStatistics",
+                                "description": "[Output-only] Information about the job, including starting time and ending time of the job."
+                            },
+                            "status": {
+                                "$ref": "JobStatus",
+                                "description": "[Full-projection-only] Describes the state of the job."
+                            },
+                            "user_email": {
+                                "description": "[Full-projection-only] Email address of the user who ran the job.",
+                                "type": "string"
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                },
+                "kind": {
+                    "default": "bigquery#jobList",
+                    "description": "The resource type of the response.",
+                    "type": "string"
+                },
+                "nextPageToken": {
+                    "description": "A token to request the next page of results.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "JobReference": {
+            "id": "JobReference",
+            "properties": {
+                "jobId": {
+                    "annotations": {
+                        "required": [
+                            "bigquery.jobs.getQueryResults"
+                        ]
+                    },
+                    "description": "[Required] The ID of the job. The ID must contain only letters (a-z, A-Z), numbers (0-9), underscores (_), or dashes (-). The maximum length is 1,024 characters.",
+                    "type": "string"
+                },
+                "location": {
+                    "description": "The geographic location of the job. See details at https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+                    "type": "string"
+                },
+                "projectId": {
+                    "annotations": {
+                        "required": [
+                            "bigquery.jobs.getQueryResults"
+                        ]
+                    },
+                    "description": "[Required] The ID of the project containing this job.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "JobStatistics": {
+            "id": "JobStatistics",
+            "properties": {
+                "completionRatio": {
+                    "description": "[TrustedTester] [Output-only] Job progress (0.0 -> 1.0) for LOAD and EXTRACT jobs.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "creationTime": {
+                    "description": "[Output-only] Creation time of this job, in milliseconds since the epoch. This field will be present on all jobs.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "endTime": {
+                    "description": "[Output-only] End time of this job, in milliseconds since the epoch. This field will be present whenever a job is in the DONE state.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "extract": {
+                    "$ref": "JobStatistics4",
+                    "description": "[Output-only] Statistics for an extract job."
+                },
+                "load": {
+                    "$ref": "JobStatistics3",
+                    "description": "[Output-only] Statistics for a load job."
+                },
+                "numChildJobs": {
+                    "description": "[Output-only] Number of child jobs executed.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "parentJobId": {
+                    "description": "[Output-only] If this is a child job, the id of the parent.",
+                    "type": "string"
+                },
+                "query": {
+                    "$ref": "JobStatistics2",
+                    "description": "[Output-only] Statistics for a query job."
+                },
+                "quotaDeferments": {
+                    "description": "[Output-only] Quotas which delayed this job's start time.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "reservationUsage": {
+                    "description": "[Output-only] Job resource usage breakdown by reservation.",
+                    "items": {
+                        "properties": {
+                            "name": {
+                                "description": "[Output-only] Reservation name or \"unreserved\" for on-demand resources usage.",
+                                "type": "string"
+                            },
+                            "slotMs": {
+                                "description": "[Output-only] Slot-milliseconds the job spent in the given reservation.",
+                                "format": "int64",
+                                "type": "string"
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                },
+                "reservation_id": {
+                    "description": "[Output-only] Name of the primary reservation assigned to this job. Note that this could be different than reservations reported in the reservation usage field if parent reservations were used to execute this job.",
+                    "type": "string"
+                },
+                "rowLevelSecurityStatistics": {
+                    "$ref": "RowLevelSecurityStatistics",
+                    "description": "[Output-only] [Preview] Statistics for row-level security. Present only for query and extract jobs."
+                },
+                "scriptStatistics": {
+                    "$ref": "ScriptStatistics",
+                    "description": "[Output-only] Statistics for a child job of a script."
+                },
+                "sessionInfoTemplate": {
+                    "$ref": "SessionInfo",
+                    "description": "[Output-only] [Preview] Information of the session if this job is part of one."
+                },
+                "startTime": {
+                    "description": "[Output-only] Start time of this job, in milliseconds since the epoch. This field will be present when the job transitions from the PENDING state to either RUNNING or DONE.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "totalBytesProcessed": {
+                    "description": "[Output-only] [Deprecated] Use the bytes processed in the query statistics instead.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "totalSlotMs": {
+                    "description": "[Output-only] Slot-milliseconds for the job.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "transactionInfoTemplate": {
+                    "$ref": "TransactionInfo",
+                    "description": "[Output-only] [Alpha] Information of the multi-statement transaction if this job is part of one."
+                }
+            },
+            "type": "object"
+        },
+        "JobStatistics2": {
+            "id": "JobStatistics2",
+            "properties": {
+                "billingTier": {
+                    "description": "[Output-only] Billing tier for the job.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "cacheHit": {
+                    "description": "[Output-only] Whether the query result was fetched from the query cache.",
+                    "type": "boolean"
+                },
+                "ddlAffectedRowAccessPolicyCount": {
+                    "description": "[Output-only] [Preview] The number of row access policies affected by a DDL statement. Present only for DROP ALL ROW ACCESS POLICIES queries.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "ddlOperationPerformed": {
+                    "description": "The DDL operation performed, possibly dependent on the pre-existence of the DDL target. Possible values (new values might be added in the future): \"CREATE\": The query created the DDL target. \"SKIP\": No-op. Example cases: the query is CREATE TABLE IF NOT EXISTS while the table already exists, or the query is DROP TABLE IF EXISTS while the table does not exist. \"REPLACE\": The query replaced the DDL target. Example case: the query is CREATE OR REPLACE TABLE, and the table already exists. \"DROP\": The query deleted the DDL target.",
+                    "type": "string"
+                },
+                "ddlTargetDataset": {
+                    "$ref": "DatasetReference",
+                    "description": "[Output-only] The DDL target dataset. Present only for CREATE/ALTER/DROP SCHEMA queries."
+                },
+                "ddlTargetRoutine": {
+                    "$ref": "RoutineReference",
+                    "description": "The DDL target routine. Present only for CREATE/DROP FUNCTION/PROCEDURE queries."
+                },
+                "ddlTargetRowAccessPolicy": {
+                    "$ref": "RowAccessPolicyReference",
+                    "description": "[Output-only] [Preview] The DDL target row access policy. Present only for CREATE/DROP ROW ACCESS POLICY queries."
+                },
+                "ddlTargetTable": {
+                    "$ref": "TableReference",
+                    "description": "[Output-only] The DDL target table. Present only for CREATE/DROP TABLE/VIEW and DROP ALL ROW ACCESS POLICIES queries."
+                },
+                "estimatedBytesProcessed": {
+                    "description": "[Output-only] The original estimate of bytes processed for the job.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "modelTraining": {
+                    "$ref": "BigQueryModelTraining",
+                    "description": "[Output-only, Beta] Information about create model query job progress."
+                },
+                "modelTrainingCurrentIteration": {
+                    "description": "[Output-only, Beta] Deprecated; do not use.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "modelTrainingExpectedTotalIteration": {
+                    "description": "[Output-only, Beta] Deprecated; do not use.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "numDmlAffectedRows": {
+                    "description": "[Output-only] The number of rows affected by a DML statement. Present only for DML statements INSERT, UPDATE or DELETE.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "queryPlan": {
+                    "description": "[Output-only] Describes execution plan for the query.",
+                    "items": {
+                        "$ref": "ExplainQueryStage"
+                    },
+                    "type": "array"
+                },
+                "referencedRoutines": {
+                    "description": "[Output-only] Referenced routines (persistent user-defined functions and stored procedures) for the job.",
+                    "items": {
+                        "$ref": "RoutineReference"
+                    },
+                    "type": "array"
+                },
+                "referencedTables": {
+                    "description": "[Output-only] Referenced tables for the job. Queries that reference more than 50 tables will not have a complete list.",
+                    "items": {
+                        "$ref": "TableReference"
+                    },
+                    "type": "array"
+                },
+                "reservationUsage": {
+                    "description": "[Output-only] Job resource usage breakdown by reservation.",
+                    "items": {
+                        "properties": {
+                            "name": {
+                                "description": "[Output-only] Reservation name or \"unreserved\" for on-demand resources usage.",
+                                "type": "string"
+                            },
+                            "slotMs": {
+                                "description": "[Output-only] Slot-milliseconds the job spent in the given reservation.",
+                                "format": "int64",
+                                "type": "string"
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                },
+                "schema": {
+                    "$ref": "TableSchema",
+                    "description": "[Output-only] The schema of the results. Present only for successful dry run of non-legacy SQL queries."
+                },
+                "statementType": {
+                    "description": "The type of query statement, if valid. Possible values (new values might be added in the future): \"SELECT\": SELECT query. \"INSERT\": INSERT query; see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-manipulation-language. \"UPDATE\": UPDATE query; see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-manipulation-language. \"DELETE\": DELETE query; see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-manipulation-language. \"MERGE\": MERGE query; see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-manipulation-language. \"ALTER_TABLE\": ALTER TABLE query. \"ALTER_VIEW\": ALTER VIEW query. \"ASSERT\": ASSERT condition AS 'description'. \"CREATE_FUNCTION\": CREATE FUNCTION query. \"CREATE_MODEL\": CREATE [OR REPLACE] MODEL ... AS SELECT ... . \"CREATE_PROCEDURE\": CREATE PROCEDURE query. \"CREATE_TABLE\": CREATE [OR REPLACE] TABLE without AS SELECT. \"CREATE_TABLE_AS_SELECT\": CREATE [OR REPLACE] TABLE ... AS SELECT ... . \"CREATE_VIEW\": CREATE [OR REPLACE] VIEW ... AS SELECT ... . \"DROP_FUNCTION\" : DROP FUNCTION query. \"DROP_PROCEDURE\": DROP PROCEDURE query. \"DROP_TABLE\": DROP TABLE query. \"DROP_VIEW\": DROP VIEW query.",
+                    "type": "string"
+                },
+                "timeline": {
+                    "description": "[Output-only] [Beta] Describes a timeline of job execution.",
+                    "items": {
+                        "$ref": "QueryTimelineSample"
+                    },
+                    "type": "array"
+                },
+                "totalBytesBilled": {
+                    "description": "[Output-only] Total bytes billed for the job.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "totalBytesProcessed": {
+                    "description": "[Output-only] Total bytes processed for the job.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "totalBytesProcessedAccuracy": {
+                    "description": "[Output-only] For dry-run jobs, totalBytesProcessed is an estimate and this field specifies the accuracy of the estimate. Possible values can be: UNKNOWN: accuracy of the estimate is unknown. PRECISE: estimate is precise. LOWER_BOUND: estimate is lower bound of what the query would cost. UPPER_BOUND: estimate is upper bound of what the query would cost.",
+                    "type": "string"
+                },
+                "totalPartitionsProcessed": {
+                    "description": "[Output-only] Total number of partitions processed from all partitioned tables referenced in the job.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "totalSlotMs": {
+                    "description": "[Output-only] Slot-milliseconds for the job.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "undeclaredQueryParameters": {
+                    "description": "Standard SQL only: list of undeclared query parameters detected during a dry run validation.",
+                    "items": {
+                        "$ref": "QueryParameter"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "JobStatistics3": {
+            "id": "JobStatistics3",
+            "properties": {
+                "badRecords": {
+                    "description": "[Output-only] The number of bad records encountered. Note that if the job has failed because of more bad records encountered than the maximum allowed in the load job configuration, then this number can be less than the total number of bad records present in the input data.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "inputFileBytes": {
+                    "description": "[Output-only] Number of bytes of source data in a load job.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "inputFiles": {
+                    "description": "[Output-only] Number of source files in a load job.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "outputBytes": {
+                    "description": "[Output-only] Size of the loaded data in bytes. Note that while a load job is in the running state, this value may change.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "outputRows": {
+                    "description": "[Output-only] Number of rows imported in a load job. Note that while an import job is in the running state, this value may change.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "JobStatistics4": {
+            "id": "JobStatistics4",
+            "properties": {
+                "destinationUriFileCounts": {
+                    "description": "[Output-only] Number of files per destination URI or URI pattern specified in the extract configuration. These values will be in the same order as the URIs specified in the 'destinationUris' field.",
+                    "items": {
+                        "format": "int64",
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "inputBytes": {
+                    "description": "[Output-only] Number of user bytes extracted into the result. This is the byte count as computed by BigQuery for billing purposes.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "JobStatus": {
+            "id": "JobStatus",
+            "properties": {
+                "errorResult": {
+                    "$ref": "ErrorProto",
+                    "description": "[Output-only] Final error result of the job. If present, indicates that the job has completed and was unsuccessful."
+                },
+                "errors": {
+                    "description": "[Output-only] The first errors encountered during the running of the job. The final message includes the number of errors that caused the process to stop. Errors here do not necessarily mean that the job has completed or was unsuccessful.",
+                    "items": {
+                        "$ref": "ErrorProto"
+                    },
+                    "type": "array"
+                },
+                "state": {
+                    "description": "[Output-only] Running state of the job.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "JsonObject": {
+            "additionalProperties": {
+                "$ref": "JsonValue"
+            },
+            "description": "Represents a single JSON object.",
+            "id": "JsonObject",
+            "type": "object"
+        },
+        "JsonValue": {
+            "id": "JsonValue",
+            "type": "any"
+        },
+        "ListModelsResponse": {
+            "id": "ListModelsResponse",
+            "properties": {
+                "models": {
+                    "description": "Models in the requested dataset. Only the following fields are populated: model_reference, model_type, creation_time, last_modified_time and labels.",
+                    "items": {
+                        "$ref": "Model"
+                    },
+                    "type": "array"
+                },
+                "nextPageToken": {
+                    "description": "A token to request the next page of results.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "ListRoutinesResponse": {
+            "id": "ListRoutinesResponse",
+            "properties": {
+                "nextPageToken": {
+                    "description": "A token to request the next page of results.",
+                    "type": "string"
+                },
+                "routines": {
+                    "description": "Routines in the requested dataset. Unless read_mask is set in the request, only the following fields are populated: etag, project_id, dataset_id, routine_id, routine_type, creation_time, last_modified_time, and language.",
+                    "items": {
+                        "$ref": "Routine"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "ListRowAccessPoliciesResponse": {
+            "description": "Response message for the ListRowAccessPolicies method.",
+            "id": "ListRowAccessPoliciesResponse",
+            "properties": {
+                "nextPageToken": {
+                    "description": "A token to request the next page of results.",
+                    "type": "string"
+                },
+                "rowAccessPolicies": {
+                    "description": "Row access policies on the requested table.",
+                    "items": {
+                        "$ref": "RowAccessPolicy"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "LocationMetadata": {
+            "description": "BigQuery-specific metadata about a location. This will be set on google.cloud.location.Location.metadata in Cloud Location API responses.",
+            "id": "LocationMetadata",
+            "properties": {
+                "legacyLocationId": {
+                    "description": "The legacy BigQuery location ID, e.g. \u201cEU\u201d for the \u201ceurope\u201d location. This is for any API consumers that need the legacy \u201cUS\u201d and \u201cEU\u201d locations.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "MaterializedViewDefinition": {
+            "id": "MaterializedViewDefinition",
+            "properties": {
+                "enableRefresh": {
+                    "description": "[Optional] [TrustedTester] Enable automatic refresh of the materialized view when the base table is updated. The default value is \"true\".",
+                    "type": "boolean"
+                },
+                "lastRefreshTime": {
+                    "description": "[Output-only] [TrustedTester] The time when this materialized view was last modified, in milliseconds since the epoch.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "query": {
+                    "description": "[Required] A query whose result is persisted.",
+                    "type": "string"
+                },
+                "refreshIntervalMs": {
+                    "description": "[Optional] [TrustedTester] The maximum frequency at which this materialized view will be refreshed. The default value is \"1800000\" (30 minutes).",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "Model": {
+            "id": "Model",
+            "properties": {
+                "bestTrialId": {
+                    "description": "The best trial_id across all training runs.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "creationTime": {
+                    "description": "Output only. The time when this model was created, in millisecs since the epoch.",
+                    "format": "int64",
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "description": {
+                    "description": "Optional. A user-friendly description of this model.",
+                    "type": "string"
+                },
+                "encryptionConfiguration": {
+                    "$ref": "EncryptionConfiguration",
+                    "description": "Custom encryption configuration (e.g., Cloud KMS keys). This shows the encryption configuration of the model data while stored in BigQuery storage. This field can be used with PatchModel to update encryption key for an already encrypted model."
+                },
+                "etag": {
+                    "description": "Output only. A hash of this resource.",
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "expirationTime": {
+                    "description": "Optional. The time when this model expires, in milliseconds since the epoch. If not present, the model will persist indefinitely. Expired models will be deleted and their storage reclaimed. The defaultTableExpirationMs property of the encapsulating dataset can be used to set a default expirationTime on newly created models.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "featureColumns": {
+                    "description": "Output only. Input feature columns that were used to train this model.",
+                    "items": {
+                        "$ref": "StandardSqlField"
+                    },
+                    "readOnly": true,
+                    "type": "array"
+                },
+                "friendlyName": {
+                    "description": "Optional. A descriptive name for this model.",
+                    "type": "string"
+                },
+                "labelColumns": {
+                    "description": "Output only. Label columns that were used to train this model. The output of the model will have a \"predicted_\" prefix to these columns.",
+                    "items": {
+                        "$ref": "StandardSqlField"
+                    },
+                    "readOnly": true,
+                    "type": "array"
+                },
+                "labels": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "description": "The labels associated with this model. You can use these to organize and group your models. Label keys and values can be no longer than 63 characters, can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. Label values are optional. Label keys must start with a letter and each label in the list must have a different key.",
+                    "type": "object"
+                },
+                "lastModifiedTime": {
+                    "description": "Output only. The time when this model was last modified, in millisecs since the epoch.",
+                    "format": "int64",
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "location": {
+                    "description": "Output only. The geographic location where the model resides. This value is inherited from the dataset.",
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "modelReference": {
+                    "$ref": "ModelReference",
+                    "description": "Required. Unique identifier for this model."
+                },
+                "modelType": {
+                    "description": "Output only. Type of the model resource.",
+                    "enum": [
+                        "MODEL_TYPE_UNSPECIFIED",
+                        "LINEAR_REGRESSION",
+                        "LOGISTIC_REGRESSION",
+                        "KMEANS",
+                        "MATRIX_FACTORIZATION",
+                        "DNN_CLASSIFIER",
+                        "TENSORFLOW",
+                        "DNN_REGRESSOR",
+                        "BOOSTED_TREE_REGRESSOR",
+                        "BOOSTED_TREE_CLASSIFIER",
+                        "ARIMA",
+                        "AUTOML_REGRESSOR",
+                        "AUTOML_CLASSIFIER"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "Linear regression model.",
+                        "Logistic regression based classification model.",
+                        "K-means clustering model.",
+                        "Matrix factorization model.",
+                        "DNN classifier model.",
+                        "An imported TensorFlow model.",
+                        "DNN regressor model.",
+                        "Boosted tree regressor model.",
+                        "Boosted tree classifier model.",
+                        "ARIMA model.",
+                        "[Beta] AutoML Tables regression model.",
+                        "[Beta] AutoML Tables classification model."
+                    ],
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "trainingRuns": {
+                    "description": "Output only. Information for all training runs in increasing order of start_time.",
+                    "items": {
+                        "$ref": "TrainingRun"
+                    },
+                    "readOnly": true,
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "ModelDefinition": {
+            "id": "ModelDefinition",
+            "properties": {
+                "modelOptions": {
+                    "description": "[Output-only, Beta] Model options used for the first training run. These options are immutable for subsequent training runs. Default values are used for any options not specified in the input query.",
+                    "properties": {
+                        "labels": {
+                            "items": {
+                                "type": "string"
+                            },
+                            "type": "array"
+                        },
+                        "lossType": {
+                            "type": "string"
+                        },
+                        "modelType": {
+                            "type": "string"
+                        }
+                    },
+                    "type": "object"
+                },
+                "trainingRuns": {
+                    "description": "[Output-only, Beta] Information about ml training runs, each training run comprises of multiple iterations and there may be multiple training runs for the model if warm start is used or if a user decides to continue a previously cancelled query.",
+                    "items": {
+                        "$ref": "BqmlTrainingRun"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "ModelReference": {
+            "id": "ModelReference",
+            "properties": {
+                "datasetId": {
+                    "description": "[Required] The ID of the dataset containing this model.",
+                    "type": "string"
+                },
+                "modelId": {
+                    "description": "[Required] The ID of the model. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 1,024 characters.",
+                    "type": "string"
+                },
+                "projectId": {
+                    "description": "[Required] The ID of the project containing this model.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "MultiClassClassificationMetrics": {
+            "description": "Evaluation metrics for multi-class classification/classifier models.",
+            "id": "MultiClassClassificationMetrics",
+            "properties": {
+                "aggregateClassificationMetrics": {
+                    "$ref": "AggregateClassificationMetrics",
+                    "description": "Aggregate classification metrics."
+                },
+                "confusionMatrixList": {
+                    "description": "Confusion matrix at different thresholds.",
+                    "items": {
+                        "$ref": "ConfusionMatrix"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "ParquetOptions": {
+            "id": "ParquetOptions",
+            "properties": {
+                "enableListInference": {
+                    "description": "[Optional] Indicates whether to use schema inference specifically for Parquet LIST logical type.",
+                    "type": "boolean"
+                },
+                "enumAsString": {
+                    "description": "[Optional] Indicates whether to infer Parquet ENUM logical type as STRING instead of BYTES by default.",
+                    "type": "boolean"
+                }
+            },
+            "type": "object"
+        },
+        "Policy": {
+            "description": "An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members` to a single `role`. Members can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** { \"bindings\": [ { \"role\": \"roles/resourcemanager.organizationAdmin\", \"members\": [ \"user:mike@example.com\", \"group:admins@example.com\", \"domain:google.com\", \"serviceAccount:my-project-id@appspot.gserviceaccount.com\" ] }, { \"role\": \"roles/resourcemanager.organizationViewer\", \"members\": [ \"user:eve@example.com\" ], \"condition\": { \"title\": \"expirable access\", \"description\": \"Does not grant access after Sep 2020\", \"expression\": \"request.time < timestamp('2020-10-01T00:00:00.000Z')\", } } ], \"etag\": \"BwWWja0YfJA=\", \"version\": 3 } **YAML example:** bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') - etag: BwWWja0YfJA= - version: 3 For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).",
+            "id": "Policy",
+            "properties": {
+                "auditConfigs": {
+                    "description": "Specifies cloud audit logging configuration for this policy.",
+                    "items": {
+                        "$ref": "AuditConfig"
+                    },
+                    "type": "array"
+                },
+                "bindings": {
+                    "description": "Associates a list of `members` to a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one member.",
+                    "items": {
+                        "$ref": "Binding"
+                    },
+                    "type": "array"
+                },
+                "etag": {
+                    "description": "`etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.",
+                    "format": "byte",
+                    "type": "string"
+                },
+                "version": {
+                    "description": "Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).",
+                    "format": "int32",
+                    "type": "integer"
+                }
+            },
+            "type": "object"
+        },
+        "PrincipalComponentInfo": {
+            "description": "Principal component infos, used only for eigen decomposition based models, e.g., PCA. Ordered by explained_variance in the descending order.",
+            "id": "PrincipalComponentInfo",
+            "properties": {
+                "cumulativeExplainedVarianceRatio": {
+                    "description": "The explained_variance is pre-ordered in the descending order to compute the cumulative explained variance ratio.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "explainedVariance": {
+                    "description": "Explained variance by this principal component, which is simply the eigenvalue.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "explainedVarianceRatio": {
+                    "description": "Explained_variance over the total explained variance.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "principalComponentId": {
+                    "description": "Id of the principal component.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "ProjectList": {
+            "id": "ProjectList",
+            "properties": {
+                "etag": {
+                    "description": "A hash of the page of results",
+                    "type": "string"
+                },
+                "kind": {
+                    "default": "bigquery#projectList",
+                    "description": "The type of list.",
+                    "type": "string"
+                },
+                "nextPageToken": {
+                    "description": "A token to request the next page of results.",
+                    "type": "string"
+                },
+                "projects": {
+                    "description": "Projects to which you have at least READ access.",
+                    "items": {
+                        "properties": {
+                            "friendlyName": {
+                                "description": "A descriptive name for this project.",
+                                "type": "string"
+                            },
+                            "id": {
+                                "description": "An opaque ID of this project.",
+                                "type": "string"
+                            },
+                            "kind": {
+                                "default": "bigquery#project",
+                                "description": "The resource type.",
+                                "type": "string"
+                            },
+                            "numericId": {
+                                "description": "The numeric ID of this project.",
+                                "format": "uint64",
+                                "type": "string"
+                            },
+                            "projectReference": {
+                                "$ref": "ProjectReference",
+                                "description": "A unique reference to this project."
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                },
+                "totalItems": {
+                    "description": "The total number of projects in the list.",
+                    "format": "int32",
+                    "type": "integer"
+                }
+            },
+            "type": "object"
+        },
+        "ProjectReference": {
+            "id": "ProjectReference",
+            "properties": {
+                "projectId": {
+                    "description": "[Required] ID of the project. Can be either the numeric ID or the assigned ID of the project.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "QueryParameter": {
+            "id": "QueryParameter",
+            "properties": {
+                "name": {
+                    "description": "[Optional] If unset, this is a positional parameter. Otherwise, should be unique within a query.",
+                    "type": "string"
+                },
+                "parameterType": {
+                    "$ref": "QueryParameterType",
+                    "description": "[Required] The type of this parameter."
+                },
+                "parameterValue": {
+                    "$ref": "QueryParameterValue",
+                    "description": "[Required] The value of this parameter."
+                }
+            },
+            "type": "object"
+        },
+        "QueryParameterType": {
+            "id": "QueryParameterType",
+            "properties": {
+                "arrayType": {
+                    "$ref": "QueryParameterType",
+                    "description": "[Optional] The type of the array's elements, if this is an array."
+                },
+                "structTypes": {
+                    "description": "[Optional] The types of the fields of this struct, in order, if this is a struct.",
+                    "items": {
+                        "properties": {
+                            "description": {
+                                "description": "[Optional] Human-oriented description of the field.",
+                                "type": "string"
+                            },
+                            "name": {
+                                "description": "[Optional] The name of this field.",
+                                "type": "string"
+                            },
+                            "type": {
+                                "$ref": "QueryParameterType",
+                                "description": "[Required] The type of this field."
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                },
+                "type": {
+                    "description": "[Required] The top level type of this field.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "QueryParameterValue": {
+            "id": "QueryParameterValue",
+            "properties": {
+                "arrayValues": {
+                    "description": "[Optional] The array values, if this is an array type.",
+                    "items": {
+                        "$ref": "QueryParameterValue"
+                    },
+                    "type": "array"
+                },
+                "structValues": {
+                    "additionalProperties": {
+                        "$ref": "QueryParameterValue"
+                    },
+                    "description": "[Optional] The struct field values, in order of the struct type's declaration.",
+                    "type": "object"
+                },
+                "value": {
+                    "description": "[Optional] The value of this value, if a simple scalar type.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "QueryRequest": {
+            "id": "QueryRequest",
+            "properties": {
+                "connectionProperties": {
+                    "description": "Connection properties.",
+                    "items": {
+                        "$ref": "ConnectionProperty"
+                    },
+                    "type": "array"
+                },
+                "createSession": {
+                    "description": "If true, creates a new session, where session id will be a server generated random id. If false, runs query with an existing session_id passed in ConnectionProperty, otherwise runs query in non-session mode.",
+                    "type": "boolean"
+                },
+                "defaultDataset": {
+                    "$ref": "DatasetReference",
+                    "description": "[Optional] Specifies the default datasetId and projectId to assume for any unqualified table names in the query. If not set, all table names in the query string must be qualified in the format 'datasetId.tableId'."
+                },
+                "dryRun": {
+                    "description": "[Optional] If set to true, BigQuery doesn't run the job. Instead, if the query is valid, BigQuery returns statistics about the job such as how many bytes would be processed. If the query is invalid, an error returns. The default value is false.",
+                    "type": "boolean"
+                },
+                "kind": {
+                    "default": "bigquery#queryRequest",
+                    "description": "The resource type of the request.",
+                    "type": "string"
+                },
+                "labels": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "description": "The labels associated with this job. You can use these to organize and group your jobs. Label keys and values can be no longer than 63 characters, can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. Label values are optional. Label keys must start with a letter and each label in the list must have a different key.",
+                    "type": "object"
+                },
+                "location": {
+                    "description": "The geographic location where the job should run. See details at https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+                    "type": "string"
+                },
+                "maxResults": {
+                    "description": "[Optional] The maximum number of rows of data to return per page of results. Setting this flag to a small value such as 1000 and then paging through results might improve reliability when the query result set is large. In addition to this limit, responses are also limited to 10 MB. By default, there is no maximum row count, and only the byte limit applies.",
+                    "format": "uint32",
+                    "type": "integer"
+                },
+                "maximumBytesBilled": {
+                    "description": "[Optional] Limits the bytes billed for this job. Queries that will have bytes billed beyond this limit will fail (without incurring a charge). If unspecified, this will be set to your project default.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "parameterMode": {
+                    "description": "Standard SQL only. Set to POSITIONAL to use positional (?) query parameters or to NAMED to use named (@myparam) query parameters in this query.",
+                    "type": "string"
+                },
+                "preserveNulls": {
+                    "description": "[Deprecated] This property is deprecated.",
+                    "type": "boolean"
+                },
+                "query": {
+                    "annotations": {
+                        "required": [
+                            "bigquery.jobs.query"
+                        ]
+                    },
+                    "description": "[Required] A query string, following the BigQuery query syntax, of the query to execute. Example: \"SELECT count(f1) FROM [myProjectId:myDatasetId.myTableId]\".",
+                    "type": "string"
+                },
+                "queryParameters": {
+                    "description": "Query parameters for Standard SQL queries.",
+                    "items": {
+                        "$ref": "QueryParameter"
+                    },
+                    "type": "array"
+                },
+                "requestId": {
+                    "description": "A unique user provided identifier to ensure idempotent behavior for queries. Note that this is different from the job_id. It has the following properties: 1. It is case-sensitive, limited to up to 36 ASCII characters. A UUID is recommended. 2. Read only queries can ignore this token since they are nullipotent by definition. 3. For the purposes of idempotency ensured by the request_id, a request is considered duplicate of another only if they have the same request_id and are actually duplicates. When determining whether a request is a duplicate of the previous request, all parameters in the request that may affect the behavior are considered. For example, query, connection_properties, query_parameters, use_legacy_sql are parameters that affect the result and are considered when determining whether a request is a duplicate, but properties like timeout_ms don't affect the result and are thus not considered. Dry run query requests are never considered duplicate of another request. 4. When a duplicate mutating query request is detected, it returns: a. the results of the mutation if it completes successfully within the timeout. b. the running operation if it is still in progress at the end of the timeout. 5. Its lifetime is limited to 15 minutes. In other words, if two requests are sent with the same request_id, but more than 15 minutes apart, idempotency is not guaranteed.",
+                    "type": "string"
+                },
+                "timeoutMs": {
+                    "description": "[Optional] How long to wait for the query to complete, in milliseconds, before the request times out and returns. Note that this is only a timeout for the request, not the query. If the query takes longer to run than the timeout value, the call returns without any results and with the 'jobComplete' flag set to false. You can call GetQueryResults() to wait for the query to complete and read the results. The default value is 10000 milliseconds (10 seconds).",
+                    "format": "uint32",
+                    "type": "integer"
+                },
+                "useLegacySql": {
+                    "default": "true",
+                    "description": "Specifies whether to use BigQuery's legacy SQL dialect for this query. The default value is true. If set to false, the query will use BigQuery's standard SQL: https://cloud.google.com/bigquery/sql-reference/ When useLegacySql is set to false, the value of flattenResults is ignored; query will be run as if flattenResults is false.",
+                    "type": "boolean"
+                },
+                "useQueryCache": {
+                    "default": "true",
+                    "description": "[Optional] Whether to look for the result in the query cache. The query cache is a best-effort cache that will be flushed whenever tables in the query are modified. The default value is true.",
+                    "type": "boolean"
+                }
+            },
+            "type": "object"
+        },
+        "QueryResponse": {
+            "id": "QueryResponse",
+            "properties": {
+                "cacheHit": {
+                    "description": "Whether the query result was fetched from the query cache.",
+                    "type": "boolean"
+                },
+                "errors": {
+                    "description": "[Output-only] The first errors or warnings encountered during the running of the job. The final message includes the number of errors that caused the process to stop. Errors here do not necessarily mean that the job has completed or was unsuccessful.",
+                    "items": {
+                        "$ref": "ErrorProto"
+                    },
+                    "type": "array"
+                },
+                "jobComplete": {
+                    "description": "Whether the query has completed or not. If rows or totalRows are present, this will always be true. If this is false, totalRows will not be available.",
+                    "type": "boolean"
+                },
+                "jobReference": {
+                    "$ref": "JobReference",
+                    "description": "Reference to the Job that was created to run the query. This field will be present even if the original request timed out, in which case GetQueryResults can be used to read the results once the query has completed. Since this API only returns the first page of results, subsequent pages can be fetched via the same mechanism (GetQueryResults)."
+                },
+                "kind": {
+                    "default": "bigquery#queryResponse",
+                    "description": "The resource type.",
+                    "type": "string"
+                },
+                "numDmlAffectedRows": {
+                    "description": "[Output-only] The number of rows affected by a DML statement. Present only for DML statements INSERT, UPDATE or DELETE.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "pageToken": {
+                    "description": "A token used for paging results.",
+                    "type": "string"
+                },
+                "rows": {
+                    "description": "An object with as many results as can be contained within the maximum permitted reply size. To get any additional rows, you can call GetQueryResults and specify the jobReference returned above.",
+                    "items": {
+                        "$ref": "TableRow"
+                    },
+                    "type": "array"
+                },
+                "schema": {
+                    "$ref": "TableSchema",
+                    "description": "The schema of the results. Present only when the query completes successfully."
+                },
+                "sessionInfoTemplate": {
+                    "$ref": "SessionInfo",
+                    "description": "[Output-only] [Preview] Information of the session if this job is part of one."
+                },
+                "totalBytesProcessed": {
+                    "description": "The total number of bytes processed for this query. If this query was a dry run, this is the number of bytes that would be processed if the query were run.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "totalRows": {
+                    "description": "The total number of rows in the complete query result set, which can be more than the number of rows in this single page of results.",
+                    "format": "uint64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "QueryTimelineSample": {
+            "id": "QueryTimelineSample",
+            "properties": {
+                "activeUnits": {
+                    "description": "Total number of units currently being processed by workers. This does not correspond directly to slot usage. This is the largest value observed since the last sample.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "completedUnits": {
+                    "description": "Total parallel units of work completed by this query.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "elapsedMs": {
+                    "description": "Milliseconds elapsed since the start of query execution.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "pendingUnits": {
+                    "description": "Total parallel units of work remaining for the active stages.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "totalSlotMs": {
+                    "description": "Cumulative slot-ms consumed by the query.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "RangePartitioning": {
+            "id": "RangePartitioning",
+            "properties": {
+                "field": {
+                    "description": "[TrustedTester] [Required] The table is partitioned by this field. The field must be a top-level NULLABLE/REQUIRED field. The only supported type is INTEGER/INT64.",
+                    "type": "string"
+                },
+                "range": {
+                    "description": "[TrustedTester] [Required] Defines the ranges for range partitioning.",
+                    "properties": {
+                        "end": {
+                            "description": "[TrustedTester] [Required] The end of range partitioning, exclusive.",
+                            "format": "int64",
+                            "type": "string"
+                        },
+                        "interval": {
+                            "description": "[TrustedTester] [Required] The width of each interval.",
+                            "format": "int64",
+                            "type": "string"
+                        },
+                        "start": {
+                            "description": "[TrustedTester] [Required] The start of range partitioning, inclusive.",
+                            "format": "int64",
+                            "type": "string"
+                        }
+                    },
+                    "type": "object"
+                }
+            },
+            "type": "object"
+        },
+        "RankingMetrics": {
+            "description": "Evaluation metrics used by weighted-ALS models specified by feedback_type=implicit.",
+            "id": "RankingMetrics",
+            "properties": {
+                "averageRank": {
+                    "description": "Determines the goodness of a ranking by computing the percentile rank from the predicted confidence and dividing it by the original rank.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "meanAveragePrecision": {
+                    "description": "Calculates a precision per user for all the items by ranking them and then averages all the precisions across all the users.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "meanSquaredError": {
+                    "description": "Similar to the mean squared error computed in regression and explicit recommendation models except instead of computing the rating directly, the output from evaluate is computed against a preference which is 1 or 0 depending on if the rating exists or not.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "normalizedDiscountedCumulativeGain": {
+                    "description": "A metric to determine the goodness of a ranking calculated from the predicted confidence by comparing it to an ideal rank measured by the original ratings.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "RegressionMetrics": {
+            "description": "Evaluation metrics for regression and explicit feedback type matrix factorization models.",
+            "id": "RegressionMetrics",
+            "properties": {
+                "meanAbsoluteError": {
+                    "description": "Mean absolute error.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "meanSquaredError": {
+                    "description": "Mean squared error.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "meanSquaredLogError": {
+                    "description": "Mean squared log error.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "medianAbsoluteError": {
+                    "description": "Median absolute error.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "rSquared": {
+                    "description": "R^2 score. This corresponds to r2_score in ML.EVALUATE.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "Routine": {
+            "description": "A user-defined function or a stored procedure.",
+            "id": "Routine",
+            "properties": {
+                "arguments": {
+                    "description": "Optional.",
+                    "items": {
+                        "$ref": "Argument"
+                    },
+                    "type": "array"
+                },
+                "creationTime": {
+                    "description": "Output only. The time when this routine was created, in milliseconds since the epoch.",
+                    "format": "int64",
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "definitionBody": {
+                    "description": "Required. The body of the routine. For functions, this is the expression in the AS clause. If language=SQL, it is the substring inside (but excluding) the parentheses. For example, for the function created with the following statement: `CREATE FUNCTION JoinLines(x string, y string) as (concat(x, \"\\n\", y))` The definition_body is `concat(x, \"\\n\", y)` (\\n is not replaced with linebreak). If language=JAVASCRIPT, it is the evaluated string in the AS clause. For example, for the function created with the following statement: `CREATE FUNCTION f() RETURNS STRING LANGUAGE js AS 'return \"\\n\";\\n'` The definition_body is `return \"\\n\";\\n` Note that both \\n are replaced with linebreaks.",
+                    "type": "string"
+                },
+                "description": {
+                    "description": "Optional. [Experimental] The description of the routine if defined.",
+                    "type": "string"
+                },
+                "determinismLevel": {
+                    "description": "Optional. [Experimental] The determinism level of the JavaScript UDF if defined.",
+                    "enum": [
+                        "DETERMINISM_LEVEL_UNSPECIFIED",
+                        "DETERMINISTIC",
+                        "NOT_DETERMINISTIC"
+                    ],
+                    "enumDescriptions": [
+                        "The determinism of the UDF is unspecified.",
+                        "The UDF is deterministic, meaning that 2 function calls with the same inputs always produce the same result, even across 2 query runs.",
+                        "The UDF is not deterministic."
+                    ],
+                    "type": "string"
+                },
+                "etag": {
+                    "description": "Output only. A hash of this resource.",
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "importedLibraries": {
+                    "description": "Optional. If language = \"JAVASCRIPT\", this field stores the path of the imported JAVASCRIPT libraries.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "language": {
+                    "description": "Optional. Defaults to \"SQL\".",
+                    "enum": [
+                        "LANGUAGE_UNSPECIFIED",
+                        "SQL",
+                        "JAVASCRIPT"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "SQL language.",
+                        "JavaScript language."
+                    ],
+                    "type": "string"
+                },
+                "lastModifiedTime": {
+                    "description": "Output only. The time when this routine was last modified, in milliseconds since the epoch.",
+                    "format": "int64",
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "returnTableType": {
+                    "$ref": "StandardSqlTableType",
+                    "description": "Optional. Set only if Routine is a \"TABLE_VALUED_FUNCTION\". TODO(b/173344646) - Update return_type documentation to say it cannot be set for TABLE_VALUED_FUNCTION before preview launch."
+                },
+                "returnType": {
+                    "$ref": "StandardSqlDataType",
+                    "description": "Optional if language = \"SQL\"; required otherwise. If absent, the return type is inferred from definition_body at query time in each query that references this routine. If present, then the evaluated result will be cast to the specified returned type at query time. For example, for the functions created with the following statements: * `CREATE FUNCTION Add(x FLOAT64, y FLOAT64) RETURNS FLOAT64 AS (x + y);` * `CREATE FUNCTION Increment(x FLOAT64) AS (Add(x, 1));` * `CREATE FUNCTION Decrement(x FLOAT64) RETURNS FLOAT64 AS (Add(x, -1));` The return_type is `{type_kind: \"FLOAT64\"}` for `Add` and `Decrement`, and is absent for `Increment` (inferred as FLOAT64 at query time). Suppose the function `Add` is replaced by `CREATE OR REPLACE FUNCTION Add(x INT64, y INT64) AS (x + y);` Then the inferred return type of `Increment` is automatically changed to INT64 at query time, while the return type of `Decrement` remains FLOAT64."
+                },
+                "routineReference": {
+                    "$ref": "RoutineReference",
+                    "description": "Required. Reference describing the ID of this routine."
+                },
+                "routineType": {
+                    "description": "Required. The type of routine.",
+                    "enum": [
+                        "ROUTINE_TYPE_UNSPECIFIED",
+                        "SCALAR_FUNCTION",
+                        "PROCEDURE",
+                        "TABLE_VALUED_FUNCTION"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "Non-builtin permanent scalar function.",
+                        "Stored procedure.",
+                        "Non-builtin permanent TVF."
+                    ],
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "RoutineReference": {
+            "id": "RoutineReference",
+            "properties": {
+                "datasetId": {
+                    "description": "[Required] The ID of the dataset containing this routine.",
+                    "type": "string"
+                },
+                "projectId": {
+                    "description": "[Required] The ID of the project containing this routine.",
+                    "type": "string"
+                },
+                "routineId": {
+                    "description": "[Required] The ID of the routine. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 256 characters.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "Row": {
+            "description": "A single row in the confusion matrix.",
+            "id": "Row",
+            "properties": {
+                "actualLabel": {
+                    "description": "The original label of this row.",
+                    "type": "string"
+                },
+                "entries": {
+                    "description": "Info describing predicted label distribution.",
+                    "items": {
+                        "$ref": "Entry"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "RowAccessPolicy": {
+            "description": "Represents access on a subset of rows on the specified table, defined by its filter predicate. Access to the subset of rows is controlled by its IAM policy.",
+            "id": "RowAccessPolicy",
+            "properties": {
+                "creationTime": {
+                    "description": "Output only. The time when this row access policy was created, in milliseconds since the epoch.",
+                    "format": "google-datetime",
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "etag": {
+                    "description": "Output only. A hash of this resource.",
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "filterPredicate": {
+                    "description": "Required. A SQL boolean expression that represents the rows defined by this row access policy, similar to the boolean expression in a WHERE clause of a SELECT query on a table. References to other tables, routines, and temporary functions are not supported. Examples: region=\"EU\" date_field = CAST('2019-9-27' as DATE) nullable_field is not NULL numeric_field BETWEEN 1.0 AND 5.0",
+                    "type": "string"
+                },
+                "lastModifiedTime": {
+                    "description": "Output only. The time when this row access policy was last modified, in milliseconds since the epoch.",
+                    "format": "google-datetime",
+                    "readOnly": true,
+                    "type": "string"
+                },
+                "rowAccessPolicyReference": {
+                    "$ref": "RowAccessPolicyReference",
+                    "description": "Required. Reference describing the ID of this row access policy."
+                }
+            },
+            "type": "object"
+        },
+        "RowAccessPolicyReference": {
+            "id": "RowAccessPolicyReference",
+            "properties": {
+                "datasetId": {
+                    "description": "[Required] The ID of the dataset containing this row access policy.",
+                    "type": "string"
+                },
+                "policyId": {
+                    "description": "[Required] The ID of the row access policy. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 256 characters.",
+                    "type": "string"
+                },
+                "projectId": {
+                    "description": "[Required] The ID of the project containing this row access policy.",
+                    "type": "string"
+                },
+                "tableId": {
+                    "description": "[Required] The ID of the table containing this row access policy.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "RowLevelSecurityStatistics": {
+            "id": "RowLevelSecurityStatistics",
+            "properties": {
+                "rowLevelSecurityApplied": {
+                    "description": "[Output-only] [Preview] Whether any accessed data was protected by row access policies.",
+                    "type": "boolean"
+                }
+            },
+            "type": "object"
+        },
+        "ScriptStackFrame": {
+            "id": "ScriptStackFrame",
+            "properties": {
+                "endColumn": {
+                    "description": "[Output-only] One-based end column.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "endLine": {
+                    "description": "[Output-only] One-based end line.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "procedureId": {
+                    "description": "[Output-only] Name of the active procedure, empty if in a top-level script.",
+                    "type": "string"
+                },
+                "startColumn": {
+                    "description": "[Output-only] One-based start column.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "startLine": {
+                    "description": "[Output-only] One-based start line.",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "text": {
+                    "description": "[Output-only] Text of the current statement/expression.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "ScriptStatistics": {
+            "id": "ScriptStatistics",
+            "properties": {
+                "evaluationKind": {
+                    "description": "[Output-only] Whether this child job was a statement or expression.",
+                    "type": "string"
+                },
+                "stackFrames": {
+                    "description": "Stack trace showing the line/column/procedure name of each frame on the stack at the point where the current evaluation happened. The leaf frame is first, the primary script is last. Never empty.",
+                    "items": {
+                        "$ref": "ScriptStackFrame"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "SessionInfo": {
+            "id": "SessionInfo",
+            "properties": {
+                "sessionId": {
+                    "description": "[Output-only] // [Preview] Id of the session.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "SetIamPolicyRequest": {
+            "description": "Request message for `SetIamPolicy` method.",
+            "id": "SetIamPolicyRequest",
+            "properties": {
+                "policy": {
+                    "$ref": "Policy",
+                    "description": "REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Cloud Platform services (such as Projects) might reject them."
+                },
+                "updateMask": {
+                    "description": "OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only the fields in the mask will be modified. If no mask is provided, the following default mask is used: `paths: \"bindings, etag\"`",
+                    "format": "google-fieldmask",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "SnapshotDefinition": {
+            "id": "SnapshotDefinition",
+            "properties": {
+                "baseTableReference": {
+                    "$ref": "TableReference",
+                    "description": "[Required] Reference describing the ID of the table that is snapshotted."
+                },
+                "snapshotTime": {
+                    "description": "[Required] The time at which the base table was snapshot.",
+                    "format": "date-time",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "StandardSqlDataType": {
+            "description": "The type of a variable, e.g., a function argument. Examples: INT64: {type_kind=\"INT64\"} ARRAY: {type_kind=\"ARRAY\", array_element_type=\"STRING\"} STRUCT>: {type_kind=\"STRUCT\", struct_type={fields=[ {name=\"x\", type={type_kind=\"STRING\"}}, {name=\"y\", type={type_kind=\"ARRAY\", array_element_type=\"DATE\"}} ]}}",
+            "id": "StandardSqlDataType",
+            "properties": {
+                "arrayElementType": {
+                    "$ref": "StandardSqlDataType",
+                    "description": "The type of the array's elements, if type_kind = \"ARRAY\"."
+                },
+                "structType": {
+                    "$ref": "StandardSqlStructType",
+                    "description": "The fields of this struct, in order, if type_kind = \"STRUCT\"."
+                },
+                "typeKind": {
+                    "description": "Required. The top level type of this field. Can be any standard SQL data type (e.g., \"INT64\", \"DATE\", \"ARRAY\").",
+                    "enum": [
+                        "TYPE_KIND_UNSPECIFIED",
+                        "INT64",
+                        "BOOL",
+                        "FLOAT64",
+                        "STRING",
+                        "BYTES",
+                        "TIMESTAMP",
+                        "DATE",
+                        "TIME",
+                        "DATETIME",
+                        "INTERVAL",
+                        "GEOGRAPHY",
+                        "NUMERIC",
+                        "BIGNUMERIC",
+                        "ARRAY",
+                        "STRUCT"
+                    ],
+                    "enumDescriptions": [
+                        "Invalid type.",
+                        "Encoded as a string in decimal format.",
+                        "Encoded as a boolean \"false\" or \"true\".",
+                        "Encoded as a number, or string \"NaN\", \"Infinity\" or \"-Infinity\".",
+                        "Encoded as a string value.",
+                        "Encoded as a base64 string per RFC 4648, section 4.",
+                        "Encoded as an RFC 3339 timestamp with mandatory \"Z\" time zone string: 1985-04-12T23:20:50.52Z",
+                        "Encoded as RFC 3339 full-date format string: 1985-04-12",
+                        "Encoded as RFC 3339 partial-time format string: 23:20:50.52",
+                        "Encoded as RFC 3339 full-date \"T\" partial-time: 1985-04-12T23:20:50.52",
+                        "Encoded as fully qualified 3 part: 0-5 15 2:30:45.6",
+                        "Encoded as WKT",
+                        "Encoded as a decimal string.",
+                        "Encoded as a decimal string.",
+                        "Encoded as a list with types matching Type.array_type.",
+                        "Encoded as a list with fields of type Type.struct_type[i]. List is used because a JSON object cannot have duplicate field names."
+                    ],
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "StandardSqlField": {
+            "description": "A field or a column.",
+            "id": "StandardSqlField",
+            "properties": {
+                "name": {
+                    "description": "Optional. The name of this field. Can be absent for struct fields.",
+                    "type": "string"
+                },
+                "type": {
+                    "$ref": "StandardSqlDataType",
+                    "description": "Optional. The type of this parameter. Absent if not explicitly specified (e.g., CREATE FUNCTION statement can omit the return type; in this case the output parameter does not have this \"type\" field)."
+                }
+            },
+            "type": "object"
+        },
+        "StandardSqlStructType": {
+            "id": "StandardSqlStructType",
+            "properties": {
+                "fields": {
+                    "items": {
+                        "$ref": "StandardSqlField"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "StandardSqlTableType": {
+            "description": "A table type",
+            "id": "StandardSqlTableType",
+            "properties": {
+                "columns": {
+                    "description": "The columns in this table type",
+                    "items": {
+                        "$ref": "StandardSqlField"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "Streamingbuffer": {
+            "id": "Streamingbuffer",
+            "properties": {
+                "estimatedBytes": {
+                    "description": "[Output-only] A lower-bound estimate of the number of bytes currently in the streaming buffer.",
+                    "format": "uint64",
+                    "type": "string"
+                },
+                "estimatedRows": {
+                    "description": "[Output-only] A lower-bound estimate of the number of rows currently in the streaming buffer.",
+                    "format": "uint64",
+                    "type": "string"
+                },
+                "oldestEntryTime": {
+                    "description": "[Output-only] Contains the timestamp of the oldest entry in the streaming buffer, in milliseconds since the epoch, if the streaming buffer is available.",
+                    "format": "uint64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "Table": {
+            "id": "Table",
+            "properties": {
+                "clustering": {
+                    "$ref": "Clustering",
+                    "description": "[Beta] Clustering specification for the table. Must be specified with partitioning, data in the table will be first partitioned and subsequently clustered."
+                },
+                "creationTime": {
+                    "description": "[Output-only] The time when this table was created, in milliseconds since the epoch.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "description": {
+                    "description": "[Optional] A user-friendly description of this table.",
+                    "type": "string"
+                },
+                "encryptionConfiguration": {
+                    "$ref": "EncryptionConfiguration",
+                    "description": "Custom encryption configuration (e.g., Cloud KMS keys)."
+                },
+                "etag": {
+                    "description": "[Output-only] A hash of the table metadata. Used to ensure there were no concurrent modifications to the resource when attempting an update. Not guaranteed to change when the table contents or the fields numRows, numBytes, numLongTermBytes or lastModifiedTime change.",
+                    "type": "string"
+                },
+                "expirationTime": {
+                    "description": "[Optional] The time when this table expires, in milliseconds since the epoch. If not present, the table will persist indefinitely. Expired tables will be deleted and their storage reclaimed. The defaultTableExpirationMs property of the encapsulating dataset can be used to set a default expirationTime on newly created tables.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "externalDataConfiguration": {
+                    "$ref": "ExternalDataConfiguration",
+                    "description": "[Optional] Describes the data format, location, and other properties of a table stored outside of BigQuery. By defining these properties, the data source can then be queried as if it were a standard BigQuery table."
+                },
+                "friendlyName": {
+                    "description": "[Optional] A descriptive name for this table.",
+                    "type": "string"
+                },
+                "id": {
+                    "description": "[Output-only] An opaque ID uniquely identifying the table.",
+                    "type": "string"
+                },
+                "kind": {
+                    "default": "bigquery#table",
+                    "description": "[Output-only] The type of the resource.",
+                    "type": "string"
+                },
+                "labels": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "description": "The labels associated with this table. You can use these to organize and group your tables. Label keys and values can be no longer than 63 characters, can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. Label values are optional. Label keys must start with a letter and each label in the list must have a different key.",
+                    "type": "object"
+                },
+                "lastModifiedTime": {
+                    "description": "[Output-only] The time when this table was last modified, in milliseconds since the epoch.",
+                    "format": "uint64",
+                    "type": "string"
+                },
+                "location": {
+                    "description": "[Output-only] The geographic location where the table resides. This value is inherited from the dataset.",
+                    "type": "string"
+                },
+                "materializedView": {
+                    "$ref": "MaterializedViewDefinition",
+                    "description": "[Optional] Materialized view definition."
+                },
+                "model": {
+                    "$ref": "ModelDefinition",
+                    "description": "[Output-only, Beta] Present iff this table represents a ML model. Describes the training information for the model, and it is required to run 'PREDICT' queries."
+                },
+                "numBytes": {
+                    "description": "[Output-only] The size of this table in bytes, excluding any data in the streaming buffer.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "numLongTermBytes": {
+                    "description": "[Output-only] The number of bytes in the table that are considered \"long-term storage\".",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "numPhysicalBytes": {
+                    "description": "[Output-only] [TrustedTester] The physical size of this table in bytes, excluding any data in the streaming buffer. This includes compression and storage used for time travel.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "numRows": {
+                    "description": "[Output-only] The number of rows of data in this table, excluding any data in the streaming buffer.",
+                    "format": "uint64",
+                    "type": "string"
+                },
+                "rangePartitioning": {
+                    "$ref": "RangePartitioning",
+                    "description": "[TrustedTester] Range partitioning specification for this table. Only one of timePartitioning and rangePartitioning should be specified."
+                },
+                "requirePartitionFilter": {
+                    "default": "false",
+                    "description": "[Optional] If set to true, queries over this table require a partition filter that can be used for partition elimination to be specified.",
+                    "type": "boolean"
+                },
+                "schema": {
+                    "$ref": "TableSchema",
+                    "description": "[Optional] Describes the schema of this table."
+                },
+                "selfLink": {
+                    "description": "[Output-only] A URL that can be used to access this resource again.",
+                    "type": "string"
+                },
+                "snapshotDefinition": {
+                    "$ref": "SnapshotDefinition",
+                    "description": "[Output-only] Snapshot definition."
+                },
+                "streamingBuffer": {
+                    "$ref": "Streamingbuffer",
+                    "description": "[Output-only] Contains information regarding this table's streaming buffer, if one is present. This field will be absent if the table is not being streamed to or if there is no data in the streaming buffer."
+                },
+                "tableReference": {
+                    "$ref": "TableReference",
+                    "description": "[Required] Reference describing the ID of this table."
+                },
+                "timePartitioning": {
+                    "$ref": "TimePartitioning",
+                    "description": "Time-based partitioning specification for this table. Only one of timePartitioning and rangePartitioning should be specified."
+                },
+                "type": {
+                    "description": "[Output-only] Describes the table type. The following values are supported: TABLE: A normal BigQuery table. VIEW: A virtual table defined by a SQL query. SNAPSHOT: An immutable, read-only table that is a copy of another table. [TrustedTester] MATERIALIZED_VIEW: SQL query whose result is persisted. EXTERNAL: A table that references data stored in an external storage system, such as Google Cloud Storage. The default value is TABLE.",
+                    "type": "string"
+                },
+                "view": {
+                    "$ref": "ViewDefinition",
+                    "description": "[Optional] The view definition."
+                }
+            },
+            "type": "object"
+        },
+        "TableCell": {
+            "id": "TableCell",
+            "properties": {
+                "v": {
+                    "type": "any"
+                }
+            },
+            "type": "object"
+        },
+        "TableDataInsertAllRequest": {
+            "id": "TableDataInsertAllRequest",
+            "properties": {
+                "ignoreUnknownValues": {
+                    "description": "[Optional] Accept rows that contain values that do not match the schema. The unknown values are ignored. Default is false, which treats unknown values as errors.",
+                    "type": "boolean"
+                },
+                "kind": {
+                    "default": "bigquery#tableDataInsertAllRequest",
+                    "description": "The resource type of the response.",
+                    "type": "string"
+                },
+                "rows": {
+                    "description": "The rows to insert.",
+                    "items": {
+                        "properties": {
+                            "insertId": {
+                                "description": "[Optional] A unique ID for each row. BigQuery uses this property to detect duplicate insertion requests on a best-effort basis.",
+                                "type": "string"
+                            },
+                            "json": {
+                                "$ref": "JsonObject",
+                                "description": "[Required] A JSON object that contains a row of data. The object's properties and values must match the destination table's schema."
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                },
+                "skipInvalidRows": {
+                    "description": "[Optional] Insert all valid rows of a request, even if invalid rows exist. The default value is false, which causes the entire request to fail if any invalid rows exist.",
+                    "type": "boolean"
+                },
+                "templateSuffix": {
+                    "description": "If specified, treats the destination table as a base template, and inserts the rows into an instance table named \"{destination}{templateSuffix}\". BigQuery will manage creation of the instance table, using the schema of the base template table. See https://cloud.google.com/bigquery/streaming-data-into-bigquery#template-tables for considerations when working with templates tables.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "TableDataInsertAllResponse": {
+            "id": "TableDataInsertAllResponse",
+            "properties": {
+                "insertErrors": {
+                    "description": "An array of errors for rows that were not inserted.",
+                    "items": {
+                        "properties": {
+                            "errors": {
+                                "description": "Error information for the row indicated by the index property.",
+                                "items": {
+                                    "$ref": "ErrorProto"
+                                },
+                                "type": "array"
+                            },
+                            "index": {
+                                "description": "The index of the row that error applies to.",
+                                "format": "uint32",
+                                "type": "integer"
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                },
+                "kind": {
+                    "default": "bigquery#tableDataInsertAllResponse",
+                    "description": "The resource type of the response.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "TableDataList": {
+            "id": "TableDataList",
+            "properties": {
+                "etag": {
+                    "description": "A hash of this page of results.",
+                    "type": "string"
+                },
+                "kind": {
+                    "default": "bigquery#tableDataList",
+                    "description": "The resource type of the response.",
+                    "type": "string"
+                },
+                "pageToken": {
+                    "description": "A token used for paging results. Providing this token instead of the startIndex parameter can help you retrieve stable results when an underlying table is changing.",
+                    "type": "string"
+                },
+                "rows": {
+                    "description": "Rows of results.",
+                    "items": {
+                        "$ref": "TableRow"
+                    },
+                    "type": "array"
+                },
+                "totalRows": {
+                    "description": "The total number of rows in the complete table.",
+                    "format": "int64",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "TableFieldSchema": {
+            "id": "TableFieldSchema",
+            "properties": {
+                "categories": {
+                    "description": "[Optional] The categories attached to this field, used for field-level access control.",
+                    "properties": {
+                        "names": {
+                            "description": "A list of category resource names. For example, \"projects/1/taxonomies/2/categories/3\". At most 5 categories are allowed.",
+                            "items": {
+                                "type": "string"
+                            },
+                            "type": "array"
+                        }
+                    },
+                    "type": "object"
+                },
+                "description": {
+                    "description": "[Optional] The field description. The maximum length is 1,024 characters.",
+                    "type": "string"
+                },
+                "fields": {
+                    "description": "[Optional] Describes the nested schema fields if the type property is set to RECORD.",
+                    "items": {
+                        "$ref": "TableFieldSchema"
+                    },
+                    "type": "array"
+                },
+                "maxLength": {
+                    "description": "[Optional] Maximum length of values of this field for STRINGS or BYTES. If max_length is not specified, no maximum length constraint is imposed on this field. If type = \"STRING\", then max_length represents the maximum UTF-8 length of strings in this field. If type = \"BYTES\", then max_length represents the maximum number of bytes in this field. It is invalid to set this field if type \u2260 \"STRING\" and \u2260 \"BYTES\".",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "mode": {
+                    "description": "[Optional] The field mode. Possible values include NULLABLE, REQUIRED and REPEATED. The default value is NULLABLE.",
+                    "type": "string"
+                },
+                "name": {
+                    "description": "[Required] The field name. The name must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_), and must start with a letter or underscore. The maximum length is 128 characters.",
+                    "type": "string"
+                },
+                "policyTags": {
+                    "properties": {
+                        "names": {
+                            "description": "A list of category resource names. For example, \"projects/1/location/eu/taxonomies/2/policyTags/3\". At most 1 policy tag is allowed.",
+                            "items": {
+                                "type": "string"
+                            },
+                            "type": "array"
+                        }
+                    },
+                    "type": "object"
+                },
+                "precision": {
+                    "description": "[Optional] Precision (maximum number of total digits in base 10) and scale (maximum number of digits in the fractional part in base 10) constraints for values of this field for NUMERIC or BIGNUMERIC. It is invalid to set precision or scale if type \u2260 \"NUMERIC\" and \u2260 \"BIGNUMERIC\". If precision and scale are not specified, no value range constraint is imposed on this field insofar as values are permitted by the type. Values of this NUMERIC or BIGNUMERIC field must be in this range when: - Precision (P) and scale (S) are specified: [-10P-S + 10-S, 10P-S - 10-S] - Precision (P) is specified but not scale (and thus scale is interpreted to be equal to zero): [-10P + 1, 10P - 1]. Acceptable values for precision and scale if both are specified: - If type = \"NUMERIC\": 1 \u2264 precision - scale \u2264 29 and 0 \u2264 scale \u2264 9. - If type = \"BIGNUMERIC\": 1 \u2264 precision - scale \u2264 38 and 0 \u2264 scale \u2264 38. Acceptable values for precision if only precision is specified but not scale (and thus scale is interpreted to be equal to zero): - If type = \"NUMERIC\": 1 \u2264 precision \u2264 29. - If type = \"BIGNUMERIC\": 1 \u2264 precision \u2264 38. If scale is specified but not precision, then it is invalid.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "scale": {
+                    "description": "[Optional] See documentation for precision.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "type": {
+                    "description": "[Required] The field data type. Possible values include STRING, BYTES, INTEGER, INT64 (same as INTEGER), FLOAT, FLOAT64 (same as FLOAT), NUMERIC, BIGNUMERIC, BOOLEAN, BOOL (same as BOOLEAN), TIMESTAMP, DATE, TIME, DATETIME, RECORD (where RECORD indicates that the field contains a nested schema) or STRUCT (same as RECORD).",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "TableList": {
+            "id": "TableList",
+            "properties": {
+                "etag": {
+                    "description": "A hash of this page of results.",
+                    "type": "string"
+                },
+                "kind": {
+                    "default": "bigquery#tableList",
+                    "description": "The type of list.",
+                    "type": "string"
+                },
+                "nextPageToken": {
+                    "description": "A token to request the next page of results.",
+                    "type": "string"
+                },
+                "tables": {
+                    "description": "Tables in the requested dataset.",
+                    "items": {
+                        "properties": {
+                            "clustering": {
+                                "$ref": "Clustering",
+                                "description": "[Beta] Clustering specification for this table, if configured."
+                            },
+                            "creationTime": {
+                                "description": "The time when this table was created, in milliseconds since the epoch.",
+                                "format": "int64",
+                                "type": "string"
+                            },
+                            "expirationTime": {
+                                "description": "[Optional] The time when this table expires, in milliseconds since the epoch. If not present, the table will persist indefinitely. Expired tables will be deleted and their storage reclaimed.",
+                                "format": "int64",
+                                "type": "string"
+                            },
+                            "friendlyName": {
+                                "description": "The user-friendly name for this table.",
+                                "type": "string"
+                            },
+                            "id": {
+                                "description": "An opaque ID of the table",
+                                "type": "string"
+                            },
+                            "kind": {
+                                "default": "bigquery#table",
+                                "description": "The resource type.",
+                                "type": "string"
+                            },
+                            "labels": {
+                                "additionalProperties": {
+                                    "type": "string"
+                                },
+                                "description": "The labels associated with this table. You can use these to organize and group your tables.",
+                                "type": "object"
+                            },
+                            "rangePartitioning": {
+                                "$ref": "RangePartitioning",
+                                "description": "The range partitioning specification for this table, if configured."
+                            },
+                            "tableReference": {
+                                "$ref": "TableReference",
+                                "description": "A reference uniquely identifying the table."
+                            },
+                            "timePartitioning": {
+                                "$ref": "TimePartitioning",
+                                "description": "The time-based partitioning specification for this table, if configured."
+                            },
+                            "type": {
+                                "description": "The type of table. Possible values are: TABLE, VIEW.",
+                                "type": "string"
+                            },
+                            "view": {
+                                "description": "Additional details for a view.",
+                                "properties": {
+                                    "useLegacySql": {
+                                        "description": "True if view is defined in legacy SQL dialect, false if in standard SQL.",
+                                        "type": "boolean"
+                                    }
+                                },
+                                "type": "object"
+                            }
+                        },
+                        "type": "object"
+                    },
+                    "type": "array"
+                },
+                "totalItems": {
+                    "description": "The total number of tables in the dataset.",
+                    "format": "int32",
+                    "type": "integer"
+                }
+            },
+            "type": "object"
+        },
+        "TableReference": {
+            "id": "TableReference",
+            "properties": {
+                "datasetId": {
+                    "annotations": {
+                        "required": [
+                            "bigquery.tables.update"
+                        ]
+                    },
+                    "description": "[Required] The ID of the dataset containing this table.",
+                    "type": "string"
+                },
+                "projectId": {
+                    "annotations": {
+                        "required": [
+                            "bigquery.tables.update"
+                        ]
+                    },
+                    "description": "[Required] The ID of the project containing this table.",
+                    "type": "string"
+                },
+                "tableId": {
+                    "annotations": {
+                        "required": [
+                            "bigquery.tables.update"
+                        ]
+                    },
+                    "description": "[Required] The ID of the table. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 1,024 characters.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "TableRow": {
+            "id": "TableRow",
+            "properties": {
+                "f": {
+                    "description": "Represents a single row in the result set, consisting of one or more fields.",
+                    "items": {
+                        "$ref": "TableCell"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "TableSchema": {
+            "id": "TableSchema",
+            "properties": {
+                "fields": {
+                    "description": "Describes the fields in a table.",
+                    "items": {
+                        "$ref": "TableFieldSchema"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "TestIamPermissionsRequest": {
+            "description": "Request message for `TestIamPermissions` method.",
+            "id": "TestIamPermissionsRequest",
+            "properties": {
+                "permissions": {
+                    "description": "The set of permissions to check for the `resource`. Permissions with wildcards (such as '*' or 'storage.*') are not allowed. For more information see [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "TestIamPermissionsResponse": {
+            "description": "Response message for `TestIamPermissions` method.",
+            "id": "TestIamPermissionsResponse",
+            "properties": {
+                "permissions": {
+                    "description": "A subset of `TestPermissionsRequest.permissions` that the caller is allowed.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "TimePartitioning": {
+            "id": "TimePartitioning",
+            "properties": {
+                "expirationMs": {
+                    "description": "[Optional] Number of milliseconds for which to keep the storage for partitions in the table. The storage in a partition will have an expiration time of its partition time plus this value.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "field": {
+                    "description": "[Beta] [Optional] If not set, the table is partitioned by pseudo column, referenced via either '_PARTITIONTIME' as TIMESTAMP type, or '_PARTITIONDATE' as DATE type. If field is specified, the table is instead partitioned by this field. The field must be a top-level TIMESTAMP or DATE field. Its mode must be NULLABLE or REQUIRED.",
+                    "type": "string"
+                },
+                "requirePartitionFilter": {
+                    "type": "boolean"
+                },
+                "type": {
+                    "description": "[Required] The supported types are DAY, HOUR, MONTH, and YEAR, which will generate one partition per day, hour, month, and year, respectively. When the type is not specified, the default behavior is DAY.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "TrainingOptions": {
+            "description": "Options used in model training.",
+            "id": "TrainingOptions",
+            "properties": {
+                "autoArima": {
+                    "description": "Whether to enable auto ARIMA or not.",
+                    "type": "boolean"
+                },
+                "autoArimaMaxOrder": {
+                    "description": "The max value of non-seasonal p and q.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "batchSize": {
+                    "description": "Batch size for dnn models.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "dataFrequency": {
+                    "description": "The data frequency of a time series.",
+                    "enum": [
+                        "DATA_FREQUENCY_UNSPECIFIED",
+                        "AUTO_FREQUENCY",
+                        "YEARLY",
+                        "QUARTERLY",
+                        "MONTHLY",
+                        "WEEKLY",
+                        "DAILY",
+                        "HOURLY",
+                        "PER_MINUTE"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "Automatically inferred from timestamps.",
+                        "Yearly data.",
+                        "Quarterly data.",
+                        "Monthly data.",
+                        "Weekly data.",
+                        "Daily data.",
+                        "Hourly data.",
+                        "Per-minute data."
+                    ],
+                    "type": "string"
+                },
+                "dataSplitColumn": {
+                    "description": "The column to split data with. This column won't be used as a feature. 1. When data_split_method is CUSTOM, the corresponding column should be boolean. The rows with true value tag are eval data, and the false are training data. 2. When data_split_method is SEQ, the first DATA_SPLIT_EVAL_FRACTION rows (from smallest to largest) in the corresponding column are used as training data, and the rest are eval data. It respects the order in Orderable data types: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#data-type-properties",
+                    "type": "string"
+                },
+                "dataSplitEvalFraction": {
+                    "description": "The fraction of evaluation data over the whole input data. The rest of data will be used as training data. The format should be double. Accurate to two decimal places. Default value is 0.2.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "dataSplitMethod": {
+                    "description": "The data split type for training and evaluation, e.g. RANDOM.",
+                    "enum": [
+                        "DATA_SPLIT_METHOD_UNSPECIFIED",
+                        "RANDOM",
+                        "CUSTOM",
+                        "SEQUENTIAL",
+                        "NO_SPLIT",
+                        "AUTO_SPLIT"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "Splits data randomly.",
+                        "Splits data with the user provided tags.",
+                        "Splits data sequentially.",
+                        "Data split will be skipped.",
+                        "Splits data automatically: Uses NO_SPLIT if the data size is small. Otherwise uses RANDOM."
+                    ],
+                    "type": "string"
+                },
+                "distanceType": {
+                    "description": "Distance type for clustering models.",
+                    "enum": [
+                        "DISTANCE_TYPE_UNSPECIFIED",
+                        "EUCLIDEAN",
+                        "COSINE"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "Eculidean distance.",
+                        "Cosine distance."
+                    ],
+                    "type": "string"
+                },
+                "dropout": {
+                    "description": "Dropout probability for dnn models.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "earlyStop": {
+                    "description": "Whether to stop early when the loss doesn't improve significantly any more (compared to min_relative_progress). Used only for iterative training algorithms.",
+                    "type": "boolean"
+                },
+                "feedbackType": {
+                    "description": "Feedback type that specifies which algorithm to run for matrix factorization.",
+                    "enum": [
+                        "FEEDBACK_TYPE_UNSPECIFIED",
+                        "IMPLICIT",
+                        "EXPLICIT"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "Use weighted-als for implicit feedback problems.",
+                        "Use nonweighted-als for explicit feedback problems."
+                    ],
+                    "type": "string"
+                },
+                "hiddenUnits": {
+                    "description": "Hidden units for dnn models.",
+                    "items": {
+                        "format": "int64",
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "holidayRegion": {
+                    "description": "The geographical region based on which the holidays are considered in time series modeling. If a valid value is specified, then holiday effects modeling is enabled.",
+                    "enum": [
+                        "HOLIDAY_REGION_UNSPECIFIED",
+                        "GLOBAL",
+                        "NA",
+                        "JAPAC",
+                        "EMEA",
+                        "LAC",
+                        "AE",
+                        "AR",
+                        "AT",
+                        "AU",
+                        "BE",
+                        "BR",
+                        "CA",
+                        "CH",
+                        "CL",
+                        "CN",
+                        "CO",
+                        "CS",
+                        "CZ",
+                        "DE",
+                        "DK",
+                        "DZ",
+                        "EC",
+                        "EE",
+                        "EG",
+                        "ES",
+                        "FI",
+                        "FR",
+                        "GB",
+                        "GR",
+                        "HK",
+                        "HU",
+                        "ID",
+                        "IE",
+                        "IL",
+                        "IN",
+                        "IR",
+                        "IT",
+                        "JP",
+                        "KR",
+                        "LV",
+                        "MA",
+                        "MX",
+                        "MY",
+                        "NG",
+                        "NL",
+                        "NO",
+                        "NZ",
+                        "PE",
+                        "PH",
+                        "PK",
+                        "PL",
+                        "PT",
+                        "RO",
+                        "RS",
+                        "RU",
+                        "SA",
+                        "SE",
+                        "SG",
+                        "SI",
+                        "SK",
+                        "TH",
+                        "TR",
+                        "TW",
+                        "UA",
+                        "US",
+                        "VE",
+                        "VN",
+                        "ZA"
+                    ],
+                    "enumDescriptions": [
+                        "Holiday region unspecified.",
+                        "Global.",
+                        "North America.",
+                        "Japan and Asia Pacific: Korea, Greater China, India, Australia, and New Zealand.",
+                        "Europe, the Middle East and Africa.",
+                        "Latin America and the Caribbean.",
+                        "United Arab Emirates",
+                        "Argentina",
+                        "Austria",
+                        "Australia",
+                        "Belgium",
+                        "Brazil",
+                        "Canada",
+                        "Switzerland",
+                        "Chile",
+                        "China",
+                        "Colombia",
+                        "Czechoslovakia",
+                        "Czech Republic",
+                        "Germany",
+                        "Denmark",
+                        "Algeria",
+                        "Ecuador",
+                        "Estonia",
+                        "Egypt",
+                        "Spain",
+                        "Finland",
+                        "France",
+                        "Great Britain (United Kingdom)",
+                        "Greece",
+                        "Hong Kong",
+                        "Hungary",
+                        "Indonesia",
+                        "Ireland",
+                        "Israel",
+                        "India",
+                        "Iran",
+                        "Italy",
+                        "Japan",
+                        "Korea (South)",
+                        "Latvia",
+                        "Morocco",
+                        "Mexico",
+                        "Malaysia",
+                        "Nigeria",
+                        "Netherlands",
+                        "Norway",
+                        "New Zealand",
+                        "Peru",
+                        "Philippines",
+                        "Pakistan",
+                        "Poland",
+                        "Portugal",
+                        "Romania",
+                        "Serbia",
+                        "Russian Federation",
+                        "Saudi Arabia",
+                        "Sweden",
+                        "Singapore",
+                        "Slovenia",
+                        "Slovakia",
+                        "Thailand",
+                        "Turkey",
+                        "Taiwan",
+                        "Ukraine",
+                        "United States",
+                        "Venezuela",
+                        "Viet Nam",
+                        "South Africa"
+                    ],
+                    "type": "string"
+                },
+                "horizon": {
+                    "description": "The number of periods ahead that need to be forecasted.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "includeDrift": {
+                    "description": "Include drift when fitting an ARIMA model.",
+                    "type": "boolean"
+                },
+                "initialLearnRate": {
+                    "description": "Specifies the initial learning rate for the line search learn rate strategy.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "inputLabelColumns": {
+                    "description": "Name of input label columns in training data.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "itemColumn": {
+                    "description": "Item column specified for matrix factorization models.",
+                    "type": "string"
+                },
+                "kmeansInitializationColumn": {
+                    "description": "The column used to provide the initial centroids for kmeans algorithm when kmeans_initialization_method is CUSTOM.",
+                    "type": "string"
+                },
+                "kmeansInitializationMethod": {
+                    "description": "The method used to initialize the centroids for kmeans algorithm.",
+                    "enum": [
+                        "KMEANS_INITIALIZATION_METHOD_UNSPECIFIED",
+                        "RANDOM",
+                        "CUSTOM",
+                        "KMEANS_PLUS_PLUS"
+                    ],
+                    "enumDescriptions": [
+                        "Unspecified initialization method.",
+                        "Initializes the centroids randomly.",
+                        "Initializes the centroids using data specified in kmeans_initialization_column.",
+                        "Initializes with kmeans++."
+                    ],
+                    "type": "string"
+                },
+                "l1Regularization": {
+                    "description": "L1 regularization coefficient.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "l2Regularization": {
+                    "description": "L2 regularization coefficient.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "labelClassWeights": {
+                    "additionalProperties": {
+                        "format": "double",
+                        "type": "number"
+                    },
+                    "description": "Weights associated with each label class, for rebalancing the training data. Only applicable for classification models.",
+                    "type": "object"
+                },
+                "learnRate": {
+                    "description": "Learning rate in training. Used only for iterative training algorithms.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "learnRateStrategy": {
+                    "description": "The strategy to determine learn rate for the current iteration.",
+                    "enum": [
+                        "LEARN_RATE_STRATEGY_UNSPECIFIED",
+                        "LINE_SEARCH",
+                        "CONSTANT"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "Use line search to determine learning rate.",
+                        "Use a constant learning rate."
+                    ],
+                    "type": "string"
+                },
+                "lossType": {
+                    "description": "Type of loss function used during training run.",
+                    "enum": [
+                        "LOSS_TYPE_UNSPECIFIED",
+                        "MEAN_SQUARED_LOSS",
+                        "MEAN_LOG_LOSS"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "Mean squared loss, used for linear regression.",
+                        "Mean log loss, used for logistic regression."
+                    ],
+                    "type": "string"
+                },
+                "maxIterations": {
+                    "description": "The maximum number of iterations in training. Used only for iterative training algorithms.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "maxTreeDepth": {
+                    "description": "Maximum depth of a tree for boosted tree models.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "minRelativeProgress": {
+                    "description": "When early_stop is true, stops training when accuracy improvement is less than 'min_relative_progress'. Used only for iterative training algorithms.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "minSplitLoss": {
+                    "description": "Minimum split loss for boosted tree models.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "modelUri": {
+                    "description": "Google Cloud Storage URI from which the model was imported. Only applicable for imported models.",
+                    "type": "string"
+                },
+                "nonSeasonalOrder": {
+                    "$ref": "ArimaOrder",
+                    "description": "A specification of the non-seasonal part of the ARIMA model: the three components (p, d, q) are the AR order, the degree of differencing, and the MA order."
+                },
+                "numClusters": {
+                    "description": "Number of clusters for clustering models.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "numFactors": {
+                    "description": "Num factors specified for matrix factorization models.",
+                    "format": "int64",
+                    "type": "string"
+                },
+                "optimizationStrategy": {
+                    "description": "Optimization strategy for training linear regression models.",
+                    "enum": [
+                        "OPTIMIZATION_STRATEGY_UNSPECIFIED",
+                        "BATCH_GRADIENT_DESCENT",
+                        "NORMAL_EQUATION"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "Uses an iterative batch gradient descent algorithm.",
+                        "Uses a normal equation to solve linear regression problem."
+                    ],
+                    "type": "string"
+                },
+                "preserveInputStructs": {
+                    "description": "Whether to preserve the input structs in output feature names. Suppose there is a struct A with field b. When false (default), the output feature name is A_b. When true, the output feature name is A.b.",
+                    "type": "boolean"
+                },
+                "subsample": {
+                    "description": "Subsample fraction of the training data to grow tree to prevent overfitting for boosted tree models.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "timeSeriesDataColumn": {
+                    "description": "Column to be designated as time series data for ARIMA model.",
+                    "type": "string"
+                },
+                "timeSeriesIdColumn": {
+                    "description": "The time series id column that was used during ARIMA model training.",
+                    "type": "string"
+                },
+                "timeSeriesTimestampColumn": {
+                    "description": "Column to be designated as time series timestamp for ARIMA model.",
+                    "type": "string"
+                },
+                "userColumn": {
+                    "description": "User column specified for matrix factorization models.",
+                    "type": "string"
+                },
+                "walsAlpha": {
+                    "description": "Hyperparameter for matrix factoration when implicit feedback type is specified.",
+                    "format": "double",
+                    "type": "number"
+                },
+                "warmStart": {
+                    "description": "Whether to train a model from the last checkpoint.",
+                    "type": "boolean"
+                }
+            },
+            "type": "object"
+        },
+        "TrainingRun": {
+            "description": "Information about a single training query run for the model.",
+            "id": "TrainingRun",
+            "properties": {
+                "dataSplitResult": {
+                    "$ref": "DataSplitResult",
+                    "description": "Data split result of the training run. Only set when the input data is actually split."
+                },
+                "evaluationMetrics": {
+                    "$ref": "EvaluationMetrics",
+                    "description": "The evaluation metrics over training/eval data that were computed at the end of training."
+                },
+                "globalExplanations": {
+                    "description": "Global explanations for important features of the model. For multi-class models, there is one entry for each label class. For other models, there is only one entry in the list.",
+                    "items": {
+                        "$ref": "GlobalExplanation"
+                    },
+                    "type": "array"
+                },
+                "results": {
+                    "description": "Output of each iteration run, results.size() <= max_iterations.",
+                    "items": {
+                        "$ref": "IterationResult"
+                    },
+                    "type": "array"
+                },
+                "startTime": {
+                    "description": "The start time of this training run.",
+                    "format": "google-datetime",
+                    "type": "string"
+                },
+                "trainingOptions": {
+                    "$ref": "TrainingOptions",
+                    "description": "Options that were used for this training run, includes user specified and default options that were used."
+                }
+            },
+            "type": "object"
+        },
+        "TransactionInfo": {
+            "id": "TransactionInfo",
+            "properties": {
+                "transactionId": {
+                    "description": "[Output-only] // [Alpha] Id of the transaction.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "UserDefinedFunctionResource": {
+            "description": "This is used for defining User Defined Function (UDF) resources only when using legacy SQL. Users of Standard SQL should leverage either DDL (e.g. CREATE [TEMPORARY] FUNCTION ... ) or the Routines API to define UDF resources. For additional information on migrating, see: https://cloud.google.com/bigquery/docs/reference/standard-sql/migrating-from-legacy-sql#differences_in_user-defined_javascript_functions",
+            "id": "UserDefinedFunctionResource",
+            "properties": {
+                "inlineCode": {
+                    "description": "[Pick one] An inline resource that contains code for a user-defined function (UDF). Providing a inline code resource is equivalent to providing a URI for a file containing the same code.",
+                    "type": "string"
+                },
+                "resourceUri": {
+                    "description": "[Pick one] A code resource to load from a Google Cloud Storage URI (gs://bucket/path).",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "ViewDefinition": {
+            "id": "ViewDefinition",
+            "properties": {
+                "query": {
+                    "description": "[Required] A query that BigQuery executes when the view is referenced.",
+                    "type": "string"
+                },
+                "useLegacySql": {
+                    "description": "Specifies whether to use BigQuery's legacy SQL for this view. The default value is true. If set to false, the view will use BigQuery's standard SQL: https://cloud.google.com/bigquery/sql-reference/ Queries and views that reference this view must use the same flag value.",
+                    "type": "boolean"
+                },
+                "userDefinedFunctionResources": {
+                    "description": "Describes user-defined function resources used in the query.",
+                    "items": {
+                        "$ref": "UserDefinedFunctionResource"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        }
+    },
+    "servicePath": "bigquery/v2/",
+    "title": "BigQuery API",
+    "version": "v2"
+}
diff --git a/scripts/test_resources/current_artifacts_dir/cloudtasks.v2.json b/scripts/test_resources/current_artifacts_dir/cloudtasks.v2.json
new file mode 100644
index 0000000..9c8d039
--- /dev/null
+++ b/scripts/test_resources/current_artifacts_dir/cloudtasks.v2.json
@@ -0,0 +1,1377 @@
+{
+  "auth": {
+    "oauth2": {
+      "scopes": {
+        "https://www.googleapis.com/auth/cloud-platform": {
+          "description": "View and manage your data across Google Cloud Platform services"
+        }
+      }
+    }
+  },
+  "basePath": "",
+  "baseUrl": "https://cloudtasks.googleapis.com/",
+  "batchPath": "batch",
+  "canonicalName": "Cloud Tasks",
+  "description": "Manages the execution of large numbers of distributed requests.",
+  "discoveryVersion": "v1",
+  "documentationLink": "https://cloud.google.com/tasks/",
+  "fullyEncodeReservedExpansion": true,
+  "icons": {
+    "x16": "http://www.google.com/images/icons/product/search-16.gif",
+    "x32": "http://www.google.com/images/icons/product/search-32.gif"
+  },
+  "id": "cloudtasks:v2",
+  "kind": "discovery#restDescription",
+  "mtlsRootUrl": "https://cloudtasks.mtls.googleapis.com/",
+  "name": "cloudtasks",
+  "ownerDomain": "google.com",
+  "ownerName": "Google",
+  "parameters": {
+    "$.xgafv": {
+      "description": "V1 error format.",
+      "enum": [
+        "1",
+        "2"
+      ],
+      "enumDescriptions": [
+        "v1 error format",
+        "v2 error format"
+      ],
+      "location": "query",
+      "type": "string"
+    },
+    "access_token": {
+      "description": "OAuth access token.",
+      "location": "query",
+      "type": "string"
+    },
+    "alt": {
+      "default": "json",
+      "description": "Data format for response.",
+      "enum": [
+        "json",
+        "media",
+        "proto"
+      ],
+      "enumDescriptions": [
+        "Responses with Content-Type of application/json",
+        "Media download with context-dependent Content-Type",
+        "Responses with Content-Type of application/x-protobuf"
+      ],
+      "location": "query",
+      "type": "string"
+    },
+    "callback": {
+      "description": "JSONP",
+      "location": "query",
+      "type": "string"
+    },
+    "fields": {
+      "description": "Selector specifying which fields to include in a partial response.",
+      "location": "query",
+      "type": "string"
+    },
+    "key": {
+      "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.",
+      "location": "query",
+      "type": "string"
+    },
+    "oauth_token": {
+      "description": "OAuth 2.0 token for the current user.",
+      "location": "query",
+      "type": "string"
+    },
+    "prettyPrint": {
+      "default": "true",
+      "description": "Returns response with indentations and line breaks.",
+      "location": "query",
+      "type": "boolean"
+    },
+    "quotaUser": {
+      "description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.",
+      "location": "query",
+      "type": "string"
+    },
+    "uploadType": {
+      "description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").",
+      "location": "query",
+      "type": "string"
+    },
+    "upload_protocol": {
+      "description": "Upload protocol for media (e.g. \"raw\", \"multipart\").",
+      "location": "query",
+      "type": "string"
+    }
+  },
+  "protocol": "rest",
+  "resources": {
+    "projects": {
+      "resources": {
+        "locations": {
+          "methods": {
+            "get": {
+              "description": "Gets information about a location.",
+              "flatPath": "v2/projects/{projectsId}/locations/{locationsId}",
+              "httpMethod": "GET",
+              "id": "cloudtasks.projects.locations.get",
+              "parameterOrder": [
+                "name"
+              ],
+              "parameters": {
+                "name": {
+                  "description": "Resource name for the location.",
+                  "location": "path",
+                  "pattern": "^projects/[^/]+/locations/[^/]+$",
+                  "required": true,
+                  "type": "string"
+                }
+              },
+              "path": "v2/{+name}",
+              "response": {
+                "$ref": "Location"
+              },
+              "scopes": [
+                "https://www.googleapis.com/auth/cloud-platform"
+              ]
+            },
+            "list": {
+              "description": "Lists information about the supported locations for this service.",
+              "flatPath": "v2/projects/{projectsId}/locations",
+              "httpMethod": "GET",
+              "id": "cloudtasks.projects.locations.list",
+              "parameterOrder": [
+                "name"
+              ],
+              "parameters": {
+                "filter": {
+                  "description": "A filter to narrow down results to a preferred subset. The filtering language accepts strings like \"displayName=tokyo\", and is documented in more detail in [AIP-160](https://google.aip.dev/160).",
+                  "location": "query",
+                  "type": "string"
+                },
+                "name": {
+                  "description": "The resource that owns the locations collection, if applicable.",
+                  "location": "path",
+                  "pattern": "^projects/[^/]+$",
+                  "required": true,
+                  "type": "string"
+                },
+                "pageSize": {
+                  "description": "The maximum number of results to return. If not set, the service will select a default.",
+                  "format": "int32",
+                  "location": "query",
+                  "type": "integer"
+                },
+                "pageToken": {
+                  "description": "A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.",
+                  "location": "query",
+                  "type": "string"
+                }
+              },
+              "path": "v2/{+name}/locations",
+              "response": {
+                "$ref": "ListLocationsResponse"
+              },
+              "scopes": [
+                "https://www.googleapis.com/auth/cloud-platform"
+              ]
+            }
+          },
+          "resources": {
+            "queues": {
+              "methods": {
+                "create": {
+                  "description": "Creates a queue. Queues created with this method allow tasks to live for a maximum of 31 days. After a task is 31 days old, the task will be deleted regardless of whether it was dispatched or not. WARNING: Using this method may have unintended side effects if you are using an App Engine `queue.yaml` or `queue.xml` file to manage your queues. Read [Overview of Queue Management and queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using this method.",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues",
+                  "httpMethod": "POST",
+                  "id": "cloudtasks.projects.locations.queues.create",
+                  "parameterOrder": [
+                    "parent"
+                  ],
+                  "parameters": {
+                    "parent": {
+                      "description": "Required. The location name in which the queue will be created. For example: `projects/PROJECT_ID/locations/LOCATION_ID` The list of allowed locations can be obtained by calling Cloud Tasks' implementation of ListLocations.",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+parent}/queues",
+                  "request": {
+                    "$ref": "Queue"
+                  },
+                  "response": {
+                    "$ref": "Queue"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                },
+                "delete": {
+                  "description": "Deletes a queue. This command will delete the queue even if it has tasks in it. Note: If you delete a queue, a queue with the same name can't be created for 7 days. WARNING: Using this method may have unintended side effects if you are using an App Engine `queue.yaml` or `queue.xml` file to manage your queues. Read [Overview of Queue Management and queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using this method.",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}",
+                  "httpMethod": "DELETE",
+                  "id": "cloudtasks.projects.locations.queues.delete",
+                  "parameterOrder": [
+                    "name"
+                  ],
+                  "parameters": {
+                    "name": {
+                      "description": "Required. The queue name. For example: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+name}",
+                  "response": {
+                    "$ref": "Empty"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                },
+                "get": {
+                  "description": "Gets a queue.",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}",
+                  "httpMethod": "GET",
+                  "id": "cloudtasks.projects.locations.queues.get",
+                  "parameterOrder": [
+                    "name"
+                  ],
+                  "parameters": {
+                    "name": {
+                      "description": "Required. The resource name of the queue. For example: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+name}",
+                  "response": {
+                    "$ref": "Queue"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                },
+                "getIamPolicy": {
+                  "description": "Gets the access control policy for a Queue. Returns an empty policy if the resource exists and does not have a policy set. Authorization requires the following [Google IAM](https://cloud.google.com/iam) permission on the specified resource parent: * `cloudtasks.queues.getIamPolicy`",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}:getIamPolicy",
+                  "httpMethod": "POST",
+                  "id": "cloudtasks.projects.locations.queues.getIamPolicy",
+                  "parameterOrder": [
+                    "resource"
+                  ],
+                  "parameters": {
+                    "resource": {
+                      "description": "REQUIRED: The resource for which the policy is being requested. See the operation documentation for the appropriate value for this field.",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+resource}:getIamPolicy",
+                  "request": {
+                    "$ref": "GetIamPolicyRequest"
+                  },
+                  "response": {
+                    "$ref": "Policy"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                },
+                "list": {
+                  "description": "Lists queues. Queues are returned in lexicographical order.",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues",
+                  "httpMethod": "GET",
+                  "id": "cloudtasks.projects.locations.queues.list",
+                  "parameterOrder": [
+                    "parent"
+                  ],
+                  "parameters": {
+                    "filter": {
+                      "description": "`filter` can be used to specify a subset of queues. Any Queue field can be used as a filter and several operators as supported. For example: `<=, <, >=, >, !=, =, :`. The filter syntax is the same as described in [Stackdriver's Advanced Logs Filters](https://cloud.google.com/logging/docs/view/advanced_filters). Sample filter \"state: PAUSED\". Note that using filters might cause fewer queues than the requested page_size to be returned.",
+                      "location": "query",
+                      "type": "string"
+                    },
+                    "pageSize": {
+                      "description": "Requested page size. The maximum page size is 9800. If unspecified, the page size will be the maximum. Fewer queues than requested might be returned, even if more queues exist; use the next_page_token in the response to determine if more queues exist.",
+                      "format": "int32",
+                      "location": "query",
+                      "type": "integer"
+                    },
+                    "pageToken": {
+                      "description": "A token identifying the page of results to return. To request the first page results, page_token must be empty. To request the next page of results, page_token must be the value of next_page_token returned from the previous call to ListQueues method. It is an error to switch the value of the filter while iterating through pages.",
+                      "location": "query",
+                      "type": "string"
+                    },
+                    "parent": {
+                      "description": "Required. The location name. For example: `projects/PROJECT_ID/locations/LOCATION_ID`",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+parent}/queues",
+                  "response": {
+                    "$ref": "ListQueuesResponse"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                },
+                "patch": {
+                  "description": "Updates a queue. This method creates the queue if it does not exist and updates the queue if it does exist. Queues created with this method allow tasks to live for a maximum of 31 days. After a task is 31 days old, the task will be deleted regardless of whether it was dispatched or not. WARNING: Using this method may have unintended side effects if you are using an App Engine `queue.yaml` or `queue.xml` file to manage your queues. Read [Overview of Queue Management and queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using this method.",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}",
+                  "httpMethod": "PATCH",
+                  "id": "cloudtasks.projects.locations.queues.patch",
+                  "parameterOrder": [
+                    "name"
+                  ],
+                  "parameters": {
+                    "name": {
+                      "description": "Caller-specified and required in CreateQueue, after which it becomes output only. The queue name. The queue name must have the following format: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID` * `PROJECT_ID` can contain letters ([A-Za-z]), numbers ([0-9]), hyphens (-), colons (:), or periods (.). For more information, see [Identifying projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects) * `LOCATION_ID` is the canonical ID for the queue's location. The list of available locations can be obtained by calling ListLocations. For more information, see https://cloud.google.com/about/locations/. * `QUEUE_ID` can contain letters ([A-Za-z]), numbers ([0-9]), or hyphens (-). The maximum length is 100 characters.",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    },
+                    "updateMask": {
+                      "description": "A mask used to specify which fields of the queue are being updated. If empty, then all fields will be updated.",
+                      "format": "google-fieldmask",
+                      "location": "query",
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+name}",
+                  "request": {
+                    "$ref": "Queue"
+                  },
+                  "response": {
+                    "$ref": "Queue"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                },
+                "pause": {
+                  "description": "Pauses the queue. If a queue is paused then the system will stop dispatching tasks until the queue is resumed via ResumeQueue. Tasks can still be added when the queue is paused. A queue is paused if its state is PAUSED.",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}:pause",
+                  "httpMethod": "POST",
+                  "id": "cloudtasks.projects.locations.queues.pause",
+                  "parameterOrder": [
+                    "name"
+                  ],
+                  "parameters": {
+                    "name": {
+                      "description": "Required. The queue name. For example: `projects/PROJECT_ID/location/LOCATION_ID/queues/QUEUE_ID`",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+name}:pause",
+                  "request": {
+                    "$ref": "PauseQueueRequest"
+                  },
+                  "response": {
+                    "$ref": "Queue"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                },
+                "purge": {
+                  "description": "Purges a queue by deleting all of its tasks. All tasks created before this method is called are permanently deleted. Purge operations can take up to one minute to take effect. Tasks might be dispatched before the purge takes effect. A purge is irreversible.",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}:purge",
+                  "httpMethod": "POST",
+                  "id": "cloudtasks.projects.locations.queues.purge",
+                  "parameterOrder": [
+                    "name"
+                  ],
+                  "parameters": {
+                    "name": {
+                      "description": "Required. The queue name. For example: `projects/PROJECT_ID/location/LOCATION_ID/queues/QUEUE_ID`",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+name}:purge",
+                  "request": {
+                    "$ref": "PurgeQueueRequest"
+                  },
+                  "response": {
+                    "$ref": "Queue"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                },
+                "resume": {
+                  "description": "Resume a queue. This method resumes a queue after it has been PAUSED or DISABLED. The state of a queue is stored in the queue's state; after calling this method it will be set to RUNNING. WARNING: Resuming many high-QPS queues at the same time can lead to target overloading. If you are resuming high-QPS queues, follow the 500/50/5 pattern described in [Managing Cloud Tasks Scaling Risks](https://cloud.google.com/tasks/docs/manage-cloud-task-scaling).",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}:resume",
+                  "httpMethod": "POST",
+                  "id": "cloudtasks.projects.locations.queues.resume",
+                  "parameterOrder": [
+                    "name"
+                  ],
+                  "parameters": {
+                    "name": {
+                      "description": "Required. The queue name. For example: `projects/PROJECT_ID/location/LOCATION_ID/queues/QUEUE_ID`",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+name}:resume",
+                  "request": {
+                    "$ref": "ResumeQueueRequest"
+                  },
+                  "response": {
+                    "$ref": "Queue"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                },
+                "setIamPolicy": {
+                  "description": "Sets the access control policy for a Queue. Replaces any existing policy. Note: The Cloud Console does not check queue-level IAM permissions yet. Project-level permissions are required to use the Cloud Console. Authorization requires the following [Google IAM](https://cloud.google.com/iam) permission on the specified resource parent: * `cloudtasks.queues.setIamPolicy`",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}:setIamPolicy",
+                  "httpMethod": "POST",
+                  "id": "cloudtasks.projects.locations.queues.setIamPolicy",
+                  "parameterOrder": [
+                    "resource"
+                  ],
+                  "parameters": {
+                    "resource": {
+                      "description": "REQUIRED: The resource for which the policy is being specified. See the operation documentation for the appropriate value for this field.",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+resource}:setIamPolicy",
+                  "request": {
+                    "$ref": "SetIamPolicyRequest"
+                  },
+                  "response": {
+                    "$ref": "Policy"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                },
+                "testIamPermissions": {
+                  "description": "Returns permissions that a caller has on a Queue. If the resource does not exist, this will return an empty set of permissions, not a NOT_FOUND error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.",
+                  "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}:testIamPermissions",
+                  "httpMethod": "POST",
+                  "id": "cloudtasks.projects.locations.queues.testIamPermissions",
+                  "parameterOrder": [
+                    "resource"
+                  ],
+                  "parameters": {
+                    "resource": {
+                      "description": "REQUIRED: The resource for which the policy detail is being requested. See the operation documentation for the appropriate value for this field.",
+                      "location": "path",
+                      "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                      "required": true,
+                      "type": "string"
+                    }
+                  },
+                  "path": "v2/{+resource}:testIamPermissions",
+                  "request": {
+                    "$ref": "TestIamPermissionsRequest"
+                  },
+                  "response": {
+                    "$ref": "TestIamPermissionsResponse"
+                  },
+                  "scopes": [
+                    "https://www.googleapis.com/auth/cloud-platform"
+                  ]
+                }
+              },
+              "resources": {
+                "tasks": {
+                  "methods": {
+                    "create": {
+                      "description": "Creates a task and adds it to a queue. Tasks cannot be updated after creation; there is no UpdateTask command. * The maximum task size is 100KB.",
+                      "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}/tasks",
+                      "httpMethod": "POST",
+                      "id": "cloudtasks.projects.locations.queues.tasks.create",
+                      "parameterOrder": [
+                        "parent"
+                      ],
+                      "parameters": {
+                        "parent": {
+                          "description": "Required. The queue name. For example: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID` The queue must already exist.",
+                          "location": "path",
+                          "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                          "required": true,
+                          "type": "string"
+                        }
+                      },
+                      "path": "v2/{+parent}/tasks",
+                      "request": {
+                        "$ref": "CreateTaskRequest"
+                      },
+                      "response": {
+                        "$ref": "Task"
+                      },
+                      "scopes": [
+                        "https://www.googleapis.com/auth/cloud-platform"
+                      ]
+                    },
+                    "delete": {
+                      "description": "Deletes a task. A task can be deleted if it is scheduled or dispatched. A task cannot be deleted if it has executed successfully or permanently failed.",
+                      "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}/tasks/{tasksId}",
+                      "httpMethod": "DELETE",
+                      "id": "cloudtasks.projects.locations.queues.tasks.delete",
+                      "parameterOrder": [
+                        "name"
+                      ],
+                      "parameters": {
+                        "name": {
+                          "description": "Required. The task name. For example: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`",
+                          "location": "path",
+                          "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+/tasks/[^/]+$",
+                          "required": true,
+                          "type": "string"
+                        }
+                      },
+                      "path": "v2/{+name}",
+                      "response": {
+                        "$ref": "Empty"
+                      },
+                      "scopes": [
+                        "https://www.googleapis.com/auth/cloud-platform"
+                      ]
+                    },
+                    "get": {
+                      "description": "Gets a task.",
+                      "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}/tasks/{tasksId}",
+                      "httpMethod": "GET",
+                      "id": "cloudtasks.projects.locations.queues.tasks.get",
+                      "parameterOrder": [
+                        "name"
+                      ],
+                      "parameters": {
+                        "name": {
+                          "description": "Required. The task name. For example: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`",
+                          "location": "path",
+                          "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+/tasks/[^/]+$",
+                          "required": true,
+                          "type": "string"
+                        },
+                        "responseView": {
+                          "description": "The response_view specifies which subset of the Task will be returned. By default response_view is BASIC; not all information is retrieved by default because some data, such as payloads, might be desirable to return only when needed because of its large size or because of the sensitivity of data that it contains. Authorization for FULL requires `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/) permission on the Task resource.",
+                          "enum": [
+                            "VIEW_UNSPECIFIED",
+                            "BASIC",
+                            "FULL"
+                          ],
+                          "enumDescriptions": [
+                            "Unspecified. Defaults to BASIC.",
+                            "The basic view omits fields which can be large or can contain sensitive data. This view does not include the body in AppEngineHttpRequest. Bodies are desirable to return only when needed, because they can be large and because of the sensitivity of the data that you choose to store in it.",
+                            "All information is returned. Authorization for FULL requires `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/) permission on the Queue resource."
+                          ],
+                          "location": "query",
+                          "type": "string"
+                        }
+                      },
+                      "path": "v2/{+name}",
+                      "response": {
+                        "$ref": "Task"
+                      },
+                      "scopes": [
+                        "https://www.googleapis.com/auth/cloud-platform"
+                      ]
+                    },
+                    "list": {
+                      "description": "Lists the tasks in a queue. By default, only the BASIC view is retrieved due to performance considerations; response_view controls the subset of information which is returned. The tasks may be returned in any order. The ordering may change at any time.",
+                      "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}/tasks",
+                      "httpMethod": "GET",
+                      "id": "cloudtasks.projects.locations.queues.tasks.list",
+                      "parameterOrder": [
+                        "parent"
+                      ],
+                      "parameters": {
+                        "pageSize": {
+                          "description": "Maximum page size. Fewer tasks than requested might be returned, even if more tasks exist; use next_page_token in the response to determine if more tasks exist. The maximum page size is 1000. If unspecified, the page size will be the maximum.",
+                          "format": "int32",
+                          "location": "query",
+                          "type": "integer"
+                        },
+                        "pageToken": {
+                          "description": "A token identifying the page of results to return. To request the first page results, page_token must be empty. To request the next page of results, page_token must be the value of next_page_token returned from the previous call to ListTasks method. The page token is valid for only 2 hours.",
+                          "location": "query",
+                          "type": "string"
+                        },
+                        "parent": {
+                          "description": "Required. The queue name. For example: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`",
+                          "location": "path",
+                          "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+$",
+                          "required": true,
+                          "type": "string"
+                        },
+                        "responseView": {
+                          "description": "The response_view specifies which subset of the Task will be returned. By default response_view is BASIC; not all information is retrieved by default because some data, such as payloads, might be desirable to return only when needed because of its large size or because of the sensitivity of data that it contains. Authorization for FULL requires `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/) permission on the Task resource.",
+                          "enum": [
+                            "VIEW_UNSPECIFIED",
+                            "BASIC",
+                            "FULL"
+                          ],
+                          "enumDescriptions": [
+                            "Unspecified. Defaults to BASIC.",
+                            "The basic view omits fields which can be large or can contain sensitive data. This view does not include the body in AppEngineHttpRequest. Bodies are desirable to return only when needed, because they can be large and because of the sensitivity of the data that you choose to store in it.",
+                            "All information is returned. Authorization for FULL requires `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/) permission on the Queue resource."
+                          ],
+                          "location": "query",
+                          "type": "string"
+                        }
+                      },
+                      "path": "v2/{+parent}/tasks",
+                      "response": {
+                        "$ref": "ListTasksResponse"
+                      },
+                      "scopes": [
+                        "https://www.googleapis.com/auth/cloud-platform"
+                      ]
+                    },
+                    "run": {
+                      "description": "Forces a task to run now. When this method is called, Cloud Tasks will dispatch the task, even if the task is already running, the queue has reached its RateLimits or is PAUSED. This command is meant to be used for manual debugging. For example, RunTask can be used to retry a failed task after a fix has been made or to manually force a task to be dispatched now. The dispatched task is returned. That is, the task that is returned contains the status after the task is dispatched but before the task is received by its target. If Cloud Tasks receives a successful response from the task's target, then the task will be deleted; otherwise the task's schedule_time will be reset to the time that RunTask was called plus the retry delay specified in the queue's RetryConfig. RunTask returns NOT_FOUND when it is called on a task that has already succeeded or permanently failed.",
+                      "flatPath": "v2/projects/{projectsId}/locations/{locationsId}/queues/{queuesId}/tasks/{tasksId}:run",
+                      "httpMethod": "POST",
+                      "id": "cloudtasks.projects.locations.queues.tasks.run",
+                      "parameterOrder": [
+                        "name"
+                      ],
+                      "parameters": {
+                        "name": {
+                          "description": "Required. The task name. For example: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`",
+                          "location": "path",
+                          "pattern": "^projects/[^/]+/locations/[^/]+/queues/[^/]+/tasks/[^/]+$",
+                          "required": true,
+                          "type": "string"
+                        }
+                      },
+                      "path": "v2/{+name}:run",
+                      "request": {
+                        "$ref": "RunTaskRequest"
+                      },
+                      "response": {
+                        "$ref": "Task"
+                      },
+                      "scopes": [
+                        "https://www.googleapis.com/auth/cloud-platform"
+                      ]
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "revision": "20210315",
+  "rootUrl": "https://cloudtasks.googleapis.com/",
+  "schemas": {
+    "AppEngineHttpRequest": {
+      "description": "App Engine HTTP request. The message defines the HTTP request that is sent to an App Engine app when the task is dispatched. Using AppEngineHttpRequest requires [`appengine.applications.get`](https://cloud.google.com/appengine/docs/admin-api/access-control) Google IAM permission for the project and the following scope: `https://www.googleapis.com/auth/cloud-platform` The task will be delivered to the App Engine app which belongs to the same project as the queue. For more information, see [How Requests are Routed](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed) and how routing is affected by [dispatch files](https://cloud.google.com/appengine/docs/python/config/dispatchref). Traffic is encrypted during transport and never leaves Google datacenters. Because this traffic is carried over a communication mechanism internal to Google, you cannot explicitly set the protocol (for example, HTTP or HTTPS). The request to the handler, however, will appear to have used the HTTP protocol. The AppEngineRouting used to construct the URL that the task is delivered to can be set at the queue-level or task-level: * If app_engine_routing_override is set on the queue, this value is used for all tasks in the queue, no matter what the setting is for the task-level app_engine_routing. The `url` that the task will be sent to is: * `url =` host `+` relative_uri Tasks can be dispatched to secure app handlers, unsecure app handlers, and URIs restricted with [`login: admin`](https://cloud.google.com/appengine/docs/standard/python/config/appref). Because tasks are not run as any user, they cannot be dispatched to URIs restricted with [`login: required`](https://cloud.google.com/appengine/docs/standard/python/config/appref) Task dispatches also do not follow redirects. The task attempt has succeeded if the app's request handler returns an HTTP response code in the range [`200` - `299`]. The task attempt has failed if the app's handler returns a non-2xx response code or Cloud Tasks does not receive response before the deadline. Failed tasks will be retried according to the retry configuration. `503` (Service Unavailable) is considered an App Engine system error instead of an application error and will cause Cloud Tasks' traffic congestion control to temporarily throttle the queue's dispatches. Unlike other types of task targets, a `429` (Too Many Requests) response from an app handler does not cause traffic congestion control to throttle the queue.",
+      "id": "AppEngineHttpRequest",
+      "properties": {
+        "appEngineRouting": {
+          "$ref": "AppEngineRouting",
+          "description": "Task-level setting for App Engine routing. * If app_engine_routing_override is set on the queue, this value is used for all tasks in the queue, no matter what the setting is for the task-level app_engine_routing."
+        },
+        "body": {
+          "description": "HTTP request body. A request body is allowed only if the HTTP method is POST or PUT. It is an error to set a body on a task with an incompatible HttpMethod.",
+          "format": "byte",
+          "type": "string"
+        },
+        "headers": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "HTTP request headers. This map contains the header field names and values. Headers can be set when the task is created. Repeated headers are not supported but a header value can contain commas. Cloud Tasks sets some headers to default values: * `User-Agent`: By default, this header is `\"AppEngine-Google; (+http://code.google.com/appengine)\"`. This header can be modified, but Cloud Tasks will append `\"AppEngine-Google; (+http://code.google.com/appengine)\"` to the modified `User-Agent`. If the task has a body, Cloud Tasks sets the following headers: * `Content-Type`: By default, the `Content-Type` header is set to `\"application/octet-stream\"`. The default can be overridden by explicitly setting `Content-Type` to a particular media type when the task is created. For example, `Content-Type` can be set to `\"application/json\"`. * `Content-Length`: This is computed by Cloud Tasks. This value is output only. It cannot be changed. The headers below cannot be set or overridden: * `Host` * `X-Google-*` * `X-AppEngine-*` In addition, Cloud Tasks sets some headers when the task is dispatched, such as headers containing information about the task; see [request headers](https://cloud.google.com/tasks/docs/creating-appengine-handlers#reading_request_headers). These headers are set only when the task is dispatched, so they are not visible when the task is returned in a Cloud Tasks response. Although there is no specific limit for the maximum number of headers or the size, there is a limit on the maximum size of the Task. For more information, see the CreateTask documentation.",
+          "type": "object"
+        },
+        "httpMethod": {
+          "description": "The HTTP method to use for the request. The default is POST. The app's request handler for the task's target URL must be able to handle HTTP requests with this http_method, otherwise the task attempt fails with error code 405 (Method Not Allowed). See [Writing a push task request handler](https://cloud.google.com/appengine/docs/java/taskqueue/push/creating-handlers#writing_a_push_task_request_handler) and the App Engine documentation for your runtime on [How Requests are Handled](https://cloud.google.com/appengine/docs/standard/python3/how-requests-are-handled).",
+          "enum": [
+            "HTTP_METHOD_UNSPECIFIED",
+            "POST",
+            "GET",
+            "HEAD",
+            "PUT",
+            "DELETE",
+            "PATCH",
+            "OPTIONS"
+          ],
+          "enumDescriptions": [
+            "HTTP method unspecified",
+            "HTTP POST",
+            "HTTP GET",
+            "HTTP HEAD",
+            "HTTP PUT",
+            "HTTP DELETE",
+            "HTTP PATCH",
+            "HTTP OPTIONS"
+          ],
+          "type": "string"
+        },
+        "relativeUri": {
+          "description": "The relative URI. The relative URI must begin with \"/\" and must be a valid HTTP relative URI. It can contain a path and query string arguments. If the relative URI is empty, then the root path \"/\" will be used. No spaces are allowed, and the maximum length allowed is 2083 characters.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "AppEngineRouting": {
+      "description": "App Engine Routing. Defines routing characteristics specific to App Engine - service, version, and instance. For more information about services, versions, and instances see [An Overview of App Engine](https://cloud.google.com/appengine/docs/python/an-overview-of-app-engine), [Microservices Architecture on Google App Engine](https://cloud.google.com/appengine/docs/python/microservices-on-app-engine), [App Engine Standard request routing](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed), and [App Engine Flex request routing](https://cloud.google.com/appengine/docs/flexible/python/how-requests-are-routed). Using AppEngineRouting requires [`appengine.applications.get`](https://cloud.google.com/appengine/docs/admin-api/access-control) Google IAM permission for the project and the following scope: `https://www.googleapis.com/auth/cloud-platform`",
+      "id": "AppEngineRouting",
+      "properties": {
+        "host": {
+          "description": "Output only. The host that the task is sent to. The host is constructed from the domain name of the app associated with the queue's project ID (for example .appspot.com), and the service, version, and instance. Tasks which were created using the App Engine SDK might have a custom domain name. For more information, see [How Requests are Routed](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed).",
+          "type": "string"
+        },
+        "instance": {
+          "description": "App instance. By default, the task is sent to an instance which is available when the task is attempted. Requests can only be sent to a specific instance if [manual scaling is used in App Engine Standard](https://cloud.google.com/appengine/docs/python/an-overview-of-app-engine?hl=en_US#scaling_types_and_instance_classes). App Engine Flex does not support instances. For more information, see [App Engine Standard request routing](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed) and [App Engine Flex request routing](https://cloud.google.com/appengine/docs/flexible/python/how-requests-are-routed).",
+          "type": "string"
+        },
+        "service": {
+          "description": "App service. By default, the task is sent to the service which is the default service when the task is attempted. For some queues or tasks which were created using the App Engine Task Queue API, host is not parsable into service, version, and instance. For example, some tasks which were created using the App Engine SDK use a custom domain name; custom domains are not parsed by Cloud Tasks. If host is not parsable, then service, version, and instance are the empty string.",
+          "type": "string"
+        },
+        "version": {
+          "description": "App version. By default, the task is sent to the version which is the default version when the task is attempted. For some queues or tasks which were created using the App Engine Task Queue API, host is not parsable into service, version, and instance. For example, some tasks which were created using the App Engine SDK use a custom domain name; custom domains are not parsed by Cloud Tasks. If host is not parsable, then service, version, and instance are the empty string.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Attempt": {
+      "description": "The status of a task attempt.",
+      "id": "Attempt",
+      "properties": {
+        "dispatchTime": {
+          "description": "Output only. The time that this attempt was dispatched. `dispatch_time` will be truncated to the nearest microsecond.",
+          "format": "google-datetime",
+          "type": "string"
+        },
+        "responseStatus": {
+          "$ref": "Status",
+          "description": "Output only. The response from the worker for this attempt. If `response_time` is unset, then the task has not been attempted or is currently running and the `response_status` field is meaningless."
+        },
+        "responseTime": {
+          "description": "Output only. The time that this attempt response was received. `response_time` will be truncated to the nearest microsecond.",
+          "format": "google-datetime",
+          "type": "string"
+        },
+        "scheduleTime": {
+          "description": "Output only. The time that this attempt was scheduled. `schedule_time` will be truncated to the nearest microsecond.",
+          "format": "google-datetime",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Binding": {
+      "description": "Associates `members` with a `role`.",
+      "id": "Binding",
+      "properties": {
+        "condition": {
+          "$ref": "Expr",
+          "description": "The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the members in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies)."
+        },
+        "members": {
+          "description": "Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. ",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "role": {
+          "description": "Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "CreateTaskRequest": {
+      "description": "Request message for CreateTask.",
+      "id": "CreateTaskRequest",
+      "properties": {
+        "responseView": {
+          "description": "The response_view specifies which subset of the Task will be returned. By default response_view is BASIC; not all information is retrieved by default because some data, such as payloads, might be desirable to return only when needed because of its large size or because of the sensitivity of data that it contains. Authorization for FULL requires `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/) permission on the Task resource.",
+          "enum": [
+            "VIEW_UNSPECIFIED",
+            "BASIC",
+            "FULL"
+          ],
+          "enumDescriptions": [
+            "Unspecified. Defaults to BASIC.",
+            "The basic view omits fields which can be large or can contain sensitive data. This view does not include the body in AppEngineHttpRequest. Bodies are desirable to return only when needed, because they can be large and because of the sensitivity of the data that you choose to store in it.",
+            "All information is returned. Authorization for FULL requires `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/) permission on the Queue resource."
+          ],
+          "type": "string"
+        },
+        "task": {
+          "$ref": "Task",
+          "description": "Required. The task to add. Task names have the following format: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`. The user can optionally specify a task name. If a name is not specified then the system will generate a random unique task id, which will be set in the task returned in the response. If schedule_time is not set or is in the past then Cloud Tasks will set it to the current time. Task De-duplication: Explicitly specifying a task ID enables task de-duplication. If a task's ID is identical to that of an existing task or a task that was deleted or executed recently then the call will fail with ALREADY_EXISTS. If the task's queue was created using Cloud Tasks, then another task with the same name can't be created for ~1hour after the original task was deleted or executed. If the task's queue was created using queue.yaml or queue.xml, then another task with the same name can't be created for ~9days after the original task was deleted or executed. Because there is an extra lookup cost to identify duplicate task names, these CreateTask calls have significantly increased latency. Using hashed strings for the task id or for the prefix of the task id is recommended. Choosing task ids that are sequential or have sequential prefixes, for example using a timestamp, causes an increase in latency and error rates in all task commands. The infrastructure relies on an approximately uniform distribution of task ids to store and serve tasks efficiently."
+        }
+      },
+      "type": "object"
+    },
+    "Empty": {
+      "description": "A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`.",
+      "id": "Empty",
+      "properties": {},
+      "type": "object"
+    },
+    "Expr": {
+      "description": "Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: \"Summary size limit\" description: \"Determines if a summary is less than 100 chars\" expression: \"document.summary.size() < 100\" Example (Equality): title: \"Requestor is owner\" description: \"Determines if requestor is the document owner\" expression: \"document.owner == request.auth.claims.email\" Example (Logic): title: \"Public documents\" description: \"Determine whether the document should be publicly visible\" expression: \"document.type != 'private' && document.type != 'internal'\" Example (Data Manipulation): title: \"Notification string\" description: \"Create a notification string with a timestamp.\" expression: \"'New message received at ' + string(document.create_time)\" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.",
+      "id": "Expr",
+      "properties": {
+        "description": {
+          "description": "Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.",
+          "type": "string"
+        },
+        "expression": {
+          "description": "Textual representation of an expression in Common Expression Language syntax.",
+          "type": "string"
+        },
+        "location": {
+          "description": "Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.",
+          "type": "string"
+        },
+        "title": {
+          "description": "Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "GetIamPolicyRequest": {
+      "description": "Request message for `GetIamPolicy` method.",
+      "id": "GetIamPolicyRequest",
+      "properties": {
+        "options": {
+          "$ref": "GetPolicyOptions",
+          "description": "OPTIONAL: A `GetPolicyOptions` object for specifying options to `GetIamPolicy`."
+        }
+      },
+      "type": "object"
+    },
+    "GetPolicyOptions": {
+      "description": "Encapsulates settings provided to GetIamPolicy.",
+      "id": "GetPolicyOptions",
+      "properties": {
+        "requestedPolicyVersion": {
+          "description": "Optional. The policy format version to be returned. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional bindings must specify version 3. Policies without any conditional bindings may specify any valid value or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).",
+          "format": "int32",
+          "type": "integer"
+        }
+      },
+      "type": "object"
+    },
+    "HttpRequest": {
+      "description": "HTTP request. The task will be pushed to the worker as an HTTP request. If the worker or the redirected worker acknowledges the task by returning a successful HTTP response code ([`200` - `299`]), the task will be removed from the queue. If any other HTTP response code is returned or no response is received, the task will be retried according to the following: * User-specified throttling: retry configuration, rate limits, and the queue's state. * System throttling: To prevent the worker from overloading, Cloud Tasks may temporarily reduce the queue's effective rate. User-specified settings will not be changed. System throttling happens because: * Cloud Tasks backs off on all errors. Normally the backoff specified in rate limits will be used. But if the worker returns `429` (Too Many Requests), `503` (Service Unavailable), or the rate of errors is high, Cloud Tasks will use a higher backoff rate. The retry specified in the `Retry-After` HTTP response header is considered. * To prevent traffic spikes and to smooth sudden increases in traffic, dispatches ramp up slowly when the queue is newly created or idle and if large numbers of tasks suddenly become available to dispatch (due to spikes in create task rates, the queue being unpaused, or many tasks that are scheduled at the same time).",
+      "id": "HttpRequest",
+      "properties": {
+        "body": {
+          "description": "HTTP request body. A request body is allowed only if the HTTP method is POST, PUT, or PATCH. It is an error to set body on a task with an incompatible HttpMethod.",
+          "format": "byte",
+          "type": "string"
+        },
+        "headers": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "HTTP request headers. This map contains the header field names and values. Headers can be set when the task is created. These headers represent a subset of the headers that will accompany the task's HTTP request. Some HTTP request headers will be ignored or replaced. A partial list of headers that will be ignored or replaced is: * Host: This will be computed by Cloud Tasks and derived from HttpRequest.url. * Content-Length: This will be computed by Cloud Tasks. * User-Agent: This will be set to `\"Google-Cloud-Tasks\"`. * X-Google-*: Google use only. * X-AppEngine-*: Google use only. `Content-Type` won't be set by Cloud Tasks. You can explicitly set `Content-Type` to a media type when the task is created. For example, `Content-Type` can be set to `\"application/octet-stream\"` or `\"application/json\"`. Headers which can have multiple values (according to RFC2616) can be specified using comma-separated values. The size of the headers must be less than 80KB.",
+          "type": "object"
+        },
+        "httpMethod": {
+          "description": "The HTTP method to use for the request. The default is POST.",
+          "enum": [
+            "HTTP_METHOD_UNSPECIFIED",
+            "POST",
+            "GET",
+            "HEAD",
+            "PUT",
+            "DELETE",
+            "PATCH",
+            "OPTIONS"
+          ],
+          "enumDescriptions": [
+            "HTTP method unspecified",
+            "HTTP POST",
+            "HTTP GET",
+            "HTTP HEAD",
+            "HTTP PUT",
+            "HTTP DELETE",
+            "HTTP PATCH",
+            "HTTP OPTIONS"
+          ],
+          "type": "string"
+        },
+        "oauthToken": {
+          "$ref": "OAuthToken",
+          "description": "If specified, an [OAuth token](https://developers.google.com/identity/protocols/OAuth2) will be generated and attached as an `Authorization` header in the HTTP request. This type of authorization should generally only be used when calling Google APIs hosted on *.googleapis.com."
+        },
+        "oidcToken": {
+          "$ref": "OidcToken",
+          "description": "If specified, an [OIDC](https://developers.google.com/identity/protocols/OpenIDConnect) token will be generated and attached as an `Authorization` header in the HTTP request. This type of authorization can be used for many scenarios, including calling Cloud Run, or endpoints where you intend to validate the token yourself."
+        },
+        "url": {
+          "description": "Required. The full url path that the request will be sent to. This string must begin with either \"http://\" or \"https://\". Some examples are: `http://acme.com` and `https://acme.com/sales:8080`. Cloud Tasks will encode some characters for safety and compatibility. The maximum allowed URL length is 2083 characters after encoding. The `Location` header response from a redirect response [`300` - `399`] may be followed. The redirect is not counted as a separate attempt.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ListLocationsResponse": {
+      "description": "The response message for Locations.ListLocations.",
+      "id": "ListLocationsResponse",
+      "properties": {
+        "locations": {
+          "description": "A list of locations that matches the specified filter in the request.",
+          "items": {
+            "$ref": "Location"
+          },
+          "type": "array"
+        },
+        "nextPageToken": {
+          "description": "The standard List next-page token.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ListQueuesResponse": {
+      "description": "Response message for ListQueues.",
+      "id": "ListQueuesResponse",
+      "properties": {
+        "nextPageToken": {
+          "description": "A token to retrieve next page of results. To return the next page of results, call ListQueues with this value as the page_token. If the next_page_token is empty, there are no more results. The page token is valid for only 2 hours.",
+          "type": "string"
+        },
+        "queues": {
+          "description": "The list of queues.",
+          "items": {
+            "$ref": "Queue"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ListTasksResponse": {
+      "description": "Response message for listing tasks using ListTasks.",
+      "id": "ListTasksResponse",
+      "properties": {
+        "nextPageToken": {
+          "description": "A token to retrieve next page of results. To return the next page of results, call ListTasks with this value as the page_token. If the next_page_token is empty, there are no more results.",
+          "type": "string"
+        },
+        "tasks": {
+          "description": "The list of tasks.",
+          "items": {
+            "$ref": "Task"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "Location": {
+      "description": "A resource that represents Google Cloud Platform location.",
+      "id": "Location",
+      "properties": {
+        "displayName": {
+          "description": "The friendly name for this location, typically a nearby city name. For example, \"Tokyo\".",
+          "type": "string"
+        },
+        "labels": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "Cross-service attributes for the location. For example {\"cloud.googleapis.com/region\": \"us-east1\"}",
+          "type": "object"
+        },
+        "locationId": {
+          "description": "The canonical id for this location. For example: `\"us-east1\"`.",
+          "type": "string"
+        },
+        "metadata": {
+          "additionalProperties": {
+            "description": "Properties of the object. Contains field @type with type URL.",
+            "type": "any"
+          },
+          "description": "Service-specific metadata. For example the available capacity at the given location.",
+          "type": "object"
+        },
+        "name": {
+          "description": "Resource name for the location, which may vary between implementations. For example: `\"projects/example-project/locations/us-east1\"`",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "OAuthToken": {
+      "description": "Contains information needed for generating an [OAuth token](https://developers.google.com/identity/protocols/OAuth2). This type of authorization should generally only be used when calling Google APIs hosted on *.googleapis.com.",
+      "id": "OAuthToken",
+      "properties": {
+        "scope": {
+          "description": "OAuth scope to be used for generating OAuth access token. If not specified, \"https://www.googleapis.com/auth/cloud-platform\" will be used.",
+          "type": "string"
+        },
+        "serviceAccountEmail": {
+          "description": "[Service account email](https://cloud.google.com/iam/docs/service-accounts) to be used for generating OAuth token. The service account must be within the same project as the queue. The caller must have iam.serviceAccounts.actAs permission for the service account.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "OidcToken": {
+      "description": "Contains information needed for generating an [OpenID Connect token](https://developers.google.com/identity/protocols/OpenIDConnect). This type of authorization can be used for many scenarios, including calling Cloud Run, or endpoints where you intend to validate the token yourself.",
+      "id": "OidcToken",
+      "properties": {
+        "audience": {
+          "description": "Audience to be used when generating OIDC token. If not specified, the URI specified in target will be used.",
+          "type": "string"
+        },
+        "serviceAccountEmail": {
+          "description": "[Service account email](https://cloud.google.com/iam/docs/service-accounts) to be used for generating OIDC token. The service account must be within the same project as the queue. The caller must have iam.serviceAccounts.actAs permission for the service account.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "PauseQueueRequest": {
+      "description": "Request message for PauseQueue.",
+      "id": "PauseQueueRequest",
+      "properties": {},
+      "type": "object"
+    },
+    "Policy": {
+      "description": "An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members` to a single `role`. Members can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** { \"bindings\": [ { \"role\": \"roles/resourcemanager.organizationAdmin\", \"members\": [ \"user:mike@example.com\", \"group:admins@example.com\", \"domain:google.com\", \"serviceAccount:my-project-id@appspot.gserviceaccount.com\" ] }, { \"role\": \"roles/resourcemanager.organizationViewer\", \"members\": [ \"user:eve@example.com\" ], \"condition\": { \"title\": \"expirable access\", \"description\": \"Does not grant access after Sep 2020\", \"expression\": \"request.time < timestamp('2020-10-01T00:00:00.000Z')\", } } ], \"etag\": \"BwWWja0YfJA=\", \"version\": 3 } **YAML example:** bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') - etag: BwWWja0YfJA= - version: 3 For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).",
+      "id": "Policy",
+      "properties": {
+        "bindings": {
+          "description": "Associates a list of `members` to a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one member.",
+          "items": {
+            "$ref": "Binding"
+          },
+          "type": "array"
+        },
+        "etag": {
+          "description": "`etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.",
+          "format": "byte",
+          "type": "string"
+        },
+        "version": {
+          "description": "Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).",
+          "format": "int32",
+          "type": "integer"
+        }
+      },
+      "type": "object"
+    },
+    "PurgeQueueRequest": {
+      "description": "Request message for PurgeQueue.",
+      "id": "PurgeQueueRequest",
+      "properties": {},
+      "type": "object"
+    },
+    "Queue": {
+      "description": "A queue is a container of related tasks. Queues are configured to manage how those tasks are dispatched. Configurable properties include rate limits, retry options, queue types, and others.",
+      "id": "Queue",
+      "properties": {
+        "appEngineRoutingOverride": {
+          "$ref": "AppEngineRouting",
+          "description": "Overrides for task-level app_engine_routing. These settings apply only to App Engine tasks in this queue. Http tasks are not affected. If set, `app_engine_routing_override` is used for all App Engine tasks in the queue, no matter what the setting is for the task-level app_engine_routing."
+        },
+        "name": {
+          "description": "Caller-specified and required in CreateQueue, after which it becomes output only. The queue name. The queue name must have the following format: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID` * `PROJECT_ID` can contain letters ([A-Za-z]), numbers ([0-9]), hyphens (-), colons (:), or periods (.). For more information, see [Identifying projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects) * `LOCATION_ID` is the canonical ID for the queue's location. The list of available locations can be obtained by calling ListLocations. For more information, see https://cloud.google.com/about/locations/. * `QUEUE_ID` can contain letters ([A-Za-z]), numbers ([0-9]), or hyphens (-). The maximum length is 100 characters.",
+          "type": "string"
+        },
+        "purgeTime": {
+          "description": "Output only. The last time this queue was purged. All tasks that were created before this time were purged. A queue can be purged using PurgeQueue, the [App Engine Task Queue SDK, or the Cloud Console](https://cloud.google.com/appengine/docs/standard/python/taskqueue/push/deleting-tasks-and-queues#purging_all_tasks_from_a_queue). Purge time will be truncated to the nearest microsecond. Purge time will be unset if the queue has never been purged.",
+          "format": "google-datetime",
+          "type": "string"
+        },
+        "rateLimits": {
+          "$ref": "RateLimits",
+          "description": "Rate limits for task dispatches. rate_limits and retry_config are related because they both control task attempts. However they control task attempts in different ways: * rate_limits controls the total rate of dispatches from a queue (i.e. all traffic dispatched from the queue, regardless of whether the dispatch is from a first attempt or a retry). * retry_config controls what happens to particular a task after its first attempt fails. That is, retry_config controls task retries (the second attempt, third attempt, etc). The queue's actual dispatch rate is the result of: * Number of tasks in the queue * User-specified throttling: rate_limits, retry_config, and the queue's state. * System throttling due to `429` (Too Many Requests) or `503` (Service Unavailable) responses from the worker, high error rates, or to smooth sudden large traffic spikes."
+        },
+        "retryConfig": {
+          "$ref": "RetryConfig",
+          "description": "Settings that determine the retry behavior. * For tasks created using Cloud Tasks: the queue-level retry settings apply to all tasks in the queue that were created using Cloud Tasks. Retry settings cannot be set on individual tasks. * For tasks created using the App Engine SDK: the queue-level retry settings apply to all tasks in the queue which do not have retry settings explicitly set on the task and were created by the App Engine SDK. See [App Engine documentation](https://cloud.google.com/appengine/docs/standard/python/taskqueue/push/retrying-tasks)."
+        },
+        "stackdriverLoggingConfig": {
+          "$ref": "StackdriverLoggingConfig",
+          "description": "Configuration options for writing logs to [Stackdriver Logging](https://cloud.google.com/logging/docs/). If this field is unset, then no logs are written."
+        },
+        "state": {
+          "description": "Output only. The state of the queue. `state` can only be changed by called PauseQueue, ResumeQueue, or uploading [queue.yaml/xml](https://cloud.google.com/appengine/docs/python/config/queueref). UpdateQueue cannot be used to change `state`.",
+          "enum": [
+            "STATE_UNSPECIFIED",
+            "RUNNING",
+            "PAUSED",
+            "DISABLED"
+          ],
+          "enumDescriptions": [
+            "Unspecified state.",
+            "The queue is running. Tasks can be dispatched. If the queue was created using Cloud Tasks and the queue has had no activity (method calls or task dispatches) for 30 days, the queue may take a few minutes to re-activate. Some method calls may return NOT_FOUND and tasks may not be dispatched for a few minutes until the queue has been re-activated.",
+            "Tasks are paused by the user. If the queue is paused then Cloud Tasks will stop delivering tasks from it, but more tasks can still be added to it by the user.",
+            "The queue is disabled. A queue becomes `DISABLED` when [queue.yaml](https://cloud.google.com/appengine/docs/python/config/queueref) or [queue.xml](https://cloud.google.com/appengine/docs/standard/java/config/queueref) is uploaded which does not contain the queue. You cannot directly disable a queue. When a queue is disabled, tasks can still be added to a queue but the tasks are not dispatched. To permanently delete this queue and all of its tasks, call DeleteQueue."
+          ],
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "RateLimits": {
+      "description": "Rate limits. This message determines the maximum rate that tasks can be dispatched by a queue, regardless of whether the dispatch is a first task attempt or a retry. Note: The debugging command, RunTask, will run a task even if the queue has reached its RateLimits.",
+      "id": "RateLimits",
+      "properties": {
+        "maxBurstSize": {
+          "description": "Output only. The max burst size. Max burst size limits how fast tasks in queue are processed when many tasks are in the queue and the rate is high. This field allows the queue to have a high rate so processing starts shortly after a task is enqueued, but still limits resource usage when many tasks are enqueued in a short period of time. The [token bucket](https://wikipedia.org/wiki/Token_Bucket) algorithm is used to control the rate of task dispatches. Each queue has a token bucket that holds tokens, up to the maximum specified by `max_burst_size`. Each time a task is dispatched, a token is removed from the bucket. Tasks will be dispatched until the queue's bucket runs out of tokens. The bucket will be continuously refilled with new tokens based on max_dispatches_per_second. Cloud Tasks will pick the value of `max_burst_size` based on the value of max_dispatches_per_second. For queues that were created or updated using `queue.yaml/xml`, `max_burst_size` is equal to [bucket_size](https://cloud.google.com/appengine/docs/standard/python/config/queueref#bucket_size). Since `max_burst_size` is output only, if UpdateQueue is called on a queue created by `queue.yaml/xml`, `max_burst_size` will be reset based on the value of max_dispatches_per_second, regardless of whether max_dispatches_per_second is updated. ",
+          "format": "int32",
+          "type": "integer"
+        },
+        "maxConcurrentDispatches": {
+          "description": "The maximum number of concurrent tasks that Cloud Tasks allows to be dispatched for this queue. After this threshold has been reached, Cloud Tasks stops dispatching tasks until the number of concurrent requests decreases. If unspecified when the queue is created, Cloud Tasks will pick the default. The maximum allowed value is 5,000. This field has the same meaning as [max_concurrent_requests in queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#max_concurrent_requests).",
+          "format": "int32",
+          "type": "integer"
+        },
+        "maxDispatchesPerSecond": {
+          "description": "The maximum rate at which tasks are dispatched from this queue. If unspecified when the queue is created, Cloud Tasks will pick the default. * The maximum allowed value is 500. This field has the same meaning as [rate in queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#rate).",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "ResumeQueueRequest": {
+      "description": "Request message for ResumeQueue.",
+      "id": "ResumeQueueRequest",
+      "properties": {},
+      "type": "object"
+    },
+    "RetryConfig": {
+      "description": "Retry config. These settings determine when a failed task attempt is retried.",
+      "id": "RetryConfig",
+      "properties": {
+        "maxAttempts": {
+          "description": "Number of attempts per task. Cloud Tasks will attempt the task `max_attempts` times (that is, if the first attempt fails, then there will be `max_attempts - 1` retries). Must be >= -1. If unspecified when the queue is created, Cloud Tasks will pick the default. -1 indicates unlimited attempts. This field has the same meaning as [task_retry_limit in queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).",
+          "format": "int32",
+          "type": "integer"
+        },
+        "maxBackoff": {
+          "description": "A task will be scheduled for retry between min_backoff and max_backoff duration after it fails, if the queue's RetryConfig specifies that the task should be retried. If unspecified when the queue is created, Cloud Tasks will pick the default. `max_backoff` will be truncated to the nearest second. This field has the same meaning as [max_backoff_seconds in queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).",
+          "format": "google-duration",
+          "type": "string"
+        },
+        "maxDoublings": {
+          "description": "The time between retries will double `max_doublings` times. A task's retry interval starts at min_backoff, then doubles `max_doublings` times, then increases linearly, and finally retries at intervals of max_backoff up to max_attempts times. For example, if min_backoff is 10s, max_backoff is 300s, and `max_doublings` is 3, then the a task will first be retried in 10s. The retry interval will double three times, and then increase linearly by 2^3 * 10s. Finally, the task will retry at intervals of max_backoff until the task has been attempted max_attempts times. Thus, the requests will retry at 10s, 20s, 40s, 80s, 160s, 240s, 300s, 300s, .... If unspecified when the queue is created, Cloud Tasks will pick the default. This field has the same meaning as [max_doublings in queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).",
+          "format": "int32",
+          "type": "integer"
+        },
+        "maxRetryDuration": {
+          "description": "If positive, `max_retry_duration` specifies the time limit for retrying a failed task, measured from when the task was first attempted. Once `max_retry_duration` time has passed *and* the task has been attempted max_attempts times, no further attempts will be made and the task will be deleted. If zero, then the task age is unlimited. If unspecified when the queue is created, Cloud Tasks will pick the default. `max_retry_duration` will be truncated to the nearest second. This field has the same meaning as [task_age_limit in queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).",
+          "format": "google-duration",
+          "type": "string"
+        },
+        "minBackoff": {
+          "description": "A task will be scheduled for retry between min_backoff and max_backoff duration after it fails, if the queue's RetryConfig specifies that the task should be retried. If unspecified when the queue is created, Cloud Tasks will pick the default. `min_backoff` will be truncated to the nearest second. This field has the same meaning as [min_backoff_seconds in queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).",
+          "format": "google-duration",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "RunTaskRequest": {
+      "description": "Request message for forcing a task to run now using RunTask.",
+      "id": "RunTaskRequest",
+      "properties": {
+        "responseView": {
+          "description": "The response_view specifies which subset of the Task will be returned. By default response_view is BASIC; not all information is retrieved by default because some data, such as payloads, might be desirable to return only when needed because of its large size or because of the sensitivity of data that it contains. Authorization for FULL requires `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/) permission on the Task resource.",
+          "enum": [
+            "VIEW_UNSPECIFIED",
+            "BASIC",
+            "FULL"
+          ],
+          "enumDescriptions": [
+            "Unspecified. Defaults to BASIC.",
+            "The basic view omits fields which can be large or can contain sensitive data. This view does not include the body in AppEngineHttpRequest. Bodies are desirable to return only when needed, because they can be large and because of the sensitivity of the data that you choose to store in it.",
+            "All information is returned. Authorization for FULL requires `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/) permission on the Queue resource."
+          ],
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "SetIamPolicyRequest": {
+      "description": "Request message for `SetIamPolicy` method.",
+      "id": "SetIamPolicyRequest",
+      "properties": {
+        "policy": {
+          "$ref": "Policy",
+          "description": "REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Cloud Platform services (such as Projects) might reject them."
+        }
+      },
+      "type": "object"
+    },
+    "StackdriverLoggingConfig": {
+      "description": "Configuration options for writing logs to [Stackdriver Logging](https://cloud.google.com/logging/docs/).",
+      "id": "StackdriverLoggingConfig",
+      "properties": {
+        "samplingRatio": {
+          "description": "Specifies the fraction of operations to write to [Stackdriver Logging](https://cloud.google.com/logging/docs/). This field may contain any value between 0.0 and 1.0, inclusive. 0.0 is the default and means that no operations are logged.",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "Status": {
+      "description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).",
+      "id": "Status",
+      "properties": {
+        "code": {
+          "description": "The status code, which should be an enum value of google.rpc.Code.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "details": {
+          "description": "A list of messages that carry the error details. There is a common set of message types for APIs to use.",
+          "items": {
+            "additionalProperties": {
+              "description": "Properties of the object. Contains field @type with type URL.",
+              "type": "any"
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "message": {
+          "description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Task": {
+      "description": "A unit of scheduled work.",
+      "id": "Task",
+      "properties": {
+        "appEngineHttpRequest": {
+          "$ref": "AppEngineHttpRequest",
+          "description": "HTTP request that is sent to the App Engine app handler. An App Engine task is a task that has AppEngineHttpRequest set."
+        },
+        "createTime": {
+          "description": "Output only. The time that the task was created. `create_time` will be truncated to the nearest second.",
+          "format": "google-datetime",
+          "type": "string"
+        },
+        "dispatchCount": {
+          "description": "Output only. The number of attempts dispatched. This count includes attempts which have been dispatched but haven't received a response.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "dispatchDeadline": {
+          "description": "The deadline for requests sent to the worker. If the worker does not respond by this deadline then the request is cancelled and the attempt is marked as a `DEADLINE_EXCEEDED` failure. Cloud Tasks will retry the task according to the RetryConfig. Note that when the request is cancelled, Cloud Tasks will stop listening for the response, but whether the worker stops processing depends on the worker. For example, if the worker is stuck, it may not react to cancelled requests. The default and maximum values depend on the type of request: * For HTTP tasks, the default is 10 minutes. The deadline must be in the interval [15 seconds, 30 minutes]. * For App Engine tasks, 0 indicates that the request has the default deadline. The default deadline depends on the [scaling type](https://cloud.google.com/appengine/docs/standard/go/how-instances-are-managed#instance_scaling) of the service: 10 minutes for standard apps with automatic scaling, 24 hours for standard apps with manual and basic scaling, and 60 minutes for flex apps. If the request deadline is set, it must be in the interval [15 seconds, 24 hours 15 seconds]. Regardless of the task's `dispatch_deadline`, the app handler will not run for longer than than the service's timeout. We recommend setting the `dispatch_deadline` to at most a few seconds more than the app handler's timeout. For more information see [Timeouts](https://cloud.google.com/tasks/docs/creating-appengine-handlers#timeouts). `dispatch_deadline` will be truncated to the nearest millisecond. The deadline is an approximate deadline.",
+          "format": "google-duration",
+          "type": "string"
+        },
+        "firstAttempt": {
+          "$ref": "Attempt",
+          "description": "Output only. The status of the task's first attempt. Only dispatch_time will be set. The other Attempt information is not retained by Cloud Tasks."
+        },
+        "httpRequest": {
+          "$ref": "HttpRequest",
+          "description": "HTTP request that is sent to the worker. An HTTP task is a task that has HttpRequest set."
+        },
+        "lastAttempt": {
+          "$ref": "Attempt",
+          "description": "Output only. The status of the task's last attempt."
+        },
+        "name": {
+          "description": "Optionally caller-specified in CreateTask. The task name. The task name must have the following format: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID` * `PROJECT_ID` can contain letters ([A-Za-z]), numbers ([0-9]), hyphens (-), colons (:), or periods (.). For more information, see [Identifying projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects) * `LOCATION_ID` is the canonical ID for the task's location. The list of available locations can be obtained by calling ListLocations. For more information, see https://cloud.google.com/about/locations/. * `QUEUE_ID` can contain letters ([A-Za-z]), numbers ([0-9]), or hyphens (-). The maximum length is 100 characters. * `TASK_ID` can contain only letters ([A-Za-z]), numbers ([0-9]), hyphens (-), or underscores (_). The maximum length is 500 characters.",
+          "type": "string"
+        },
+        "responseCount": {
+          "description": "Output only. The number of attempts which have received a response.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "scheduleTime": {
+          "description": "The time when the task is scheduled to be attempted or retried. `schedule_time` will be truncated to the nearest microsecond.",
+          "format": "google-datetime",
+          "type": "string"
+        },
+        "view": {
+          "description": "Output only. The view specifies which subset of the Task has been returned.",
+          "enum": [
+            "VIEW_UNSPECIFIED",
+            "BASIC",
+            "FULL"
+          ],
+          "enumDescriptions": [
+            "Unspecified. Defaults to BASIC.",
+            "The basic view omits fields which can be large or can contain sensitive data. This view does not include the body in AppEngineHttpRequest. Bodies are desirable to return only when needed, because they can be large and because of the sensitivity of the data that you choose to store in it.",
+            "All information is returned. Authorization for FULL requires `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/) permission on the Queue resource."
+          ],
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "TestIamPermissionsRequest": {
+      "description": "Request message for `TestIamPermissions` method.",
+      "id": "TestIamPermissionsRequest",
+      "properties": {
+        "permissions": {
+          "description": "The set of permissions to check for the `resource`. Permissions with wildcards (such as '*' or 'storage.*') are not allowed. For more information see [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "TestIamPermissionsResponse": {
+      "description": "Response message for `TestIamPermissions` method.",
+      "id": "TestIamPermissionsResponse",
+      "properties": {
+        "permissions": {
+          "description": "A subset of `TestPermissionsRequest.permissions` that the caller is allowed.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    }
+  },
+  "servicePath": "",
+  "title": "Cloud Tasks API",
+  "version": "v2",
+  "version_module": true
+}
\ No newline at end of file
diff --git a/scripts/test_resources/new_artifacts_dir/bigquery.v2.json b/scripts/test_resources/new_artifacts_dir/bigquery.v2.json
new file mode 100644
index 0000000..e965bbc
--- /dev/null
+++ b/scripts/test_resources/new_artifacts_dir/bigquery.v2.json
@@ -0,0 +1,6549 @@
+{
+  "auth": {
+    "oauth2": {
+      "scopes": {
+        "https://www.googleapis.com/auth/bigquery": {
+          "description": "View and manage your data in Google BigQuery"
+        },
+        "https://www.googleapis.com/auth/bigquery.insertdata": {
+          "description": "Insert data into Google BigQuery"
+        },
+        "https://www.googleapis.com/auth/cloud-platform": {
+          "description": "See, edit, configure, and delete your Google Cloud Platform data"
+        },
+        "https://www.googleapis.com/auth/cloud-platform.read-only": {
+          "description": "View your data across Google Cloud Platform services"
+        },
+        "https://www.googleapis.com/auth/devstorage.full_control": {
+          "description": "Manage your data and permissions in Google Cloud Storage"
+        },
+        "https://www.googleapis.com/auth/devstorage.read_only": {
+          "description": "View your data in Google Cloud Storage"
+        },
+        "https://www.googleapis.com/auth/devstorage.read_write": {
+          "description": "Manage your data in Google Cloud Storage"
+        }
+      }
+    }
+  },
+  "basePath": "/bigquery/v2/",
+  "baseUrl": "https://bigquery.googleapis.com/bigquery/v2/",
+  "batchPath": "batch/bigquery/v2",
+  "description": "A data platform for customers to create, manage, share and query data.",
+  "discoveryVersion": "v1",
+  "documentationLink": "https://cloud.google.com/bigquery/",
+  "icons": {
+    "x16": "https://www.google.com/images/icons/product/search-16.gif",
+    "x32": "https://www.google.com/images/icons/product/search-32.gif"
+  },
+  "id": "bigquery:v2",
+  "kind": "discovery#restDescription",
+  "mtlsRootUrl": "https://bigquery.mtls.googleapis.com/",
+  "name": "bigquery",
+  "ownerDomain": "google.com",
+  "ownerName": "Google",
+  "parameters": {
+    "alt": {
+      "default": "json",
+      "description": "Data format for the response.",
+      "enum": [
+        "json"
+      ],
+      "enumDescriptions": [
+        "Responses with Content-Type of application/json"
+      ],
+      "location": "query",
+      "type": "string"
+    },
+    "fields": {
+      "description": "Selector specifying which fields to include in a partial response.",
+      "location": "query",
+      "type": "string"
+    },
+    "key": {
+      "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.",
+      "location": "query",
+      "type": "string"
+    },
+    "oauth_token": {
+      "description": "OAuth 2.0 token for the current user.",
+      "location": "query",
+      "type": "string"
+    },
+    "prettyPrint": {
+      "default": "true",
+      "description": "Returns response with indentations and line breaks.",
+      "location": "query",
+      "type": "boolean"
+    },
+    "quotaUser": {
+      "description": "An opaque string that represents a user for quota purposes. Must not exceed 40 characters.",
+      "location": "query",
+      "type": "string"
+    },
+    "userIp": {
+      "description": "Deprecated. Please use quotaUser instead.",
+      "location": "query",
+      "type": "string"
+    }
+  },
+  "protocol": "rest",
+  "resources": {
+    "datasets": {
+      "methods": {
+        "delete": {
+          "description": "Deletes the dataset specified by the datasetId value. Before you can delete a dataset, you must delete all its tables, either manually or by specifying deleteContents. Immediately after deletion, you can create another dataset with the same name.",
+          "httpMethod": "DELETE",
+          "id": "bigquery.datasets.delete",
+          "parameterOrder": [
+            "projectId",
+            "datasetId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of dataset being deleted",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "deleteContents": {
+              "description": "If True, delete all the tables in the dataset. If False and the dataset contains tables, the request will fail. Default is False",
+              "location": "query",
+              "type": "boolean"
+            },
+            "projectId": {
+              "description": "Project ID of the dataset being deleted",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "get": {
+          "description": "Returns the dataset specified by datasetID.",
+          "httpMethod": "GET",
+          "id": "bigquery.datasets.get",
+          "parameterOrder": [
+            "projectId",
+            "datasetId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the requested dataset",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the requested dataset",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}",
+          "response": {
+            "$ref": "Dataset"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "insert": {
+          "description": "Creates a new empty dataset.",
+          "httpMethod": "POST",
+          "id": "bigquery.datasets.insert",
+          "parameterOrder": [
+            "projectId"
+          ],
+          "parameters": {
+            "projectId": {
+              "description": "Project ID of the new dataset",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets",
+          "request": {
+            "$ref": "Dataset"
+          },
+          "response": {
+            "$ref": "Dataset"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "list": {
+          "description": "Lists all datasets in the specified project to which you have been granted the READER dataset role.",
+          "httpMethod": "GET",
+          "id": "bigquery.datasets.list",
+          "parameterOrder": [
+            "projectId"
+          ],
+          "parameters": {
+            "all": {
+              "description": "Whether to list all datasets, including hidden ones",
+              "location": "query",
+              "type": "boolean"
+            },
+            "filter": {
+              "description": "An expression for filtering the results of the request by label. The syntax is \"labels.<name>[:<value>]\". Multiple filters can be ANDed together by connecting with a space. Example: \"labels.department:receiving labels.active\". See Filtering datasets using labels for details.",
+              "location": "query",
+              "type": "string"
+            },
+            "maxResults": {
+              "description": "The maximum number of results to return",
+              "format": "uint32",
+              "location": "query",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Page token, returned by a previous call, to request the next page of results",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the datasets to be listed",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets",
+          "response": {
+            "$ref": "DatasetList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "patch": {
+          "description": "Updates information in an existing dataset. The update method replaces the entire dataset resource, whereas the patch method only replaces fields that are provided in the submitted dataset resource. This method supports patch semantics.",
+          "httpMethod": "PATCH",
+          "id": "bigquery.datasets.patch",
+          "parameterOrder": [
+            "projectId",
+            "datasetId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the dataset being updated",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the dataset being updated",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}",
+          "request": {
+            "$ref": "Dataset"
+          },
+          "response": {
+            "$ref": "Dataset"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "update": {
+          "description": "Updates information in an existing dataset. The update method replaces the entire dataset resource, whereas the patch method only replaces fields that are provided in the submitted dataset resource.",
+          "httpMethod": "PUT",
+          "id": "bigquery.datasets.update",
+          "parameterOrder": [
+            "projectId",
+            "datasetId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the dataset being updated",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the dataset being updated",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}",
+          "request": {
+            "$ref": "Dataset"
+          },
+          "response": {
+            "$ref": "Dataset"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        }
+      }
+    },
+    "jobs": {
+      "methods": {
+        "cancel": {
+          "description": "Requests that a job be cancelled. This call will return immediately, and the client will need to poll for the job status to see if the cancel completed successfully. Cancelled jobs may still incur costs.",
+          "httpMethod": "POST",
+          "id": "bigquery.jobs.cancel",
+          "parameterOrder": [
+            "projectId",
+            "jobId"
+          ],
+          "parameters": {
+            "jobId": {
+              "description": "[Required] Job ID of the job to cancel",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "location": {
+              "description": "The geographic location of the job. Required except for US and EU. See details at https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "[Required] Project ID of the job to cancel",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/jobs/{jobId}/cancel",
+          "response": {
+            "$ref": "JobCancelResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "delete": {
+          "description": "Requests that a job is deleted. This call will return when the job is deleted. This method is available in limited preview.",
+          "flatPath": "projects/{projectsId}/jobs/{jobsId}/delete",
+          "httpMethod": "DELETE",
+          "id": "bigquery.jobs.delete",
+          "parameterOrder": [
+            "projectId",
+            "jobId"
+          ],
+          "parameters": {
+            "jobId": {
+              "description": "Required. Job ID of the job to be deleted. If this is a parent job which has child jobs, all child jobs will be deleted as well. Deletion of child jobs directly is not allowed.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "location": {
+              "description": "The geographic location of the job. Required. See details at: https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the job to be deleted.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/jobs/{+jobId}/delete",
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "get": {
+          "description": "Returns information about a specific job. Job information is available for a six month period after creation. Requires that you're the person who ran the job, or have the Is Owner project role.",
+          "httpMethod": "GET",
+          "id": "bigquery.jobs.get",
+          "parameterOrder": [
+            "projectId",
+            "jobId"
+          ],
+          "parameters": {
+            "jobId": {
+              "description": "[Required] Job ID of the requested job",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "location": {
+              "description": "The geographic location of the job. Required except for US and EU. See details at https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "[Required] Project ID of the requested job",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/jobs/{jobId}",
+          "response": {
+            "$ref": "Job"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "getQueryResults": {
+          "description": "Retrieves the results of a query job.",
+          "httpMethod": "GET",
+          "id": "bigquery.jobs.getQueryResults",
+          "parameterOrder": [
+            "projectId",
+            "jobId"
+          ],
+          "parameters": {
+            "jobId": {
+              "description": "[Required] Job ID of the query job",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "location": {
+              "description": "The geographic location where the job should run. Required except for US and EU. See details at https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+              "location": "query",
+              "type": "string"
+            },
+            "maxResults": {
+              "description": "Maximum number of results to read",
+              "format": "uint32",
+              "location": "query",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Page token, returned by a previous call, to request the next page of results",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "[Required] Project ID of the query job",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "startIndex": {
+              "description": "Zero-based index of the starting row",
+              "format": "uint64",
+              "location": "query",
+              "type": "string"
+            },
+            "timeoutMs": {
+              "description": "How long to wait for the query to complete, in milliseconds, before returning. Default is 10 seconds. If the timeout passes before the job completes, the 'jobComplete' field in the response will be false",
+              "format": "uint32",
+              "location": "query",
+              "type": "integer"
+            }
+          },
+          "path": "projects/{projectId}/queries/{jobId}",
+          "response": {
+            "$ref": "GetQueryResultsResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "insert": {
+          "description": "Starts a new asynchronous job. Requires the Can View project role.",
+          "httpMethod": "POST",
+          "id": "bigquery.jobs.insert",
+          "mediaUpload": {
+            "accept": [
+              "*/*"
+            ],
+            "protocols": {
+              "resumable": {
+                "multipart": true,
+                "path": "/resumable/upload/bigquery/v2/projects/{projectId}/jobs"
+              },
+              "simple": {
+                "multipart": true,
+                "path": "/upload/bigquery/v2/projects/{projectId}/jobs"
+              }
+            }
+          },
+          "parameterOrder": [
+            "projectId"
+          ],
+          "parameters": {
+            "projectId": {
+              "description": "Project ID of the project that will be billed for the job",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/jobs",
+          "request": {
+            "$ref": "Job"
+          },
+          "response": {
+            "$ref": "Job"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/devstorage.full_control",
+            "https://www.googleapis.com/auth/devstorage.read_only",
+            "https://www.googleapis.com/auth/devstorage.read_write"
+          ],
+          "supportsMediaUpload": true
+        },
+        "list": {
+          "description": "Lists all jobs that you started in the specified project. Job information is available for a six month period after creation. The job list is sorted in reverse chronological order, by job creation time. Requires the Can View project role, or the Is Owner project role if you set the allUsers property.",
+          "httpMethod": "GET",
+          "id": "bigquery.jobs.list",
+          "parameterOrder": [
+            "projectId"
+          ],
+          "parameters": {
+            "allUsers": {
+              "description": "Whether to display jobs owned by all users in the project. Default false",
+              "location": "query",
+              "type": "boolean"
+            },
+            "maxCreationTime": {
+              "description": "Max value for job creation time, in milliseconds since the POSIX epoch. If set, only jobs created before or at this timestamp are returned",
+              "format": "uint64",
+              "location": "query",
+              "type": "string"
+            },
+            "maxResults": {
+              "description": "Maximum number of results to return",
+              "format": "uint32",
+              "location": "query",
+              "type": "integer"
+            },
+            "minCreationTime": {
+              "description": "Min value for job creation time, in milliseconds since the POSIX epoch. If set, only jobs created after or at this timestamp are returned",
+              "format": "uint64",
+              "location": "query",
+              "type": "string"
+            },
+            "pageToken": {
+              "description": "Page token, returned by a previous call, to request the next page of results",
+              "location": "query",
+              "type": "string"
+            },
+            "parentJobId": {
+              "description": "If set, retrieves only jobs whose parent is this job. Otherwise, retrieves only jobs which have no parent",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the jobs to list",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projection": {
+              "description": "Restrict information returned to a set of selected fields",
+              "enum": [
+                "full",
+                "minimal"
+              ],
+              "enumDescriptions": [
+                "Includes all job data",
+                "Does not include the job configuration"
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "stateFilter": {
+              "description": "Filter for job state",
+              "enum": [
+                "done",
+                "pending",
+                "running"
+              ],
+              "enumDescriptions": [
+                "Finished jobs",
+                "Pending jobs",
+                "Running jobs"
+              ],
+              "location": "query",
+              "repeated": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/jobs",
+          "response": {
+            "$ref": "JobList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "query": {
+          "description": "Runs a BigQuery SQL query synchronously and returns query results if the query completes within a specified timeout.",
+          "httpMethod": "POST",
+          "id": "bigquery.jobs.query",
+          "parameterOrder": [
+            "projectId"
+          ],
+          "parameters": {
+            "projectId": {
+              "description": "Project ID of the project billed for the query",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/queries",
+          "request": {
+            "$ref": "QueryRequest"
+          },
+          "response": {
+            "$ref": "QueryResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        }
+      }
+    },
+    "models": {
+      "methods": {
+        "delete": {
+          "description": "Deletes the model specified by modelId from the dataset.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/models/{modelsId}",
+          "httpMethod": "DELETE",
+          "id": "bigquery.models.delete",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "modelId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Required. Dataset ID of the model to delete.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "modelId": {
+              "description": "Required. Model ID of the model to delete.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the model to delete.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/datasets/{+datasetId}/models/{+modelId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "get": {
+          "description": "Gets the specified model resource by model ID.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/models/{modelsId}",
+          "httpMethod": "GET",
+          "id": "bigquery.models.get",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "modelId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Required. Dataset ID of the requested model.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "modelId": {
+              "description": "Required. Model ID of the requested model.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the requested model.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/datasets/{+datasetId}/models/{+modelId}",
+          "response": {
+            "$ref": "Model"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/bigquery.readonly",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "list": {
+          "description": "Lists all models in the specified dataset. Requires the READER dataset role.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/models",
+          "httpMethod": "GET",
+          "id": "bigquery.models.list",
+          "parameterOrder": [
+            "projectId",
+            "datasetId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Required. Dataset ID of the models to list.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "maxResults": {
+              "description": "The maximum number of results to return in a single response page. Leverage the page tokens to iterate through the entire collection.",
+              "format": "uint32",
+              "location": "query",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Page token, returned by a previous call to request the next page of results",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the models to list.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/datasets/{+datasetId}/models",
+          "response": {
+            "$ref": "ListModelsResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/bigquery.readonly",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "patch": {
+          "description": "Patch specific fields in the specified model.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/models/{modelsId}",
+          "httpMethod": "PATCH",
+          "id": "bigquery.models.patch",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "modelId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Required. Dataset ID of the model to patch.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "modelId": {
+              "description": "Required. Model ID of the model to patch.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the model to patch.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/datasets/{+datasetId}/models/{+modelId}",
+          "request": {
+            "$ref": "Model"
+          },
+          "response": {
+            "$ref": "Model"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        }
+      }
+    },
+    "projects": {
+      "methods": {
+        "getServiceAccount": {
+          "description": "Returns the email address of the service account for your project used for interactions with Google Cloud KMS.",
+          "httpMethod": "GET",
+          "id": "bigquery.projects.getServiceAccount",
+          "parameterOrder": [
+            "projectId"
+          ],
+          "parameters": {
+            "projectId": {
+              "description": "Project ID for which the service account is requested.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/serviceAccount",
+          "response": {
+            "$ref": "GetServiceAccountResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "list": {
+          "description": "Lists all projects to which you have been granted any project role.",
+          "httpMethod": "GET",
+          "id": "bigquery.projects.list",
+          "parameters": {
+            "maxResults": {
+              "description": "Maximum number of results to return",
+              "format": "uint32",
+              "location": "query",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Page token, returned by a previous call, to request the next page of results",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "projects",
+          "response": {
+            "$ref": "ProjectList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        }
+      }
+    },
+    "routines": {
+      "methods": {
+        "delete": {
+          "description": "Deletes the routine specified by routineId from the dataset.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/routines/{routinesId}",
+          "httpMethod": "DELETE",
+          "id": "bigquery.routines.delete",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "routineId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Required. Dataset ID of the routine to delete",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the routine to delete",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "routineId": {
+              "description": "Required. Routine ID of the routine to delete",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/datasets/{+datasetId}/routines/{+routineId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "get": {
+          "description": "Gets the specified routine resource by routine ID.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/routines/{routinesId}",
+          "httpMethod": "GET",
+          "id": "bigquery.routines.get",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "routineId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Required. Dataset ID of the requested routine",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the requested routine",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "readMask": {
+              "description": "If set, only the Routine fields in the field mask are returned in the response. If unset, all Routine fields are returned.",
+              "format": "google-fieldmask",
+              "location": "query",
+              "type": "string"
+            },
+            "routineId": {
+              "description": "Required. Routine ID of the requested routine",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/datasets/{+datasetId}/routines/{+routineId}",
+          "response": {
+            "$ref": "Routine"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/bigquery.readonly",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "insert": {
+          "description": "Creates a new routine in the dataset.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/routines",
+          "httpMethod": "POST",
+          "id": "bigquery.routines.insert",
+          "parameterOrder": [
+            "projectId",
+            "datasetId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Required. Dataset ID of the new routine",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the new routine",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/datasets/{+datasetId}/routines",
+          "request": {
+            "$ref": "Routine"
+          },
+          "response": {
+            "$ref": "Routine"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "list": {
+          "description": "Lists all routines in the specified dataset. Requires the READER dataset role.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/routines",
+          "httpMethod": "GET",
+          "id": "bigquery.routines.list",
+          "parameterOrder": [
+            "projectId",
+            "datasetId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Required. Dataset ID of the routines to list",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "filter": {
+              "description": "If set, then only the Routines matching this filter are returned. The current supported form is either \"routine_type:\" or \"routineType:\", where is a RoutineType enum. Example: \"routineType:SCALAR_FUNCTION\".",
+              "location": "query",
+              "type": "string"
+            },
+            "maxResults": {
+              "description": "The maximum number of results to return in a single response page. Leverage the page tokens to iterate through the entire collection.",
+              "format": "uint32",
+              "location": "query",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Page token, returned by a previous call, to request the next page of results",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the routines to list",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "readMask": {
+              "description": "If set, then only the Routine fields in the field mask, as well as project_id, dataset_id and routine_id, are returned in the response. If unset, then the following Routine fields are returned: etag, project_id, dataset_id, routine_id, routine_type, creation_time, last_modified_time, and language.",
+              "format": "google-fieldmask",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/datasets/{+datasetId}/routines",
+          "response": {
+            "$ref": "ListRoutinesResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/bigquery.readonly",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "update": {
+          "description": "Updates information in an existing routine. The update method replaces the entire Routine resource.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/routines/{routinesId}",
+          "httpMethod": "PUT",
+          "id": "bigquery.routines.update",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "routineId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Required. Dataset ID of the routine to update",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the routine to update",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "routineId": {
+              "description": "Required. Routine ID of the routine to update",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/datasets/{+datasetId}/routines/{+routineId}",
+          "request": {
+            "$ref": "Routine"
+          },
+          "response": {
+            "$ref": "Routine"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        }
+      }
+    },
+    "rowAccessPolicies": {
+      "methods": {
+        "getIamPolicy": {
+          "description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}/rowAccessPolicies/{rowAccessPoliciesId}:getIamPolicy",
+          "httpMethod": "POST",
+          "id": "bigquery.rowAccessPolicies.getIamPolicy",
+          "parameterOrder": [
+            "resource"
+          ],
+          "parameters": {
+            "resource": {
+              "description": "REQUIRED: The resource for which the policy is being requested. See the operation documentation for the appropriate value for this field.",
+              "location": "path",
+              "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+/rowAccessPolicies/[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "{+resource}:getIamPolicy",
+          "request": {
+            "$ref": "GetIamPolicyRequest"
+          },
+          "response": {
+            "$ref": "Policy"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/bigquery.readonly",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "list": {
+          "description": "Lists all row access policies on the specified table.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}/rowAccessPolicies",
+          "httpMethod": "GET",
+          "id": "bigquery.rowAccessPolicies.list",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "tableId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Required. Dataset ID of row access policies to list.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "pageSize": {
+              "description": "The maximum number of results to return in a single response page. Leverage the page tokens to iterate through the entire collection.",
+              "format": "int32",
+              "location": "query",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Page token, returned by a previous call, to request the next page of results.",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Required. Project ID of the row access policies to list.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            },
+            "tableId": {
+              "description": "Required. Table ID of the table to list row access policies.",
+              "location": "path",
+              "pattern": "^[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}/rowAccessPolicies",
+          "response": {
+            "$ref": "ListRowAccessPoliciesResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/bigquery.readonly",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "setIamPolicy": {
+          "description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}/rowAccessPolicies/{rowAccessPoliciesId}:setIamPolicy",
+          "httpMethod": "POST",
+          "id": "bigquery.rowAccessPolicies.setIamPolicy",
+          "parameterOrder": [
+            "resource"
+          ],
+          "parameters": {
+            "resource": {
+              "description": "REQUIRED: The resource for which the policy is being specified. See the operation documentation for the appropriate value for this field.",
+              "location": "path",
+              "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+/rowAccessPolicies/[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "{+resource}:setIamPolicy",
+          "request": {
+            "$ref": "SetIamPolicyRequest"
+          },
+          "response": {
+            "$ref": "Policy"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "testIamPermissions": {
+          "description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}/rowAccessPolicies/{rowAccessPoliciesId}:testIamPermissions",
+          "httpMethod": "POST",
+          "id": "bigquery.rowAccessPolicies.testIamPermissions",
+          "parameterOrder": [
+            "resource"
+          ],
+          "parameters": {
+            "resource": {
+              "description": "REQUIRED: The resource for which the policy detail is being requested. See the operation documentation for the appropriate value for this field.",
+              "location": "path",
+              "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+/rowAccessPolicies/[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "{+resource}:testIamPermissions",
+          "request": {
+            "$ref": "TestIamPermissionsRequest"
+          },
+          "response": {
+            "$ref": "TestIamPermissionsResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/bigquery.readonly",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        }
+      }
+    },
+    "tabledata": {
+      "methods": {
+        "insertAll": {
+          "description": "Streams data into BigQuery one record at a time without needing to run a load job. Requires the WRITER dataset role.",
+          "httpMethod": "POST",
+          "id": "bigquery.tabledata.insertAll",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "tableId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the destination table.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the destination table.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "tableId": {
+              "description": "Table ID of the destination table.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}/insertAll",
+          "request": {
+            "$ref": "TableDataInsertAllRequest"
+          },
+          "response": {
+            "$ref": "TableDataInsertAllResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/bigquery.insertdata",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "list": {
+          "description": "Retrieves table data from a specified set of rows. Requires the READER dataset role.",
+          "httpMethod": "GET",
+          "id": "bigquery.tabledata.list",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "tableId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the table to read",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "maxResults": {
+              "description": "Maximum number of results to return",
+              "format": "uint32",
+              "location": "query",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Page token, returned by a previous call, identifying the result set",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the table to read",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "selectedFields": {
+              "description": "List of fields to return (comma-separated). If unspecified, all fields are returned",
+              "location": "query",
+              "type": "string"
+            },
+            "startIndex": {
+              "description": "Zero-based index of the starting row to read",
+              "format": "uint64",
+              "location": "query",
+              "type": "string"
+            },
+            "tableId": {
+              "description": "Table ID of the table to read",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}/data",
+          "response": {
+            "$ref": "TableDataList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        }
+      }
+    },
+    "tables": {
+      "methods": {
+        "delete": {
+          "description": "Deletes the table specified by tableId from the dataset. If the table contains data, all the data will be deleted.",
+          "httpMethod": "DELETE",
+          "id": "bigquery.tables.delete",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "tableId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the table to delete",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the table to delete",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "tableId": {
+              "description": "Table ID of the table to delete",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "get": {
+          "description": "Gets the specified table resource by table ID. This method does not return the data in the table, it only returns the table resource, which describes the structure of this table.",
+          "httpMethod": "GET",
+          "id": "bigquery.tables.get",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "tableId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the requested table",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the requested table",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "selectedFields": {
+              "description": "List of fields to return (comma-separated). If unspecified, all fields are returned",
+              "location": "query",
+              "type": "string"
+            },
+            "tableId": {
+              "description": "Table ID of the requested table",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}",
+          "response": {
+            "$ref": "Table"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "getIamPolicy": {
+          "description": "Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}:getIamPolicy",
+          "httpMethod": "POST",
+          "id": "bigquery.tables.getIamPolicy",
+          "parameterOrder": [
+            "resource"
+          ],
+          "parameters": {
+            "resource": {
+              "description": "REQUIRED: The resource for which the policy is being requested. See the operation documentation for the appropriate value for this field.",
+              "location": "path",
+              "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "{+resource}:getIamPolicy",
+          "request": {
+            "$ref": "GetIamPolicyRequest"
+          },
+          "response": {
+            "$ref": "Policy"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/bigquery.readonly",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "insert": {
+          "description": "Creates a new, empty table in the dataset.",
+          "httpMethod": "POST",
+          "id": "bigquery.tables.insert",
+          "parameterOrder": [
+            "projectId",
+            "datasetId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the new table",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the new table",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}/tables",
+          "request": {
+            "$ref": "Table"
+          },
+          "response": {
+            "$ref": "Table"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "list": {
+          "description": "Lists all tables in the specified dataset. Requires the READER dataset role.",
+          "httpMethod": "GET",
+          "id": "bigquery.tables.list",
+          "parameterOrder": [
+            "projectId",
+            "datasetId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the tables to list",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "maxResults": {
+              "description": "Maximum number of results to return",
+              "format": "uint32",
+              "location": "query",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Page token, returned by a previous call, to request the next page of results",
+              "location": "query",
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the tables to list",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}/tables",
+          "response": {
+            "$ref": "TableList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "patch": {
+          "description": "Updates information in an existing table. The update method replaces the entire table resource, whereas the patch method only replaces fields that are provided in the submitted table resource. This method supports patch semantics.",
+          "httpMethod": "PATCH",
+          "id": "bigquery.tables.patch",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "tableId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the table to update",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the table to update",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "tableId": {
+              "description": "Table ID of the table to update",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}",
+          "request": {
+            "$ref": "Table"
+          },
+          "response": {
+            "$ref": "Table"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "setIamPolicy": {
+          "description": "Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}:setIamPolicy",
+          "httpMethod": "POST",
+          "id": "bigquery.tables.setIamPolicy",
+          "parameterOrder": [
+            "resource"
+          ],
+          "parameters": {
+            "resource": {
+              "description": "REQUIRED: The resource for which the policy is being specified. See the operation documentation for the appropriate value for this field.",
+              "location": "path",
+              "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "{+resource}:setIamPolicy",
+          "request": {
+            "$ref": "SetIamPolicyRequest"
+          },
+          "response": {
+            "$ref": "Policy"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        },
+        "testIamPermissions": {
+          "description": "Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may \"fail open\" without warning.",
+          "flatPath": "projects/{projectsId}/datasets/{datasetsId}/tables/{tablesId}:testIamPermissions",
+          "httpMethod": "POST",
+          "id": "bigquery.tables.testIamPermissions",
+          "parameterOrder": [
+            "resource"
+          ],
+          "parameters": {
+            "resource": {
+              "description": "REQUIRED: The resource for which the policy detail is being requested. See the operation documentation for the appropriate value for this field.",
+              "location": "path",
+              "pattern": "^projects/[^/]+/datasets/[^/]+/tables/[^/]+$",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "{+resource}:testIamPermissions",
+          "request": {
+            "$ref": "TestIamPermissionsRequest"
+          },
+          "response": {
+            "$ref": "TestIamPermissionsResponse"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/bigquery.readonly",
+            "https://www.googleapis.com/auth/cloud-platform",
+            "https://www.googleapis.com/auth/cloud-platform.read-only"
+          ]
+        },
+        "update": {
+          "description": "Updates information in an existing table. The update method replaces the entire table resource, whereas the patch method only replaces fields that are provided in the submitted table resource.",
+          "httpMethod": "PUT",
+          "id": "bigquery.tables.update",
+          "parameterOrder": [
+            "projectId",
+            "datasetId",
+            "tableId"
+          ],
+          "parameters": {
+            "datasetId": {
+              "description": "Dataset ID of the table to update",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "projectId": {
+              "description": "Project ID of the table to update",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "tableId": {
+              "description": "Table ID of the table to update",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "projects/{projectId}/datasets/{datasetId}/tables/{tableId}",
+          "request": {
+            "$ref": "Table"
+          },
+          "response": {
+            "$ref": "Table"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/bigquery",
+            "https://www.googleapis.com/auth/cloud-platform"
+          ]
+        }
+      }
+    }
+  },
+  "revision": "20210404",
+  "rootUrl": "https://bigquery.googleapis.com/",
+  "schemas": {
+    "AggregateClassificationMetrics": {
+      "description": "Aggregate metrics for classification/classifier models. For multi-class models, the metrics are either macro-averaged or micro-averaged. When macro-averaged, the metrics are calculated for each label and then an unweighted average is taken of those values. When micro-averaged, the metric is calculated globally by counting the total number of correctly predicted rows.",
+      "id": "AggregateClassificationMetrics",
+      "properties": {
+        "accuracy": {
+          "description": "Accuracy is the fraction of predictions given the correct label. For multiclass this is a micro-averaged metric.",
+          "format": "double",
+          "type": "number"
+        },
+        "f1Score": {
+          "description": "The F1 score is an average of recall and precision. For multiclass this is a macro-averaged metric.",
+          "format": "double",
+          "type": "number"
+        },
+        "logLoss": {
+          "description": "Logarithmic Loss. For multiclass this is a macro-averaged metric.",
+          "format": "double",
+          "type": "number"
+        },
+        "precision": {
+          "description": "Precision is the fraction of actual positive predictions that had positive actual labels. For multiclass this is a macro-averaged metric treating each class as a binary classifier.",
+          "format": "double",
+          "type": "number"
+        },
+        "recall": {
+          "description": "Recall is the fraction of actual positive labels that were given a positive prediction. For multiclass this is a macro-averaged metric.",
+          "format": "double",
+          "type": "number"
+        },
+        "rocAuc": {
+          "description": "Area Under a ROC Curve. For multiclass this is a macro-averaged metric.",
+          "format": "double",
+          "type": "number"
+        },
+        "threshold": {
+          "description": "Threshold at which the metrics are computed. For binary classification models this is the positive class threshold. For multi-class classfication models this is the confidence threshold.",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "Argument": {
+      "description": "Input/output argument of a function or a stored procedure.",
+      "id": "Argument",
+      "properties": {
+        "argumentKind": {
+          "description": "Optional. Defaults to FIXED_TYPE.",
+          "enum": [
+            "ARGUMENT_KIND_UNSPECIFIED",
+            "FIXED_TYPE",
+            "ANY_TYPE"
+          ],
+          "enumDescriptions": [
+            "",
+            "The argument is a variable with fully specified type, which can be a struct or an array, but not a table.",
+            "The argument is any type, including struct or array, but not a table. To be added: FIXED_TABLE, ANY_TABLE"
+          ],
+          "type": "string"
+        },
+        "dataType": {
+          "$ref": "StandardSqlDataType",
+          "description": "Required unless argument_kind = ANY_TYPE."
+        },
+        "mode": {
+          "description": "Optional. Specifies whether the argument is input or output. Can be set for procedures only.",
+          "enum": [
+            "MODE_UNSPECIFIED",
+            "IN",
+            "OUT",
+            "INOUT"
+          ],
+          "enumDescriptions": [
+            "",
+            "The argument is input-only.",
+            "The argument is output-only.",
+            "The argument is both an input and an output."
+          ],
+          "type": "string"
+        },
+        "name": {
+          "description": "Optional. The name of this argument. Can be absent for function return argument.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ArimaCoefficients": {
+      "description": "Arima coefficients.",
+      "id": "ArimaCoefficients",
+      "properties": {
+        "autoRegressiveCoefficients": {
+          "description": "Auto-regressive coefficients, an array of double.",
+          "items": {
+            "format": "double",
+            "type": "number"
+          },
+          "type": "array"
+        },
+        "interceptCoefficient": {
+          "description": "Intercept coefficient, just a double not an array.",
+          "format": "double",
+          "type": "number"
+        },
+        "movingAverageCoefficients": {
+          "description": "Moving-average coefficients, an array of double.",
+          "items": {
+            "format": "double",
+            "type": "number"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ArimaFittingMetrics": {
+      "description": "ARIMA model fitting metrics.",
+      "id": "ArimaFittingMetrics",
+      "properties": {
+        "aic": {
+          "description": "AIC.",
+          "format": "double",
+          "type": "number"
+        },
+        "logLikelihood": {
+          "description": "Log-likelihood.",
+          "format": "double",
+          "type": "number"
+        },
+        "variance": {
+          "description": "Variance.",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "ArimaForecastingMetrics": {
+      "description": "Model evaluation metrics for ARIMA forecasting models.",
+      "id": "ArimaForecastingMetrics",
+      "properties": {
+        "arimaFittingMetrics": {
+          "description": "Arima model fitting metrics.",
+          "items": {
+            "$ref": "ArimaFittingMetrics"
+          },
+          "type": "array"
+        },
+        "arimaSingleModelForecastingMetrics": {
+          "description": "Repeated as there can be many metric sets (one for each model) in auto-arima and the large-scale case.",
+          "items": {
+            "$ref": "ArimaSingleModelForecastingMetrics"
+          },
+          "type": "array"
+        },
+        "hasDrift": {
+          "description": "Whether Arima model fitted with drift or not. It is always false when d is not 1.",
+          "items": {
+            "type": "boolean"
+          },
+          "type": "array"
+        },
+        "nonSeasonalOrder": {
+          "description": "Non-seasonal order.",
+          "items": {
+            "$ref": "ArimaOrder"
+          },
+          "type": "array"
+        },
+        "seasonalPeriods": {
+          "description": "Seasonal periods. Repeated because multiple periods are supported for one time series.",
+          "items": {
+            "enum": [
+              "SEASONAL_PERIOD_TYPE_UNSPECIFIED",
+              "NO_SEASONALITY",
+              "DAILY",
+              "WEEKLY",
+              "MONTHLY",
+              "QUARTERLY",
+              "YEARLY"
+            ],
+            "enumDescriptions": [
+              "",
+              "No seasonality",
+              "Daily period, 24 hours.",
+              "Weekly period, 7 days.",
+              "Monthly period, 30 days or irregular.",
+              "Quarterly period, 90 days or irregular.",
+              "Yearly period, 365 days or irregular."
+            ],
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "timeSeriesId": {
+          "description": "Id to differentiate different time series for the large-scale case.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ArimaModelInfo": {
+      "description": "Arima model information.",
+      "id": "ArimaModelInfo",
+      "properties": {
+        "arimaCoefficients": {
+          "$ref": "ArimaCoefficients",
+          "description": "Arima coefficients."
+        },
+        "arimaFittingMetrics": {
+          "$ref": "ArimaFittingMetrics",
+          "description": "Arima fitting metrics."
+        },
+        "hasDrift": {
+          "description": "Whether Arima model fitted with drift or not. It is always false when d is not 1.",
+          "type": "boolean"
+        },
+        "hasHolidayEffect": {
+          "description": "If true, holiday_effect is a part of time series decomposition result.",
+          "type": "boolean"
+        },
+        "hasSpikesAndDips": {
+          "description": "If true, spikes_and_dips is a part of time series decomposition result.",
+          "type": "boolean"
+        },
+        "hasStepChanges": {
+          "description": "If true, step_changes is a part of time series decomposition result.",
+          "type": "boolean"
+        },
+        "nonSeasonalOrder": {
+          "$ref": "ArimaOrder",
+          "description": "Non-seasonal order."
+        },
+        "seasonalPeriods": {
+          "description": "Seasonal periods. Repeated because multiple periods are supported for one time series.",
+          "items": {
+            "enum": [
+              "SEASONAL_PERIOD_TYPE_UNSPECIFIED",
+              "NO_SEASONALITY",
+              "DAILY",
+              "WEEKLY",
+              "MONTHLY",
+              "QUARTERLY",
+              "YEARLY"
+            ],
+            "enumDescriptions": [
+              "",
+              "No seasonality",
+              "Daily period, 24 hours.",
+              "Weekly period, 7 days.",
+              "Monthly period, 30 days or irregular.",
+              "Quarterly period, 90 days or irregular.",
+              "Yearly period, 365 days or irregular."
+            ],
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "timeSeriesId": {
+          "description": "The time_series_id value for this time series. It will be one of the unique values from the time_series_id_column specified during ARIMA model training. Only present when time_series_id_column training option was used.",
+          "type": "string"
+        },
+        "timeSeriesIds": {
+          "description": "The tuple of time_series_ids identifying this time series. It will be one of the unique tuples of values present in the time_series_id_columns specified during ARIMA model training. Only present when time_series_id_columns training option was used and the order of values here are same as the order of time_series_id_columns.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ArimaOrder": {
+      "description": "Arima order, can be used for both non-seasonal and seasonal parts.",
+      "id": "ArimaOrder",
+      "properties": {
+        "d": {
+          "description": "Order of the differencing part.",
+          "format": "int64",
+          "type": "string"
+        },
+        "p": {
+          "description": "Order of the autoregressive part.",
+          "format": "int64",
+          "type": "string"
+        },
+        "q": {
+          "description": "Order of the moving-average part.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ArimaResult": {
+      "description": "(Auto-)arima fitting result. Wrap everything in ArimaResult for easier refactoring if we want to use model-specific iteration results.",
+      "id": "ArimaResult",
+      "properties": {
+        "arimaModelInfo": {
+          "description": "This message is repeated because there are multiple arima models fitted in auto-arima. For non-auto-arima model, its size is one.",
+          "items": {
+            "$ref": "ArimaModelInfo"
+          },
+          "type": "array"
+        },
+        "seasonalPeriods": {
+          "description": "Seasonal periods. Repeated because multiple periods are supported for one time series.",
+          "items": {
+            "enum": [
+              "SEASONAL_PERIOD_TYPE_UNSPECIFIED",
+              "NO_SEASONALITY",
+              "DAILY",
+              "WEEKLY",
+              "MONTHLY",
+              "QUARTERLY",
+              "YEARLY"
+            ],
+            "enumDescriptions": [
+              "",
+              "No seasonality",
+              "Daily period, 24 hours.",
+              "Weekly period, 7 days.",
+              "Monthly period, 30 days or irregular.",
+              "Quarterly period, 90 days or irregular.",
+              "Yearly period, 365 days or irregular."
+            ],
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ArimaSingleModelForecastingMetrics": {
+      "description": "Model evaluation metrics for a single ARIMA forecasting model.",
+      "id": "ArimaSingleModelForecastingMetrics",
+      "properties": {
+        "arimaFittingMetrics": {
+          "$ref": "ArimaFittingMetrics",
+          "description": "Arima fitting metrics."
+        },
+        "hasDrift": {
+          "description": "Is arima model fitted with drift or not. It is always false when d is not 1.",
+          "type": "boolean"
+        },
+        "hasHolidayEffect": {
+          "description": "If true, holiday_effect is a part of time series decomposition result.",
+          "type": "boolean"
+        },
+        "hasSpikesAndDips": {
+          "description": "If true, spikes_and_dips is a part of time series decomposition result.",
+          "type": "boolean"
+        },
+        "hasStepChanges": {
+          "description": "If true, step_changes is a part of time series decomposition result.",
+          "type": "boolean"
+        },
+        "nonSeasonalOrder": {
+          "$ref": "ArimaOrder",
+          "description": "Non-seasonal order."
+        },
+        "seasonalPeriods": {
+          "description": "Seasonal periods. Repeated because multiple periods are supported for one time series.",
+          "items": {
+            "enum": [
+              "SEASONAL_PERIOD_TYPE_UNSPECIFIED",
+              "NO_SEASONALITY",
+              "DAILY",
+              "WEEKLY",
+              "MONTHLY",
+              "QUARTERLY",
+              "YEARLY"
+            ],
+            "enumDescriptions": [
+              "",
+              "No seasonality",
+              "Daily period, 24 hours.",
+              "Weekly period, 7 days.",
+              "Monthly period, 30 days or irregular.",
+              "Quarterly period, 90 days or irregular.",
+              "Yearly period, 365 days or irregular."
+            ],
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "timeSeriesId": {
+          "description": "The time_series_id value for this time series. It will be one of the unique values from the time_series_id_column specified during ARIMA model training. Only present when time_series_id_column training option was used.",
+          "type": "string"
+        },
+        "timeSeriesIds": {
+          "description": "The tuple of time_series_ids identifying this time series. It will be one of the unique tuples of values present in the time_series_id_columns specified during ARIMA model training. Only present when time_series_id_columns training option was used and the order of values here are same as the order of time_series_id_columns.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "AuditConfig": {
+      "description": "Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { \"audit_configs\": [ { \"service\": \"allServices\", \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\", \"exempted_members\": [ \"user:jose@example.com\" ] }, { \"log_type\": \"DATA_WRITE\" }, { \"log_type\": \"ADMIN_READ\" } ] }, { \"service\": \"sampleservice.googleapis.com\", \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\" }, { \"log_type\": \"DATA_WRITE\", \"exempted_members\": [ \"user:aliya@example.com\" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts jose@example.com from DATA_READ logging, and aliya@example.com from DATA_WRITE logging.",
+      "id": "AuditConfig",
+      "properties": {
+        "auditLogConfigs": {
+          "description": "The configuration for logging of each type of permission.",
+          "items": {
+            "$ref": "AuditLogConfig"
+          },
+          "type": "array"
+        },
+        "service": {
+          "description": "Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "AuditLogConfig": {
+      "description": "Provides the configuration for logging a type of permissions. Example: { \"audit_log_configs\": [ { \"log_type\": \"DATA_READ\", \"exempted_members\": [ \"user:jose@example.com\" ] }, { \"log_type\": \"DATA_WRITE\" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.",
+      "id": "AuditLogConfig",
+      "properties": {
+        "exemptedMembers": {
+          "description": "Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "logType": {
+          "description": "The log type that this config enables.",
+          "enum": [
+            "LOG_TYPE_UNSPECIFIED",
+            "ADMIN_READ",
+            "DATA_WRITE",
+            "DATA_READ"
+          ],
+          "enumDescriptions": [
+            "Default case. Should never be this.",
+            "Admin reads. Example: CloudIAM getIamPolicy",
+            "Data writes. Example: CloudSQL Users create",
+            "Data reads. Example: CloudSQL Users list"
+          ],
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "BigQueryModelTraining": {
+      "id": "BigQueryModelTraining",
+      "properties": {
+        "currentIteration": {
+          "description": "[Output-only, Beta] Index of current ML training iteration. Updated during create model query job to show job progress.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "expectedTotalIterations": {
+          "description": "[Output-only, Beta] Expected number of iterations for the create model query job specified as num_iterations in the input query. The actual total number of iterations may be less than this number due to early stop.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "BigtableColumn": {
+      "id": "BigtableColumn",
+      "properties": {
+        "encoding": {
+          "description": "[Optional] The encoding of the values when the type is not STRING. Acceptable encoding values are: TEXT - indicates values are alphanumeric text strings. BINARY - indicates values are encoded using HBase Bytes.toBytes family of functions. 'encoding' can also be set at the column family level. However, the setting at this level takes precedence if 'encoding' is set at both levels.",
+          "type": "string"
+        },
+        "fieldName": {
+          "description": "[Optional] If the qualifier is not a valid BigQuery field identifier i.e. does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as the column field name and is used as field name in queries.",
+          "type": "string"
+        },
+        "onlyReadLatest": {
+          "description": "[Optional] If this is set, only the latest version of value in this column are exposed. 'onlyReadLatest' can also be set at the column family level. However, the setting at this level takes precedence if 'onlyReadLatest' is set at both levels.",
+          "type": "boolean"
+        },
+        "qualifierEncoded": {
+          "description": "[Required] Qualifier of the column. Columns in the parent column family that has this exact qualifier are exposed as . field. If the qualifier is valid UTF-8 string, it can be specified in the qualifier_string field. Otherwise, a base-64 encoded value must be set to qualifier_encoded. The column field name is the same as the column qualifier. However, if the qualifier is not a valid BigQuery field identifier i.e. does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as field_name.",
+          "format": "byte",
+          "type": "string"
+        },
+        "qualifierString": {
+          "type": "string"
+        },
+        "type": {
+          "description": "[Optional] The type to convert the value in cells of this column. The values are expected to be encoded using HBase Bytes.toBytes function when using the BINARY encoding value. Following BigQuery types are allowed (case-sensitive) - BYTES STRING INTEGER FLOAT BOOLEAN Default type is BYTES. 'type' can also be set at the column family level. However, the setting at this level takes precedence if 'type' is set at both levels.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "BigtableColumnFamily": {
+      "id": "BigtableColumnFamily",
+      "properties": {
+        "columns": {
+          "description": "[Optional] Lists of columns that should be exposed as individual fields as opposed to a list of (column name, value) pairs. All columns whose qualifier matches a qualifier in this list can be accessed as .. Other columns can be accessed as a list through .Column field.",
+          "items": {
+            "$ref": "BigtableColumn"
+          },
+          "type": "array"
+        },
+        "encoding": {
+          "description": "[Optional] The encoding of the values when the type is not STRING. Acceptable encoding values are: TEXT - indicates values are alphanumeric text strings. BINARY - indicates values are encoded using HBase Bytes.toBytes family of functions. This can be overridden for a specific column by listing that column in 'columns' and specifying an encoding for it.",
+          "type": "string"
+        },
+        "familyId": {
+          "description": "Identifier of the column family.",
+          "type": "string"
+        },
+        "onlyReadLatest": {
+          "description": "[Optional] If this is set only the latest version of value are exposed for all columns in this column family. This can be overridden for a specific column by listing that column in 'columns' and specifying a different setting for that column.",
+          "type": "boolean"
+        },
+        "type": {
+          "description": "[Optional] The type to convert the value in cells of this column family. The values are expected to be encoded using HBase Bytes.toBytes function when using the BINARY encoding value. Following BigQuery types are allowed (case-sensitive) - BYTES STRING INTEGER FLOAT BOOLEAN Default type is BYTES. This can be overridden for a specific column by listing that column in 'columns' and specifying a type for it.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "BigtableOptions": {
+      "id": "BigtableOptions",
+      "properties": {
+        "columnFamilies": {
+          "description": "[Optional] List of column families to expose in the table schema along with their types. This list restricts the column families that can be referenced in queries and specifies their value types. You can use this list to do type conversions - see the 'type' field for more details. If you leave this list empty, all column families are present in the table schema and their values are read as BYTES. During a query only the column families referenced in that query are read from Bigtable.",
+          "items": {
+            "$ref": "BigtableColumnFamily"
+          },
+          "type": "array"
+        },
+        "ignoreUnspecifiedColumnFamilies": {
+          "description": "[Optional] If field is true, then the column families that are not specified in columnFamilies list are not exposed in the table schema. Otherwise, they are read with BYTES type values. The default value is false.",
+          "type": "boolean"
+        },
+        "readRowkeyAsString": {
+          "description": "[Optional] If field is true, then the rowkey column families will be read and converted to string. Otherwise they are read with BYTES type values and users need to manually cast them with CAST if necessary. The default value is false.",
+          "type": "boolean"
+        }
+      },
+      "type": "object"
+    },
+    "BinaryClassificationMetrics": {
+      "description": "Evaluation metrics for binary classification/classifier models.",
+      "id": "BinaryClassificationMetrics",
+      "properties": {
+        "aggregateClassificationMetrics": {
+          "$ref": "AggregateClassificationMetrics",
+          "description": "Aggregate classification metrics."
+        },
+        "binaryConfusionMatrixList": {
+          "description": "Binary confusion matrix at multiple thresholds.",
+          "items": {
+            "$ref": "BinaryConfusionMatrix"
+          },
+          "type": "array"
+        },
+        "negativeLabel": {
+          "description": "Label representing the negative class.",
+          "type": "string"
+        },
+        "positiveLabel": {
+          "description": "Label representing the positive class.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "BinaryConfusionMatrix": {
+      "description": "Confusion matrix for binary classification models.",
+      "id": "BinaryConfusionMatrix",
+      "properties": {
+        "accuracy": {
+          "description": "The fraction of predictions given the correct label.",
+          "format": "double",
+          "type": "number"
+        },
+        "f1Score": {
+          "description": "The equally weighted average of recall and precision.",
+          "format": "double",
+          "type": "number"
+        },
+        "falseNegatives": {
+          "description": "Number of false samples predicted as false.",
+          "format": "int64",
+          "type": "string"
+        },
+        "falsePositives": {
+          "description": "Number of false samples predicted as true.",
+          "format": "int64",
+          "type": "string"
+        },
+        "positiveClassThreshold": {
+          "description": "Threshold value used when computing each of the following metric.",
+          "format": "double",
+          "type": "number"
+        },
+        "precision": {
+          "description": "The fraction of actual positive predictions that had positive actual labels.",
+          "format": "double",
+          "type": "number"
+        },
+        "recall": {
+          "description": "The fraction of actual positive labels that were given a positive prediction.",
+          "format": "double",
+          "type": "number"
+        },
+        "trueNegatives": {
+          "description": "Number of true samples predicted as false.",
+          "format": "int64",
+          "type": "string"
+        },
+        "truePositives": {
+          "description": "Number of true samples predicted as true.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Binding": {
+      "description": "Associates `members` with a `role`.",
+      "id": "Binding",
+      "properties": {
+        "condition": {
+          "$ref": "Expr",
+          "description": "The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the members in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies)."
+        },
+        "members": {
+          "description": "Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. ",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "role": {
+          "description": "Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "BqmlIterationResult": {
+      "id": "BqmlIterationResult",
+      "properties": {
+        "durationMs": {
+          "description": "[Output-only, Beta] Time taken to run the training iteration in milliseconds.",
+          "format": "int64",
+          "type": "string"
+        },
+        "evalLoss": {
+          "description": "[Output-only, Beta] Eval loss computed on the eval data at the end of the iteration. The eval loss is used for early stopping to avoid overfitting. No eval loss if eval_split_method option is specified as no_split or auto_split with input data size less than 500 rows.",
+          "format": "double",
+          "type": "number"
+        },
+        "index": {
+          "description": "[Output-only, Beta] Index of the ML training iteration, starting from zero for each training run.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "learnRate": {
+          "description": "[Output-only, Beta] Learning rate used for this iteration, it varies for different training iterations if learn_rate_strategy option is not constant.",
+          "format": "double",
+          "type": "number"
+        },
+        "trainingLoss": {
+          "description": "[Output-only, Beta] Training loss computed on the training data at the end of the iteration. The training loss function is defined by model type.",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "BqmlTrainingRun": {
+      "id": "BqmlTrainingRun",
+      "properties": {
+        "iterationResults": {
+          "description": "[Output-only, Beta] List of each iteration results.",
+          "items": {
+            "$ref": "BqmlIterationResult"
+          },
+          "type": "array"
+        },
+        "startTime": {
+          "description": "[Output-only, Beta] Training run start time in milliseconds since the epoch.",
+          "format": "date-time",
+          "type": "string"
+        },
+        "state": {
+          "description": "[Output-only, Beta] Different state applicable for a training run. IN PROGRESS: Training run is in progress. FAILED: Training run ended due to a non-retryable failure. SUCCEEDED: Training run successfully completed. CANCELLED: Training run cancelled by the user.",
+          "type": "string"
+        },
+        "trainingOptions": {
+          "description": "[Output-only, Beta] Training options used by this training run. These options are mutable for subsequent training runs. Default values are explicitly stored for options not specified in the input query of the first training run. For subsequent training runs, any option not explicitly specified in the input query will be copied from the previous training run.",
+          "properties": {
+            "earlyStop": {
+              "type": "boolean"
+            },
+            "l1Reg": {
+              "format": "double",
+              "type": "number"
+            },
+            "l2Reg": {
+              "format": "double",
+              "type": "number"
+            },
+            "learnRate": {
+              "format": "double",
+              "type": "number"
+            },
+            "learnRateStrategy": {
+              "type": "string"
+            },
+            "lineSearchInitLearnRate": {
+              "format": "double",
+              "type": "number"
+            },
+            "maxIteration": {
+              "format": "int64",
+              "type": "string"
+            },
+            "minRelProgress": {
+              "format": "double",
+              "type": "number"
+            },
+            "warmStart": {
+              "type": "boolean"
+            }
+          },
+          "type": "object"
+        }
+      },
+      "type": "object"
+    },
+    "CategoricalValue": {
+      "description": "Representative value of a categorical feature.",
+      "id": "CategoricalValue",
+      "properties": {
+        "categoryCounts": {
+          "description": "Counts of all categories for the categorical feature. If there are more than ten categories, we return top ten (by count) and return one more CategoryCount with category \"_OTHER_\" and count as aggregate counts of remaining categories.",
+          "items": {
+            "$ref": "CategoryCount"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "CategoryCount": {
+      "description": "Represents the count of a single category within the cluster.",
+      "id": "CategoryCount",
+      "properties": {
+        "category": {
+          "description": "The name of category.",
+          "type": "string"
+        },
+        "count": {
+          "description": "The count of training samples matching the category within the cluster.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Cluster": {
+      "description": "Message containing the information about one cluster.",
+      "id": "Cluster",
+      "properties": {
+        "centroidId": {
+          "description": "Centroid id.",
+          "format": "int64",
+          "type": "string"
+        },
+        "count": {
+          "description": "Count of training data rows that were assigned to this cluster.",
+          "format": "int64",
+          "type": "string"
+        },
+        "featureValues": {
+          "description": "Values of highly variant features for this cluster.",
+          "items": {
+            "$ref": "FeatureValue"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ClusterInfo": {
+      "description": "Information about a single cluster for clustering model.",
+      "id": "ClusterInfo",
+      "properties": {
+        "centroidId": {
+          "description": "Centroid id.",
+          "format": "int64",
+          "type": "string"
+        },
+        "clusterRadius": {
+          "description": "Cluster radius, the average distance from centroid to each point assigned to the cluster.",
+          "format": "double",
+          "type": "number"
+        },
+        "clusterSize": {
+          "description": "Cluster size, the total number of points assigned to the cluster.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Clustering": {
+      "id": "Clustering",
+      "properties": {
+        "fields": {
+          "description": "[Repeated] One or more fields on which data should be clustered. Only top-level, non-repeated, simple-type fields are supported. When you cluster a table using multiple columns, the order of columns you specify is important. The order of the specified columns determines the sort order of the data.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ClusteringMetrics": {
+      "description": "Evaluation metrics for clustering models.",
+      "id": "ClusteringMetrics",
+      "properties": {
+        "clusters": {
+          "description": "Information for all clusters.",
+          "items": {
+            "$ref": "Cluster"
+          },
+          "type": "array"
+        },
+        "daviesBouldinIndex": {
+          "description": "Davies-Bouldin index.",
+          "format": "double",
+          "type": "number"
+        },
+        "meanSquaredDistance": {
+          "description": "Mean of squared distances between each sample to its cluster centroid.",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "ConfusionMatrix": {
+      "description": "Confusion matrix for multi-class classification models.",
+      "id": "ConfusionMatrix",
+      "properties": {
+        "confidenceThreshold": {
+          "description": "Confidence threshold used when computing the entries of the confusion matrix.",
+          "format": "double",
+          "type": "number"
+        },
+        "rows": {
+          "description": "One row per actual label.",
+          "items": {
+            "$ref": "Row"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ConnectionProperty": {
+      "id": "ConnectionProperty",
+      "properties": {
+        "key": {
+          "description": "[Required] Name of the connection property to set.",
+          "type": "string"
+        },
+        "value": {
+          "description": "[Required] Value of the connection property.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "CsvOptions": {
+      "id": "CsvOptions",
+      "properties": {
+        "allowJaggedRows": {
+          "description": "[Optional] Indicates if BigQuery should accept rows that are missing trailing optional columns. If true, BigQuery treats missing trailing columns as null values. If false, records with missing trailing columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false.",
+          "type": "boolean"
+        },
+        "allowQuotedNewlines": {
+          "description": "[Optional] Indicates if BigQuery should allow quoted data sections that contain newline characters in a CSV file. The default value is false.",
+          "type": "boolean"
+        },
+        "encoding": {
+          "description": "[Optional] The character encoding of the data. The supported values are UTF-8 or ISO-8859-1. The default value is UTF-8. BigQuery decodes the data after the raw, binary data has been split using the values of the quote and fieldDelimiter properties.",
+          "type": "string"
+        },
+        "fieldDelimiter": {
+          "description": "[Optional] The separator for fields in a CSV file. BigQuery converts the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the data in its raw, binary state. BigQuery also supports the escape sequence \"\\t\" to specify a tab separator. The default value is a comma (',').",
+          "type": "string"
+        },
+        "quote": {
+          "default": "\"",
+          "description": "[Optional] The value that is used to quote data sections in a CSV file. BigQuery converts the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the data in its raw, binary state. The default value is a double-quote ('\"'). If your data does not contain quoted sections, set the property value to an empty string. If your data contains quoted newline characters, you must also set the allowQuotedNewlines property to true.",
+          "pattern": ".?",
+          "type": "string"
+        },
+        "skipLeadingRows": {
+          "description": "[Optional] The number of rows at the top of a CSV file that BigQuery will skip when reading the data. The default value is 0. This property is useful if you have header rows in the file that should be skipped. When autodetect is on, the behavior is the following: * skipLeadingRows unspecified - Autodetect tries to detect headers in the first row. If they are not detected, the row is read as data. Otherwise data is read starting from the second row. * skipLeadingRows is 0 - Instructs autodetect that there are no headers and data should be read starting from the first row. * skipLeadingRows = N > 0 - Autodetect skips N-1 rows and tries to detect headers in row N. If headers are not detected, row N is just skipped. Otherwise row N is used to extract column names for the detected schema.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "DataSplitResult": {
+      "description": "Data split result. This contains references to the training and evaluation data tables that were used to train the model.",
+      "id": "DataSplitResult",
+      "properties": {
+        "evaluationTable": {
+          "$ref": "TableReference",
+          "description": "Table reference of the evaluation data after split."
+        },
+        "trainingTable": {
+          "$ref": "TableReference",
+          "description": "Table reference of the training data after split."
+        }
+      },
+      "type": "object"
+    },
+    "Dataset": {
+      "id": "Dataset",
+      "properties": {
+        "access": {
+          "description": "[Optional] An array of objects that define dataset access for one or more entities. You can set this property when inserting or updating a dataset in order to control who is allowed to access the data. If unspecified at dataset creation time, BigQuery adds default dataset access for the following entities: access.specialGroup: projectReaders; access.role: READER; access.specialGroup: projectWriters; access.role: WRITER; access.specialGroup: projectOwners; access.role: OWNER; access.userByEmail: [dataset creator email]; access.role: OWNER;",
+          "items": {
+            "properties": {
+              "dataset": {
+                "$ref": "DatasetAccessEntry",
+                "description": "[Pick one] A grant authorizing all resources of a particular type in a particular dataset access to this dataset. Only views are supported for now. The role field is not required when this field is set. If that dataset is deleted and re-created, its access needs to be granted again via an update operation."
+              },
+              "domain": {
+                "description": "[Pick one] A domain to grant access to. Any users signed in with the domain specified will be granted the specified access. Example: \"example.com\". Maps to IAM policy member \"domain:DOMAIN\".",
+                "type": "string"
+              },
+              "groupByEmail": {
+                "description": "[Pick one] An email address of a Google Group to grant access to. Maps to IAM policy member \"group:GROUP\".",
+                "type": "string"
+              },
+              "iamMember": {
+                "description": "[Pick one] Some other type of member that appears in the IAM Policy but isn't a user, group, domain, or special group.",
+                "type": "string"
+              },
+              "role": {
+                "description": "[Required] An IAM role ID that should be granted to the user, group, or domain specified in this access entry. The following legacy mappings will be applied: OWNER  roles/bigquery.dataOwner WRITER  roles/bigquery.dataEditor READER  roles/bigquery.dataViewer This field will accept any of the above formats, but will return only the legacy format. For example, if you set this field to \"roles/bigquery.dataOwner\", it will be returned back as \"OWNER\".",
+                "type": "string"
+              },
+              "routine": {
+                "$ref": "RoutineReference",
+                "description": "[Pick one] A routine from a different dataset to grant access to. Queries executed against that routine will have read access to views/tables/routines in this dataset. Only UDF is supported for now. The role field is not required when this field is set. If that routine is updated by any user, access to the routine needs to be granted again via an update operation."
+              },
+              "specialGroup": {
+                "description": "[Pick one] A special group to grant access to. Possible values include: projectOwners: Owners of the enclosing project. projectReaders: Readers of the enclosing project. projectWriters: Writers of the enclosing project. allAuthenticatedUsers: All authenticated BigQuery users. Maps to similarly-named IAM members.",
+                "type": "string"
+              },
+              "userByEmail": {
+                "description": "[Pick one] An email address of a user to grant access to. For example: fred@example.com. Maps to IAM policy member \"user:EMAIL\" or \"serviceAccount:EMAIL\".",
+                "type": "string"
+              },
+              "view": {
+                "$ref": "TableReference",
+                "description": "[Pick one] A view from a different dataset to grant access to. Queries executed against that view will have read access to tables in this dataset. The role field is not required when this field is set. If that view is updated by any user, access to the view needs to be granted again via an update operation."
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "creationTime": {
+          "description": "[Output-only] The time when this dataset was created, in milliseconds since the epoch.",
+          "format": "int64",
+          "type": "string"
+        },
+        "datasetReference": {
+          "$ref": "DatasetReference",
+          "description": "[Required] A reference that identifies the dataset."
+        },
+        "defaultEncryptionConfiguration": {
+          "$ref": "EncryptionConfiguration"
+        },
+        "defaultPartitionExpirationMs": {
+          "description": "[Optional] The default partition expiration for all partitioned tables in the dataset, in milliseconds. Once this property is set, all newly-created partitioned tables in the dataset will have an expirationMs property in the timePartitioning settings set to this value, and changing the value will only affect new tables, not existing ones. The storage in a partition will have an expiration time of its partition time plus this value. Setting this property overrides the use of defaultTableExpirationMs for partitioned tables: only one of defaultTableExpirationMs and defaultPartitionExpirationMs will be used for any new partitioned table. If you provide an explicit timePartitioning.expirationMs when creating or updating a partitioned table, that value takes precedence over the default partition expiration time indicated by this property.",
+          "format": "int64",
+          "type": "string"
+        },
+        "defaultTableExpirationMs": {
+          "description": "[Optional] The default lifetime of all tables in the dataset, in milliseconds. The minimum value is 3600000 milliseconds (one hour). Once this property is set, all newly-created tables in the dataset will have an expirationTime property set to the creation time plus the value in this property, and changing the value will only affect new tables, not existing ones. When the expirationTime for a given table is reached, that table will be deleted automatically. If a table's expirationTime is modified or removed before the table expires, or if you provide an explicit expirationTime when creating a table, that value takes precedence over the default expiration time indicated by this property.",
+          "format": "int64",
+          "type": "string"
+        },
+        "description": {
+          "description": "[Optional] A user-friendly description of the dataset.",
+          "type": "string"
+        },
+        "etag": {
+          "description": "[Output-only] A hash of the resource.",
+          "type": "string"
+        },
+        "friendlyName": {
+          "description": "[Optional] A descriptive name for the dataset.",
+          "type": "string"
+        },
+        "id": {
+          "description": "[Output-only] The fully-qualified unique name of the dataset in the format projectId:datasetId. The dataset name without the project name is given in the datasetId field. When creating a new dataset, leave this field blank, and instead specify the datasetId field.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "bigquery#dataset",
+          "description": "[Output-only] The resource type.",
+          "type": "string"
+        },
+        "labels": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "The labels associated with this dataset. You can use these to organize and group your datasets. You can set this property when inserting or updating a dataset. See Creating and Updating Dataset Labels for more information.",
+          "type": "object"
+        },
+        "lastModifiedTime": {
+          "description": "[Output-only] The date when this dataset or any of its tables was last modified, in milliseconds since the epoch.",
+          "format": "int64",
+          "type": "string"
+        },
+        "location": {
+          "description": "The geographic location where the dataset should reside. The default value is US. See details at https://cloud.google.com/bigquery/docs/locations.",
+          "type": "string"
+        },
+        "satisfiesPZS": {
+          "description": "[Output-only] Reserved for future use.",
+          "type": "boolean"
+        },
+        "selfLink": {
+          "description": "[Output-only] A URL that can be used to access the resource again. You can use this URL in Get or Update requests to the resource.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "DatasetAccessEntry": {
+      "id": "DatasetAccessEntry",
+      "properties": {
+        "dataset": {
+          "$ref": "DatasetReference",
+          "description": "[Required] The dataset this entry applies to."
+        },
+        "target_types": {
+          "items": {
+            "properties": {
+              "targetType": {
+                "description": "[Required] Which resources in the dataset this entry applies to. Currently, only views are supported, but additional target types may be added in the future. Possible values: VIEWS: This entry applies to all views in the dataset.",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "DatasetList": {
+      "id": "DatasetList",
+      "properties": {
+        "datasets": {
+          "description": "An array of the dataset resources in the project. Each resource contains basic information. For full information about a particular dataset resource, use the Datasets: get method. This property is omitted when there are no datasets in the project.",
+          "items": {
+            "properties": {
+              "datasetReference": {
+                "$ref": "DatasetReference",
+                "description": "The dataset reference. Use this property to access specific parts of the dataset's ID, such as project ID or dataset ID."
+              },
+              "friendlyName": {
+                "description": "A descriptive name for the dataset, if one exists.",
+                "type": "string"
+              },
+              "id": {
+                "description": "The fully-qualified, unique, opaque ID of the dataset.",
+                "type": "string"
+              },
+              "kind": {
+                "default": "bigquery#dataset",
+                "description": "The resource type. This property always returns the value \"bigquery#dataset\".",
+                "type": "string"
+              },
+              "labels": {
+                "additionalProperties": {
+                  "type": "string"
+                },
+                "description": "The labels associated with this dataset. You can use these to organize and group your datasets.",
+                "type": "object"
+              },
+              "location": {
+                "description": "The geographic location where the data resides.",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "etag": {
+          "description": "A hash value of the results page. You can use this property to determine if the page has changed since the last request.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "bigquery#datasetList",
+          "description": "The list type. This property always returns the value \"bigquery#datasetList\".",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "A token that can be used to request the next results page. This property is omitted on the final results page.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "DatasetReference": {
+      "id": "DatasetReference",
+      "properties": {
+        "datasetId": {
+          "annotations": {
+            "required": [
+              "bigquery.datasets.update"
+            ]
+          },
+          "description": "[Required] A unique ID for this dataset, without the project name. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 1,024 characters.",
+          "type": "string"
+        },
+        "projectId": {
+          "annotations": {
+            "required": [
+              "bigquery.datasets.update"
+            ]
+          },
+          "description": "[Optional] The ID of the project containing this dataset.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "DestinationTableProperties": {
+      "id": "DestinationTableProperties",
+      "properties": {
+        "description": {
+          "description": "[Optional] The description for the destination table. This will only be used if the destination table is newly created. If the table already exists and a value different than the current description is provided, the job will fail.",
+          "type": "string"
+        },
+        "friendlyName": {
+          "description": "[Optional] The friendly name for the destination table. This will only be used if the destination table is newly created. If the table already exists and a value different than the current friendly name is provided, the job will fail.",
+          "type": "string"
+        },
+        "labels": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "[Optional] The labels associated with this table. You can use these to organize and group your tables. This will only be used if the destination table is newly created. If the table already exists and labels are different than the current labels are provided, the job will fail.",
+          "type": "object"
+        }
+      },
+      "type": "object"
+    },
+    "EncryptionConfiguration": {
+      "id": "EncryptionConfiguration",
+      "properties": {
+        "kmsKeyName": {
+          "description": "[Optional] Describes the Cloud KMS encryption key that will be used to protect destination BigQuery table. The BigQuery Service Account associated with your project requires access to this encryption key.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Entry": {
+      "description": "A single entry in the confusion matrix.",
+      "id": "Entry",
+      "properties": {
+        "itemCount": {
+          "description": "Number of items being predicted as this label.",
+          "format": "int64",
+          "type": "string"
+        },
+        "predictedLabel": {
+          "description": "The predicted label. For confidence_threshold > 0, we will also add an entry indicating the number of items under the confidence threshold.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ErrorProto": {
+      "id": "ErrorProto",
+      "properties": {
+        "debugInfo": {
+          "description": "Debugging information. This property is internal to Google and should not be used.",
+          "type": "string"
+        },
+        "location": {
+          "description": "Specifies where the error occurred, if present.",
+          "type": "string"
+        },
+        "message": {
+          "description": "A human-readable description of the error.",
+          "type": "string"
+        },
+        "reason": {
+          "description": "A short error code that summarizes the error.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "EvaluationMetrics": {
+      "description": "Evaluation metrics of a model. These are either computed on all training data or just the eval data based on whether eval data was used during training. These are not present for imported models.",
+      "id": "EvaluationMetrics",
+      "properties": {
+        "arimaForecastingMetrics": {
+          "$ref": "ArimaForecastingMetrics",
+          "description": "Populated for ARIMA models."
+        },
+        "binaryClassificationMetrics": {
+          "$ref": "BinaryClassificationMetrics",
+          "description": "Populated for binary classification/classifier models."
+        },
+        "clusteringMetrics": {
+          "$ref": "ClusteringMetrics",
+          "description": "Populated for clustering models."
+        },
+        "multiClassClassificationMetrics": {
+          "$ref": "MultiClassClassificationMetrics",
+          "description": "Populated for multi-class classification/classifier models."
+        },
+        "rankingMetrics": {
+          "$ref": "RankingMetrics",
+          "description": "Populated for implicit feedback type matrix factorization models."
+        },
+        "regressionMetrics": {
+          "$ref": "RegressionMetrics",
+          "description": "Populated for regression models and explicit feedback type matrix factorization models."
+        }
+      },
+      "type": "object"
+    },
+    "ExplainQueryStage": {
+      "id": "ExplainQueryStage",
+      "properties": {
+        "completedParallelInputs": {
+          "description": "Number of parallel input segments completed.",
+          "format": "int64",
+          "type": "string"
+        },
+        "computeMsAvg": {
+          "description": "Milliseconds the average shard spent on CPU-bound tasks.",
+          "format": "int64",
+          "type": "string"
+        },
+        "computeMsMax": {
+          "description": "Milliseconds the slowest shard spent on CPU-bound tasks.",
+          "format": "int64",
+          "type": "string"
+        },
+        "computeRatioAvg": {
+          "description": "Relative amount of time the average shard spent on CPU-bound tasks.",
+          "format": "double",
+          "type": "number"
+        },
+        "computeRatioMax": {
+          "description": "Relative amount of time the slowest shard spent on CPU-bound tasks.",
+          "format": "double",
+          "type": "number"
+        },
+        "endMs": {
+          "description": "Stage end time represented as milliseconds since epoch.",
+          "format": "int64",
+          "type": "string"
+        },
+        "id": {
+          "description": "Unique ID for stage within plan.",
+          "format": "int64",
+          "type": "string"
+        },
+        "inputStages": {
+          "description": "IDs for stages that are inputs to this stage.",
+          "items": {
+            "format": "int64",
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "name": {
+          "description": "Human-readable name for stage.",
+          "type": "string"
+        },
+        "parallelInputs": {
+          "description": "Number of parallel input segments to be processed.",
+          "format": "int64",
+          "type": "string"
+        },
+        "readMsAvg": {
+          "description": "Milliseconds the average shard spent reading input.",
+          "format": "int64",
+          "type": "string"
+        },
+        "readMsMax": {
+          "description": "Milliseconds the slowest shard spent reading input.",
+          "format": "int64",
+          "type": "string"
+        },
+        "readRatioAvg": {
+          "description": "Relative amount of time the average shard spent reading input.",
+          "format": "double",
+          "type": "number"
+        },
+        "readRatioMax": {
+          "description": "Relative amount of time the slowest shard spent reading input.",
+          "format": "double",
+          "type": "number"
+        },
+        "recordsRead": {
+          "description": "Number of records read into the stage.",
+          "format": "int64",
+          "type": "string"
+        },
+        "recordsWritten": {
+          "description": "Number of records written by the stage.",
+          "format": "int64",
+          "type": "string"
+        },
+        "shuffleOutputBytes": {
+          "description": "Total number of bytes written to shuffle.",
+          "format": "int64",
+          "type": "string"
+        },
+        "shuffleOutputBytesSpilled": {
+          "description": "Total number of bytes written to shuffle and spilled to disk.",
+          "format": "int64",
+          "type": "string"
+        },
+        "slotMs": {
+          "description": "Slot-milliseconds used by the stage.",
+          "format": "int64",
+          "type": "string"
+        },
+        "startMs": {
+          "description": "Stage start time represented as milliseconds since epoch.",
+          "format": "int64",
+          "type": "string"
+        },
+        "status": {
+          "description": "Current status for the stage.",
+          "type": "string"
+        },
+        "steps": {
+          "description": "List of operations within the stage in dependency order (approximately chronological).",
+          "items": {
+            "$ref": "ExplainQueryStep"
+          },
+          "type": "array"
+        },
+        "waitMsAvg": {
+          "description": "Milliseconds the average shard spent waiting to be scheduled.",
+          "format": "int64",
+          "type": "string"
+        },
+        "waitMsMax": {
+          "description": "Milliseconds the slowest shard spent waiting to be scheduled.",
+          "format": "int64",
+          "type": "string"
+        },
+        "waitRatioAvg": {
+          "description": "Relative amount of time the average shard spent waiting to be scheduled.",
+          "format": "double",
+          "type": "number"
+        },
+        "waitRatioMax": {
+          "description": "Relative amount of time the slowest shard spent waiting to be scheduled.",
+          "format": "double",
+          "type": "number"
+        },
+        "writeMsAvg": {
+          "description": "Milliseconds the average shard spent on writing output.",
+          "format": "int64",
+          "type": "string"
+        },
+        "writeMsMax": {
+          "description": "Milliseconds the slowest shard spent on writing output.",
+          "format": "int64",
+          "type": "string"
+        },
+        "writeRatioAvg": {
+          "description": "Relative amount of time the average shard spent on writing output.",
+          "format": "double",
+          "type": "number"
+        },
+        "writeRatioMax": {
+          "description": "Relative amount of time the slowest shard spent on writing output.",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "ExplainQueryStep": {
+      "id": "ExplainQueryStep",
+      "properties": {
+        "kind": {
+          "description": "Machine-readable operation type.",
+          "type": "string"
+        },
+        "substeps": {
+          "description": "Human-readable stage descriptions.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "Explanation": {
+      "description": "Explanation for a single feature.",
+      "id": "Explanation",
+      "properties": {
+        "attribution": {
+          "description": "Attribution of feature.",
+          "format": "double",
+          "type": "number"
+        },
+        "featureName": {
+          "description": "Full name of the feature. For non-numerical features, will be formatted like .. Overall size of feature name will always be truncated to first 120 characters.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Expr": {
+      "description": "Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: \"Summary size limit\" description: \"Determines if a summary is less than 100 chars\" expression: \"document.summary.size() < 100\" Example (Equality): title: \"Requestor is owner\" description: \"Determines if requestor is the document owner\" expression: \"document.owner == request.auth.claims.email\" Example (Logic): title: \"Public documents\" description: \"Determine whether the document should be publicly visible\" expression: \"document.type != 'private' && document.type != 'internal'\" Example (Data Manipulation): title: \"Notification string\" description: \"Create a notification string with a timestamp.\" expression: \"'New message received at ' + string(document.create_time)\" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.",
+      "id": "Expr",
+      "properties": {
+        "description": {
+          "description": "Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.",
+          "type": "string"
+        },
+        "expression": {
+          "description": "Textual representation of an expression in Common Expression Language syntax.",
+          "type": "string"
+        },
+        "location": {
+          "description": "Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.",
+          "type": "string"
+        },
+        "title": {
+          "description": "Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ExternalDataConfiguration": {
+      "id": "ExternalDataConfiguration",
+      "properties": {
+        "autodetect": {
+          "description": "Try to detect schema and format options automatically. Any option specified explicitly will be honored.",
+          "type": "boolean"
+        },
+        "bigtableOptions": {
+          "$ref": "BigtableOptions",
+          "description": "[Optional] Additional options if sourceFormat is set to BIGTABLE."
+        },
+        "compression": {
+          "description": "[Optional] The compression type of the data source. Possible values include GZIP and NONE. The default value is NONE. This setting is ignored for Google Cloud Bigtable, Google Cloud Datastore backups and Avro formats.",
+          "type": "string"
+        },
+        "connectionId": {
+          "description": "[Optional, Trusted Tester] Connection for external data source.",
+          "type": "string"
+        },
+        "csvOptions": {
+          "$ref": "CsvOptions",
+          "description": "Additional properties to set if sourceFormat is set to CSV."
+        },
+        "googleSheetsOptions": {
+          "$ref": "GoogleSheetsOptions",
+          "description": "[Optional] Additional options if sourceFormat is set to GOOGLE_SHEETS."
+        },
+        "hivePartitioningOptions": {
+          "$ref": "HivePartitioningOptions",
+          "description": "[Optional] Options to configure hive partitioning support."
+        },
+        "ignoreUnknownValues": {
+          "description": "[Optional] Indicates if BigQuery should allow extra values that are not represented in the table schema. If true, the extra values are ignored. If false, records with extra columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false. The sourceFormat property determines what BigQuery treats as an extra value: CSV: Trailing columns JSON: Named values that don't match any column names Google Cloud Bigtable: This setting is ignored. Google Cloud Datastore backups: This setting is ignored. Avro: This setting is ignored.",
+          "type": "boolean"
+        },
+        "maxBadRecords": {
+          "description": "[Optional] The maximum number of bad records that BigQuery can ignore when reading data. If the number of bad records exceeds this value, an invalid error is returned in the job result. This is only valid for CSV, JSON, and Google Sheets. The default value is 0, which requires that all records are valid. This setting is ignored for Google Cloud Bigtable, Google Cloud Datastore backups and Avro formats.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "parquetOptions": {
+          "$ref": "ParquetOptions",
+          "description": "Additional properties to set if sourceFormat is set to Parquet."
+        },
+        "schema": {
+          "$ref": "TableSchema",
+          "description": "[Optional] The schema for the data. Schema is required for CSV and JSON formats. Schema is disallowed for Google Cloud Bigtable, Cloud Datastore backups, and Avro formats."
+        },
+        "sourceFormat": {
+          "description": "[Required] The data format. For CSV files, specify \"CSV\". For Google sheets, specify \"GOOGLE_SHEETS\". For newline-delimited JSON, specify \"NEWLINE_DELIMITED_JSON\". For Avro files, specify \"AVRO\". For Google Cloud Datastore backups, specify \"DATASTORE_BACKUP\". [Beta] For Google Cloud Bigtable, specify \"BIGTABLE\".",
+          "type": "string"
+        },
+        "sourceUris": {
+          "description": "[Required] The fully-qualified URIs that point to your data in Google Cloud. For Google Cloud Storage URIs: Each URI can contain one '*' wildcard character and it must come after the 'bucket' name. Size limits related to load jobs apply to external data sources. For Google Cloud Bigtable URIs: Exactly one URI can be specified and it has be a fully specified and valid HTTPS URL for a Google Cloud Bigtable table. For Google Cloud Datastore backups, exactly one URI can be specified. Also, the '*' wildcard character is not allowed.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "FeatureValue": {
+      "description": "Representative value of a single feature within the cluster.",
+      "id": "FeatureValue",
+      "properties": {
+        "categoricalValue": {
+          "$ref": "CategoricalValue",
+          "description": "The categorical feature value."
+        },
+        "featureColumn": {
+          "description": "The feature column name.",
+          "type": "string"
+        },
+        "numericalValue": {
+          "description": "The numerical feature value. This is the centroid value for this feature.",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "GetIamPolicyRequest": {
+      "description": "Request message for `GetIamPolicy` method.",
+      "id": "GetIamPolicyRequest",
+      "properties": {
+        "options": {
+          "$ref": "GetPolicyOptions",
+          "description": "OPTIONAL: A `GetPolicyOptions` object for specifying options to `GetIamPolicy`."
+        }
+      },
+      "type": "object"
+    },
+    "GetPolicyOptions": {
+      "description": "Encapsulates settings provided to GetIamPolicy.",
+      "id": "GetPolicyOptions",
+      "properties": {
+        "requestedPolicyVersion": {
+          "description": "Optional. The policy format version to be returned. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional bindings must specify version 3. Policies without any conditional bindings may specify any valid value or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).",
+          "format": "int32",
+          "type": "integer"
+        }
+      },
+      "type": "object"
+    },
+    "GetQueryResultsResponse": {
+      "id": "GetQueryResultsResponse",
+      "properties": {
+        "cacheHit": {
+          "description": "Whether the query result was fetched from the query cache.",
+          "type": "boolean"
+        },
+        "errors": {
+          "description": "[Output-only] The first errors or warnings encountered during the running of the job. The final message includes the number of errors that caused the process to stop. Errors here do not necessarily mean that the job has completed or was unsuccessful.",
+          "items": {
+            "$ref": "ErrorProto"
+          },
+          "type": "array"
+        },
+        "etag": {
+          "description": "A hash of this response.",
+          "type": "string"
+        },
+        "jobComplete": {
+          "description": "Whether the query has completed or not. If rows or totalRows are present, this will always be true. If this is false, totalRows will not be available.",
+          "type": "boolean"
+        },
+        "jobReference": {
+          "$ref": "JobReference",
+          "description": "Reference to the BigQuery Job that was created to run the query. This field will be present even if the original request timed out, in which case GetQueryResults can be used to read the results once the query has completed. Since this API only returns the first page of results, subsequent pages can be fetched via the same mechanism (GetQueryResults)."
+        },
+        "kind": {
+          "default": "bigquery#getQueryResultsResponse",
+          "description": "The resource type of the response.",
+          "type": "string"
+        },
+        "numDmlAffectedRows": {
+          "description": "[Output-only] The number of rows affected by a DML statement. Present only for DML statements INSERT, UPDATE or DELETE.",
+          "format": "int64",
+          "type": "string"
+        },
+        "pageToken": {
+          "description": "A token used for paging results.",
+          "type": "string"
+        },
+        "rows": {
+          "description": "An object with as many results as can be contained within the maximum permitted reply size. To get any additional rows, you can call GetQueryResults and specify the jobReference returned above. Present only when the query completes successfully.",
+          "items": {
+            "$ref": "TableRow"
+          },
+          "type": "array"
+        },
+        "schema": {
+          "$ref": "TableSchema",
+          "description": "The schema of the results. Present only when the query completes successfully."
+        },
+        "totalBytesProcessed": {
+          "description": "The total number of bytes processed for this query.",
+          "format": "int64",
+          "type": "string"
+        },
+        "totalRows": {
+          "description": "The total number of rows in the complete query result set, which can be more than the number of rows in this single page of results. Present only when the query completes successfully.",
+          "format": "uint64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "GetServiceAccountResponse": {
+      "id": "GetServiceAccountResponse",
+      "properties": {
+        "email": {
+          "description": "The service account email address.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "bigquery#getServiceAccountResponse",
+          "description": "The resource type of the response.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "GlobalExplanation": {
+      "description": "Global explanations containing the top most important features after training.",
+      "id": "GlobalExplanation",
+      "properties": {
+        "classLabel": {
+          "description": "Class label for this set of global explanations. Will be empty/null for binary logistic and linear regression models. Sorted alphabetically in descending order.",
+          "type": "string"
+        },
+        "explanations": {
+          "description": "A list of the top global explanations. Sorted by absolute value of attribution in descending order.",
+          "items": {
+            "$ref": "Explanation"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "GoogleSheetsOptions": {
+      "id": "GoogleSheetsOptions",
+      "properties": {
+        "range": {
+          "description": "[Optional] Range of a sheet to query from. Only used when non-empty. Typical format: sheet_name!top_left_cell_id:bottom_right_cell_id For example: sheet1!A1:B20",
+          "type": "string"
+        },
+        "skipLeadingRows": {
+          "description": "[Optional] The number of rows at the top of a sheet that BigQuery will skip when reading the data. The default value is 0. This property is useful if you have header rows that should be skipped. When autodetect is on, behavior is the following: * skipLeadingRows unspecified - Autodetect tries to detect headers in the first row. If they are not detected, the row is read as data. Otherwise data is read starting from the second row. * skipLeadingRows is 0 - Instructs autodetect that there are no headers and data should be read starting from the first row. * skipLeadingRows = N > 0 - Autodetect skips N-1 rows and tries to detect headers in row N. If headers are not detected, row N is just skipped. Otherwise row N is used to extract column names for the detected schema.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "HivePartitioningOptions": {
+      "id": "HivePartitioningOptions",
+      "properties": {
+        "mode": {
+          "description": "[Optional] When set, what mode of hive partitioning to use when reading data. The following modes are supported. (1) AUTO: automatically infer partition key name(s) and type(s). (2) STRINGS: automatically infer partition key name(s). All types are interpreted as strings. (3) CUSTOM: partition key schema is encoded in the source URI prefix. Not all storage formats support hive partitioning. Requesting hive partitioning on an unsupported format will lead to an error. Currently supported types include: AVRO, CSV, JSON, ORC and Parquet.",
+          "type": "string"
+        },
+        "requirePartitionFilter": {
+          "description": "[Optional] If set to true, queries over this table require a partition filter that can be used for partition elimination to be specified. Note that this field should only be true when creating a permanent external table or querying a temporary external table. Hive-partitioned loads with requirePartitionFilter explicitly set to true will fail.",
+          "type": "boolean"
+        },
+        "sourceUriPrefix": {
+          "description": "[Optional] When hive partition detection is requested, a common prefix for all source uris should be supplied. The prefix must end immediately before the partition key encoding begins. For example, consider files following this data layout. gs://bucket/path_to_table/dt=2019-01-01/country=BR/id=7/file.avro gs://bucket/path_to_table/dt=2018-12-31/country=CA/id=3/file.avro When hive partitioning is requested with either AUTO or STRINGS detection, the common prefix can be either of gs://bucket/path_to_table or gs://bucket/path_to_table/ (trailing slash does not matter).",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "IterationResult": {
+      "description": "Information about a single iteration of the training run.",
+      "id": "IterationResult",
+      "properties": {
+        "arimaResult": {
+          "$ref": "ArimaResult"
+        },
+        "clusterInfos": {
+          "description": "Information about top clusters for clustering models.",
+          "items": {
+            "$ref": "ClusterInfo"
+          },
+          "type": "array"
+        },
+        "durationMs": {
+          "description": "Time taken to run the iteration in milliseconds.",
+          "format": "int64",
+          "type": "string"
+        },
+        "evalLoss": {
+          "description": "Loss computed on the eval data at the end of iteration.",
+          "format": "double",
+          "type": "number"
+        },
+        "index": {
+          "description": "Index of the iteration, 0 based.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "learnRate": {
+          "description": "Learn rate used for this iteration.",
+          "format": "double",
+          "type": "number"
+        },
+        "trainingLoss": {
+          "description": "Loss computed on the training data at the end of iteration.",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "Job": {
+      "id": "Job",
+      "properties": {
+        "configuration": {
+          "$ref": "JobConfiguration",
+          "description": "[Required] Describes the job configuration."
+        },
+        "etag": {
+          "description": "[Output-only] A hash of this resource.",
+          "type": "string"
+        },
+        "id": {
+          "description": "[Output-only] Opaque ID field of the job",
+          "type": "string"
+        },
+        "jobReference": {
+          "$ref": "JobReference",
+          "description": "[Optional] Reference describing the unique-per-user name of the job."
+        },
+        "kind": {
+          "default": "bigquery#job",
+          "description": "[Output-only] The type of the resource.",
+          "type": "string"
+        },
+        "selfLink": {
+          "description": "[Output-only] A URL that can be used to access this resource again.",
+          "type": "string"
+        },
+        "statistics": {
+          "$ref": "JobStatistics",
+          "description": "[Output-only] Information about the job, including starting time and ending time of the job."
+        },
+        "status": {
+          "$ref": "JobStatus",
+          "description": "[Output-only] The status of this job. Examine this value when polling an asynchronous job to see if the job is complete."
+        },
+        "user_email": {
+          "description": "[Output-only] Email address of the user who ran the job.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "JobCancelResponse": {
+      "id": "JobCancelResponse",
+      "properties": {
+        "job": {
+          "$ref": "Job",
+          "description": "The final state of the job."
+        },
+        "kind": {
+          "default": "bigquery#jobCancelResponse",
+          "description": "The resource type of the response.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "JobConfiguration": {
+      "id": "JobConfiguration",
+      "properties": {
+        "copy": {
+          "$ref": "JobConfigurationTableCopy",
+          "description": "[Pick one] Copies a table."
+        },
+        "dryRun": {
+          "description": "[Optional] If set, don't actually run this job. A valid query will return a mostly empty response with some processing statistics, while an invalid query will return the same error it would if it wasn't a dry run. Behavior of non-query jobs is undefined.",
+          "type": "boolean"
+        },
+        "extract": {
+          "$ref": "JobConfigurationExtract",
+          "description": "[Pick one] Configures an extract job."
+        },
+        "jobTimeoutMs": {
+          "description": "[Optional] Job timeout in milliseconds. If this time limit is exceeded, BigQuery may attempt to terminate the job.",
+          "format": "int64",
+          "type": "string"
+        },
+        "jobType": {
+          "description": "[Output-only] The type of the job. Can be QUERY, LOAD, EXTRACT, COPY or UNKNOWN.",
+          "type": "string"
+        },
+        "labels": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "The labels associated with this job. You can use these to organize and group your jobs. Label keys and values can be no longer than 63 characters, can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. Label values are optional. Label keys must start with a letter and each label in the list must have a different key.",
+          "type": "object"
+        },
+        "load": {
+          "$ref": "JobConfigurationLoad",
+          "description": "[Pick one] Configures a load job."
+        },
+        "query": {
+          "$ref": "JobConfigurationQuery",
+          "description": "[Pick one] Configures a query job."
+        }
+      },
+      "type": "object"
+    },
+    "JobConfigurationExtract": {
+      "id": "JobConfigurationExtract",
+      "properties": {
+        "compression": {
+          "description": "[Optional] The compression type to use for exported files. Possible values include GZIP, DEFLATE, SNAPPY, and NONE. The default value is NONE. DEFLATE and SNAPPY are only supported for Avro. Not applicable when extracting models.",
+          "type": "string"
+        },
+        "destinationFormat": {
+          "description": "[Optional] The exported file format. Possible values include CSV, NEWLINE_DELIMITED_JSON, PARQUET or AVRO for tables and ML_TF_SAVED_MODEL or ML_XGBOOST_BOOSTER for models. The default value for tables is CSV. Tables with nested or repeated fields cannot be exported as CSV. The default value for models is ML_TF_SAVED_MODEL.",
+          "type": "string"
+        },
+        "destinationUri": {
+          "description": "[Pick one] DEPRECATED: Use destinationUris instead, passing only one URI as necessary. The fully-qualified Google Cloud Storage URI where the extracted table should be written.",
+          "type": "string"
+        },
+        "destinationUris": {
+          "description": "[Pick one] A list of fully-qualified Google Cloud Storage URIs where the extracted table should be written.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "fieldDelimiter": {
+          "description": "[Optional] Delimiter to use between fields in the exported data. Default is ','. Not applicable when extracting models.",
+          "type": "string"
+        },
+        "printHeader": {
+          "default": "true",
+          "description": "[Optional] Whether to print out a header row in the results. Default is true. Not applicable when extracting models.",
+          "type": "boolean"
+        },
+        "sourceModel": {
+          "$ref": "ModelReference",
+          "description": "A reference to the model being exported."
+        },
+        "sourceTable": {
+          "$ref": "TableReference",
+          "description": "A reference to the table being exported."
+        },
+        "useAvroLogicalTypes": {
+          "description": "[Optional] If destinationFormat is set to \"AVRO\", this flag indicates whether to enable extracting applicable column types (such as TIMESTAMP) to their corresponding AVRO logical types (timestamp-micros), instead of only using their raw types (avro-long). Not applicable when extracting models.",
+          "type": "boolean"
+        }
+      },
+      "type": "object"
+    },
+    "JobConfigurationLoad": {
+      "id": "JobConfigurationLoad",
+      "properties": {
+        "allowJaggedRows": {
+          "description": "[Optional] Accept rows that are missing trailing optional columns. The missing values are treated as nulls. If false, records with missing trailing columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false. Only applicable to CSV, ignored for other formats.",
+          "type": "boolean"
+        },
+        "allowQuotedNewlines": {
+          "description": "Indicates if BigQuery should allow quoted data sections that contain newline characters in a CSV file. The default value is false.",
+          "type": "boolean"
+        },
+        "autodetect": {
+          "description": "[Optional] Indicates if we should automatically infer the options and schema for CSV and JSON sources.",
+          "type": "boolean"
+        },
+        "clustering": {
+          "$ref": "Clustering",
+          "description": "[Beta] Clustering specification for the destination table. Must be specified with time-based partitioning, data in the table will be first partitioned and subsequently clustered."
+        },
+        "createDisposition": {
+          "description": "[Optional] Specifies whether the job is allowed to create new tables. The following values are supported: CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table. CREATE_NEVER: The table must already exist. If it does not, a 'notFound' error is returned in the job result. The default value is CREATE_IF_NEEDED. Creation, truncation and append actions occur as one atomic update upon job completion.",
+          "type": "string"
+        },
+        "decimalTargetTypes": {
+          "description": "Defines the list of possible SQL data types to which the source decimal values are converted. This list and the precision and the scale parameters of the decimal field determine the target type. In the order of NUMERIC, BIGNUMERIC ([Preview](/products/#product-launch-stages)), and STRING, a type is picked if it is in the specified list and if it supports the precision and the scale. STRING supports all precision and scale values. If none of the listed types supports the precision and the scale, the type supporting the widest range in the specified list is picked, and if a value exceeds the supported range when reading the data, an error will be thrown. Example: Suppose the value of this field is [\"NUMERIC\", \"BIGNUMERIC\"]. If (precision,scale) is: * (38,9) -> NUMERIC; * (39,9) -> BIGNUMERIC (NUMERIC cannot hold 30 integer digits); * (38,10) -> BIGNUMERIC (NUMERIC cannot hold 10 fractional digits); * (76,38) -> BIGNUMERIC; * (77,38) -> BIGNUMERIC (error if value exeeds supported range). This field cannot contain duplicate types. The order of the types in this field is ignored. For example, [\"BIGNUMERIC\", \"NUMERIC\"] is the same as [\"NUMERIC\", \"BIGNUMERIC\"] and NUMERIC always takes precedence over BIGNUMERIC. Defaults to [\"NUMERIC\", \"STRING\"] for ORC and [\"NUMERIC\"] for the other file formats.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "destinationEncryptionConfiguration": {
+          "$ref": "EncryptionConfiguration",
+          "description": "Custom encryption configuration (e.g., Cloud KMS keys)."
+        },
+        "destinationTable": {
+          "$ref": "TableReference",
+          "description": "[Required] The destination table to load the data into."
+        },
+        "destinationTableProperties": {
+          "$ref": "DestinationTableProperties",
+          "description": "[Beta] [Optional] Properties with which to create the destination table if it is new."
+        },
+        "encoding": {
+          "description": "[Optional] The character encoding of the data. The supported values are UTF-8 or ISO-8859-1. The default value is UTF-8. BigQuery decodes the data after the raw, binary data has been split using the values of the quote and fieldDelimiter properties.",
+          "type": "string"
+        },
+        "fieldDelimiter": {
+          "description": "[Optional] The separator for fields in a CSV file. The separator can be any ISO-8859-1 single-byte character. To use a character in the range 128-255, you must encode the character as UTF8. BigQuery converts the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the data in its raw, binary state. BigQuery also supports the escape sequence \"\\t\" to specify a tab separator. The default value is a comma (',').",
+          "type": "string"
+        },
+        "hivePartitioningOptions": {
+          "$ref": "HivePartitioningOptions",
+          "description": "[Optional] Options to configure hive partitioning support."
+        },
+        "ignoreUnknownValues": {
+          "description": "[Optional] Indicates if BigQuery should allow extra values that are not represented in the table schema. If true, the extra values are ignored. If false, records with extra columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false. The sourceFormat property determines what BigQuery treats as an extra value: CSV: Trailing columns JSON: Named values that don't match any column names",
+          "type": "boolean"
+        },
+        "jsonExtension": {
+          "description": "[Optional] If sourceFormat is set to newline-delimited JSON, indicates whether it should be processed as a JSON variant such as GeoJSON. For a sourceFormat other than JSON, omit this field. If the sourceFormat is newline-delimited JSON: - for newline-delimited GeoJSON: set to GEOJSON.",
+          "type": "string"
+        },
+        "maxBadRecords": {
+          "description": "[Optional] The maximum number of bad records that BigQuery can ignore when running the job. If the number of bad records exceeds this value, an invalid error is returned in the job result. This is only valid for CSV and JSON. The default value is 0, which requires that all records are valid.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "nullMarker": {
+          "description": "[Optional] Specifies a string that represents a null value in a CSV file. For example, if you specify \"\\N\", BigQuery interprets \"\\N\" as a null value when loading a CSV file. The default value is the empty string. If you set this property to a custom value, BigQuery throws an error if an empty string is present for all data types except for STRING and BYTE. For STRING and BYTE columns, BigQuery interprets the empty string as an empty value.",
+          "type": "string"
+        },
+        "parquetOptions": {
+          "$ref": "ParquetOptions",
+          "description": "[Optional] Options to configure parquet support."
+        },
+        "projectionFields": {
+          "description": "If sourceFormat is set to \"DATASTORE_BACKUP\", indicates which entity properties to load into BigQuery from a Cloud Datastore backup. Property names are case sensitive and must be top-level properties. If no properties are specified, BigQuery loads all properties. If any named property isn't found in the Cloud Datastore backup, an invalid error is returned in the job result.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "quote": {
+          "default": "\"",
+          "description": "[Optional] The value that is used to quote data sections in a CSV file. BigQuery converts the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the data in its raw, binary state. The default value is a double-quote ('\"'). If your data does not contain quoted sections, set the property value to an empty string. If your data contains quoted newline characters, you must also set the allowQuotedNewlines property to true.",
+          "pattern": ".?",
+          "type": "string"
+        },
+        "rangePartitioning": {
+          "$ref": "RangePartitioning",
+          "description": "[TrustedTester] Range partitioning specification for this table. Only one of timePartitioning and rangePartitioning should be specified."
+        },
+        "schema": {
+          "$ref": "TableSchema",
+          "description": "[Optional] The schema for the destination table. The schema can be omitted if the destination table already exists, or if you're loading data from Google Cloud Datastore."
+        },
+        "schemaInline": {
+          "description": "[Deprecated] The inline schema. For CSV schemas, specify as \"Field1:Type1[,Field2:Type2]*\". For example, \"foo:STRING, bar:INTEGER, baz:FLOAT\".",
+          "type": "string"
+        },
+        "schemaInlineFormat": {
+          "description": "[Deprecated] The format of the schemaInline property.",
+          "type": "string"
+        },
+        "schemaUpdateOptions": {
+          "description": "Allows the schema of the destination table to be updated as a side effect of the load job if a schema is autodetected or supplied in the job configuration. Schema update options are supported in two cases: when writeDisposition is WRITE_APPEND; when writeDisposition is WRITE_TRUNCATE and the destination table is a partition of a table, specified by partition decorators. For normal tables, WRITE_TRUNCATE will always overwrite the schema. One or more of the following values are specified: ALLOW_FIELD_ADDITION: allow adding a nullable field to the schema. ALLOW_FIELD_RELAXATION: allow relaxing a required field in the original schema to nullable.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "skipLeadingRows": {
+          "description": "[Optional] The number of rows at the top of a CSV file that BigQuery will skip when loading the data. The default value is 0. This property is useful if you have header rows in the file that should be skipped.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "sourceFormat": {
+          "description": "[Optional] The format of the data files. For CSV files, specify \"CSV\". For datastore backups, specify \"DATASTORE_BACKUP\". For newline-delimited JSON, specify \"NEWLINE_DELIMITED_JSON\". For Avro, specify \"AVRO\". For parquet, specify \"PARQUET\". For orc, specify \"ORC\". The default value is CSV.",
+          "type": "string"
+        },
+        "sourceUris": {
+          "description": "[Required] The fully-qualified URIs that point to your data in Google Cloud. For Google Cloud Storage URIs: Each URI can contain one '*' wildcard character and it must come after the 'bucket' name. Size limits related to load jobs apply to external data sources. For Google Cloud Bigtable URIs: Exactly one URI can be specified and it has be a fully specified and valid HTTPS URL for a Google Cloud Bigtable table. For Google Cloud Datastore backups: Exactly one URI can be specified. Also, the '*' wildcard character is not allowed.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "timePartitioning": {
+          "$ref": "TimePartitioning",
+          "description": "Time-based partitioning specification for the destination table. Only one of timePartitioning and rangePartitioning should be specified."
+        },
+        "useAvroLogicalTypes": {
+          "description": "[Optional] If sourceFormat is set to \"AVRO\", indicates whether to enable interpreting logical types into their corresponding types (ie. TIMESTAMP), instead of only using their raw types (ie. INTEGER).",
+          "type": "boolean"
+        },
+        "writeDisposition": {
+          "description": "[Optional] Specifies the action that occurs if the destination table already exists. The following values are supported: WRITE_TRUNCATE: If the table already exists, BigQuery overwrites the table data. WRITE_APPEND: If the table already exists, BigQuery appends the data to the table. WRITE_EMPTY: If the table already exists and contains data, a 'duplicate' error is returned in the job result. The default value is WRITE_APPEND. Each action is atomic and only occurs if BigQuery is able to complete the job successfully. Creation, truncation and append actions occur as one atomic update upon job completion.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "JobConfigurationQuery": {
+      "id": "JobConfigurationQuery",
+      "properties": {
+        "allowLargeResults": {
+          "default": "false",
+          "description": "[Optional] If true and query uses legacy SQL dialect, allows the query to produce arbitrarily large result tables at a slight cost in performance. Requires destinationTable to be set. For standard SQL queries, this flag is ignored and large results are always allowed. However, you must still set destinationTable when result size exceeds the allowed maximum response size.",
+          "type": "boolean"
+        },
+        "clustering": {
+          "$ref": "Clustering",
+          "description": "[Beta] Clustering specification for the destination table. Must be specified with time-based partitioning, data in the table will be first partitioned and subsequently clustered."
+        },
+        "connectionProperties": {
+          "description": "Connection properties.",
+          "items": {
+            "$ref": "ConnectionProperty"
+          },
+          "type": "array"
+        },
+        "createDisposition": {
+          "description": "[Optional] Specifies whether the job is allowed to create new tables. The following values are supported: CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table. CREATE_NEVER: The table must already exist. If it does not, a 'notFound' error is returned in the job result. The default value is CREATE_IF_NEEDED. Creation, truncation and append actions occur as one atomic update upon job completion.",
+          "type": "string"
+        },
+        "createSession": {
+          "description": "If true, creates a new session, where session id will be a server generated random id. If false, runs query with an existing session_id passed in ConnectionProperty, otherwise runs query in non-session mode.",
+          "type": "boolean"
+        },
+        "defaultDataset": {
+          "$ref": "DatasetReference",
+          "description": "[Optional] Specifies the default dataset to use for unqualified table names in the query. Note that this does not alter behavior of unqualified dataset names."
+        },
+        "destinationEncryptionConfiguration": {
+          "$ref": "EncryptionConfiguration",
+          "description": "Custom encryption configuration (e.g., Cloud KMS keys)."
+        },
+        "destinationTable": {
+          "$ref": "TableReference",
+          "description": "[Optional] Describes the table where the query results should be stored. If not present, a new table will be created to store the results. This property must be set for large results that exceed the maximum response size."
+        },
+        "flattenResults": {
+          "default": "true",
+          "description": "[Optional] If true and query uses legacy SQL dialect, flattens all nested and repeated fields in the query results. allowLargeResults must be true if this is set to false. For standard SQL queries, this flag is ignored and results are never flattened.",
+          "type": "boolean"
+        },
+        "maximumBillingTier": {
+          "default": "1",
+          "description": "[Optional] Limits the billing tier for this job. Queries that have resource usage beyond this tier will fail (without incurring a charge). If unspecified, this will be set to your project default.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "maximumBytesBilled": {
+          "description": "[Optional] Limits the bytes billed for this job. Queries that will have bytes billed beyond this limit will fail (without incurring a charge). If unspecified, this will be set to your project default.",
+          "format": "int64",
+          "type": "string"
+        },
+        "parameterMode": {
+          "description": "Standard SQL only. Set to POSITIONAL to use positional (?) query parameters or to NAMED to use named (@myparam) query parameters in this query.",
+          "type": "string"
+        },
+        "preserveNulls": {
+          "description": "[Deprecated] This property is deprecated.",
+          "type": "boolean"
+        },
+        "priority": {
+          "description": "[Optional] Specifies a priority for the query. Possible values include INTERACTIVE and BATCH. The default value is INTERACTIVE.",
+          "type": "string"
+        },
+        "query": {
+          "description": "[Required] SQL query text to execute. The useLegacySql field can be used to indicate whether the query uses legacy SQL or standard SQL.",
+          "type": "string"
+        },
+        "queryParameters": {
+          "description": "Query parameters for standard SQL queries.",
+          "items": {
+            "$ref": "QueryParameter"
+          },
+          "type": "array"
+        },
+        "rangePartitioning": {
+          "$ref": "RangePartitioning",
+          "description": "[TrustedTester] Range partitioning specification for this table. Only one of timePartitioning and rangePartitioning should be specified."
+        },
+        "schemaUpdateOptions": {
+          "description": "Allows the schema of the destination table to be updated as a side effect of the query job. Schema update options are supported in two cases: when writeDisposition is WRITE_APPEND; when writeDisposition is WRITE_TRUNCATE and the destination table is a partition of a table, specified by partition decorators. For normal tables, WRITE_TRUNCATE will always overwrite the schema. One or more of the following values are specified: ALLOW_FIELD_ADDITION: allow adding a nullable field to the schema. ALLOW_FIELD_RELAXATION: allow relaxing a required field in the original schema to nullable.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "tableDefinitions": {
+          "additionalProperties": {
+            "$ref": "ExternalDataConfiguration"
+          },
+          "description": "[Optional] If querying an external data source outside of BigQuery, describes the data format, location and other properties of the data source. By defining these properties, the data source can then be queried as if it were a standard BigQuery table.",
+          "type": "object"
+        },
+        "timePartitioning": {
+          "$ref": "TimePartitioning",
+          "description": "Time-based partitioning specification for the destination table. Only one of timePartitioning and rangePartitioning should be specified."
+        },
+        "useLegacySql": {
+          "default": "true",
+          "description": "Specifies whether to use BigQuery's legacy SQL dialect for this query. The default value is true. If set to false, the query will use BigQuery's standard SQL: https://cloud.google.com/bigquery/sql-reference/ When useLegacySql is set to false, the value of flattenResults is ignored; query will be run as if flattenResults is false.",
+          "type": "boolean"
+        },
+        "useQueryCache": {
+          "default": "true",
+          "description": "[Optional] Whether to look for the result in the query cache. The query cache is a best-effort cache that will be flushed whenever tables in the query are modified. Moreover, the query cache is only available when a query does not have a destination table specified. The default value is true.",
+          "type": "boolean"
+        },
+        "userDefinedFunctionResources": {
+          "description": "Describes user-defined function resources used in the query.",
+          "items": {
+            "$ref": "UserDefinedFunctionResource"
+          },
+          "type": "array"
+        },
+        "writeDisposition": {
+          "description": "[Optional] Specifies the action that occurs if the destination table already exists. The following values are supported: WRITE_TRUNCATE: If the table already exists, BigQuery overwrites the table data and uses the schema from the query result. WRITE_APPEND: If the table already exists, BigQuery appends the data to the table. WRITE_EMPTY: If the table already exists and contains data, a 'duplicate' error is returned in the job result. The default value is WRITE_EMPTY. Each action is atomic and only occurs if BigQuery is able to complete the job successfully. Creation, truncation and append actions occur as one atomic update upon job completion.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "JobConfigurationTableCopy": {
+      "id": "JobConfigurationTableCopy",
+      "properties": {
+        "createDisposition": {
+          "description": "[Optional] Specifies whether the job is allowed to create new tables. The following values are supported: CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table. CREATE_NEVER: The table must already exist. If it does not, a 'notFound' error is returned in the job result. The default value is CREATE_IF_NEEDED. Creation, truncation and append actions occur as one atomic update upon job completion.",
+          "type": "string"
+        },
+        "destinationEncryptionConfiguration": {
+          "$ref": "EncryptionConfiguration",
+          "description": "Custom encryption configuration (e.g., Cloud KMS keys)."
+        },
+        "destinationExpirationTime": {
+          "description": "[Optional] The time when the destination table expires. Expired tables will be deleted and their storage reclaimed.",
+          "type": "any"
+        },
+        "destinationTable": {
+          "$ref": "TableReference",
+          "description": "[Required] The destination table"
+        },
+        "operationType": {
+          "description": "[Optional] Supported operation types in table copy job.",
+          "type": "string"
+        },
+        "sourceTable": {
+          "$ref": "TableReference",
+          "description": "[Pick one] Source table to copy."
+        },
+        "sourceTables": {
+          "description": "[Pick one] Source tables to copy.",
+          "items": {
+            "$ref": "TableReference"
+          },
+          "type": "array"
+        },
+        "writeDisposition": {
+          "description": "[Optional] Specifies the action that occurs if the destination table already exists. The following values are supported: WRITE_TRUNCATE: If the table already exists, BigQuery overwrites the table data. WRITE_APPEND: If the table already exists, BigQuery appends the data to the table. WRITE_EMPTY: If the table already exists and contains data, a 'duplicate' error is returned in the job result. The default value is WRITE_EMPTY. Each action is atomic and only occurs if BigQuery is able to complete the job successfully. Creation, truncation and append actions occur as one atomic update upon job completion.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "JobList": {
+      "id": "JobList",
+      "properties": {
+        "etag": {
+          "description": "A hash of this page of results.",
+          "type": "string"
+        },
+        "jobs": {
+          "description": "List of jobs that were requested.",
+          "items": {
+            "properties": {
+              "configuration": {
+                "$ref": "JobConfiguration",
+                "description": "[Full-projection-only] Specifies the job configuration."
+              },
+              "errorResult": {
+                "$ref": "ErrorProto",
+                "description": "A result object that will be present only if the job has failed."
+              },
+              "id": {
+                "description": "Unique opaque ID of the job.",
+                "type": "string"
+              },
+              "jobReference": {
+                "$ref": "JobReference",
+                "description": "Job reference uniquely identifying the job."
+              },
+              "kind": {
+                "default": "bigquery#job",
+                "description": "The resource type.",
+                "type": "string"
+              },
+              "state": {
+                "description": "Running state of the job. When the state is DONE, errorResult can be checked to determine whether the job succeeded or failed.",
+                "type": "string"
+              },
+              "statistics": {
+                "$ref": "JobStatistics",
+                "description": "[Output-only] Information about the job, including starting time and ending time of the job."
+              },
+              "status": {
+                "$ref": "JobStatus",
+                "description": "[Full-projection-only] Describes the state of the job."
+              },
+              "user_email": {
+                "description": "[Full-projection-only] Email address of the user who ran the job.",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "bigquery#jobList",
+          "description": "The resource type of the response.",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "A token to request the next page of results.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "JobReference": {
+      "id": "JobReference",
+      "properties": {
+        "jobId": {
+          "annotations": {
+            "required": [
+              "bigquery.jobs.getQueryResults"
+            ]
+          },
+          "description": "[Required] The ID of the job. The ID must contain only letters (a-z, A-Z), numbers (0-9), underscores (_), or dashes (-). The maximum length is 1,024 characters.",
+          "type": "string"
+        },
+        "location": {
+          "description": "The geographic location of the job. See details at https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+          "type": "string"
+        },
+        "projectId": {
+          "annotations": {
+            "required": [
+              "bigquery.jobs.getQueryResults"
+            ]
+          },
+          "description": "[Required] The ID of the project containing this job.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "JobStatistics": {
+      "id": "JobStatistics",
+      "properties": {
+        "completionRatio": {
+          "description": "[TrustedTester] [Output-only] Job progress (0.0 -> 1.0) for LOAD and EXTRACT jobs.",
+          "format": "double",
+          "type": "number"
+        },
+        "creationTime": {
+          "description": "[Output-only] Creation time of this job, in milliseconds since the epoch. This field will be present on all jobs.",
+          "format": "int64",
+          "type": "string"
+        },
+        "endTime": {
+          "description": "[Output-only] End time of this job, in milliseconds since the epoch. This field will be present whenever a job is in the DONE state.",
+          "format": "int64",
+          "type": "string"
+        },
+        "extract": {
+          "$ref": "JobStatistics4",
+          "description": "[Output-only] Statistics for an extract job."
+        },
+        "load": {
+          "$ref": "JobStatistics3",
+          "description": "[Output-only] Statistics for a load job."
+        },
+        "numChildJobs": {
+          "description": "[Output-only] Number of child jobs executed.",
+          "format": "int64",
+          "type": "string"
+        },
+        "parentJobId": {
+          "description": "[Output-only] If this is a child job, the id of the parent.",
+          "type": "string"
+        },
+        "query": {
+          "$ref": "JobStatistics2",
+          "description": "[Output-only] Statistics for a query job."
+        },
+        "quotaDeferments": {
+          "description": "[Output-only] Quotas which delayed this job's start time.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "reservationUsage": {
+          "description": "[Output-only] Job resource usage breakdown by reservation.",
+          "items": {
+            "properties": {
+              "name": {
+                "description": "[Output-only] Reservation name or \"unreserved\" for on-demand resources usage.",
+                "type": "string"
+              },
+              "slotMs": {
+                "description": "[Output-only] Slot-milliseconds the job spent in the given reservation.",
+                "format": "int64",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "reservation_id": {
+          "description": "[Output-only] Name of the primary reservation assigned to this job. Note that this could be different than reservations reported in the reservation usage field if parent reservations were used to execute this job.",
+          "type": "string"
+        },
+        "rowLevelSecurityStatistics": {
+          "$ref": "RowLevelSecurityStatistics",
+          "description": "[Output-only] [Preview] Statistics for row-level security. Present only for query and extract jobs."
+        },
+        "scriptStatistics": {
+          "$ref": "ScriptStatistics",
+          "description": "[Output-only] Statistics for a child job of a script."
+        },
+        "sessionInfoTemplate": {
+          "$ref": "SessionInfo",
+          "description": "[Output-only] [Preview] Information of the session if this job is part of one."
+        },
+        "startTime": {
+          "description": "[Output-only] Start time of this job, in milliseconds since the epoch. This field will be present when the job transitions from the PENDING state to either RUNNING or DONE.",
+          "format": "int64",
+          "type": "string"
+        },
+        "totalBytesProcessed": {
+          "description": "[Output-only] [Deprecated] Use the bytes processed in the query statistics instead.",
+          "format": "int64",
+          "type": "string"
+        },
+        "totalSlotMs": {
+          "description": "[Output-only] Slot-milliseconds for the job.",
+          "format": "int64",
+          "type": "string"
+        },
+        "transactionInfoTemplate": {
+          "$ref": "TransactionInfo",
+          "description": "[Output-only] [Alpha] Information of the multi-statement transaction if this job is part of one."
+        }
+      },
+      "type": "object"
+    },
+    "JobStatistics2": {
+      "id": "JobStatistics2",
+      "properties": {
+        "billingTier": {
+          "description": "[Output-only] Billing tier for the job.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "cacheHit": {
+          "description": "[Output-only] Whether the query result was fetched from the query cache.",
+          "type": "boolean"
+        },
+        "ddlAffectedRowAccessPolicyCount": {
+          "description": "[Output-only] [Preview] The number of row access policies affected by a DDL statement. Present only for DROP ALL ROW ACCESS POLICIES queries.",
+          "format": "int64",
+          "type": "string"
+        },
+        "ddlOperationPerformed": {
+          "description": "The DDL operation performed, possibly dependent on the pre-existence of the DDL target. Possible values (new values might be added in the future): \"CREATE\": The query created the DDL target. \"SKIP\": No-op. Example cases: the query is CREATE TABLE IF NOT EXISTS while the table already exists, or the query is DROP TABLE IF EXISTS while the table does not exist. \"REPLACE\": The query replaced the DDL target. Example case: the query is CREATE OR REPLACE TABLE, and the table already exists. \"DROP\": The query deleted the DDL target.",
+          "type": "string"
+        },
+        "ddlTargetDataset": {
+          "$ref": "DatasetReference",
+          "description": "[Output-only] The DDL target dataset. Present only for CREATE/ALTER/DROP SCHEMA queries."
+        },
+        "ddlTargetRoutine": {
+          "$ref": "RoutineReference",
+          "description": "The DDL target routine. Present only for CREATE/DROP FUNCTION/PROCEDURE queries."
+        },
+        "ddlTargetRowAccessPolicy": {
+          "$ref": "RowAccessPolicyReference",
+          "description": "[Output-only] [Preview] The DDL target row access policy. Present only for CREATE/DROP ROW ACCESS POLICY queries."
+        },
+        "ddlTargetTable": {
+          "$ref": "TableReference",
+          "description": "[Output-only] The DDL target table. Present only for CREATE/DROP TABLE/VIEW and DROP ALL ROW ACCESS POLICIES queries."
+        },
+        "estimatedBytesProcessed": {
+          "description": "[Output-only] The original estimate of bytes processed for the job.",
+          "format": "int64",
+          "type": "string"
+        },
+        "modelTraining": {
+          "$ref": "BigQueryModelTraining",
+          "description": "[Output-only, Beta] Information about create model query job progress."
+        },
+        "modelTrainingCurrentIteration": {
+          "description": "[Output-only, Beta] Deprecated; do not use.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "modelTrainingExpectedTotalIteration": {
+          "description": "[Output-only, Beta] Deprecated; do not use.",
+          "format": "int64",
+          "type": "string"
+        },
+        "numDmlAffectedRows": {
+          "description": "[Output-only] The number of rows affected by a DML statement. Present only for DML statements INSERT, UPDATE or DELETE.",
+          "format": "int64",
+          "type": "string"
+        },
+        "queryPlan": {
+          "description": "[Output-only] Describes execution plan for the query.",
+          "items": {
+            "$ref": "ExplainQueryStage"
+          },
+          "type": "array"
+        },
+        "referencedRoutines": {
+          "description": "[Output-only] Referenced routines (persistent user-defined functions and stored procedures) for the job.",
+          "items": {
+            "$ref": "RoutineReference"
+          },
+          "type": "array"
+        },
+        "referencedTables": {
+          "description": "[Output-only] Referenced tables for the job. Queries that reference more than 50 tables will not have a complete list.",
+          "items": {
+            "$ref": "TableReference"
+          },
+          "type": "array"
+        },
+        "reservationUsage": {
+          "description": "[Output-only] Job resource usage breakdown by reservation.",
+          "items": {
+            "properties": {
+              "name": {
+                "description": "[Output-only] Reservation name or \"unreserved\" for on-demand resources usage.",
+                "type": "string"
+              },
+              "slotMs": {
+                "description": "[Output-only] Slot-milliseconds the job spent in the given reservation.",
+                "format": "int64",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "schema": {
+          "$ref": "TableSchema",
+          "description": "[Output-only] The schema of the results. Present only for successful dry run of non-legacy SQL queries."
+        },
+        "statementType": {
+          "description": "The type of query statement, if valid. Possible values (new values might be added in the future): \"SELECT\": SELECT query. \"INSERT\": INSERT query; see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-manipulation-language. \"UPDATE\": UPDATE query; see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-manipulation-language. \"DELETE\": DELETE query; see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-manipulation-language. \"MERGE\": MERGE query; see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-manipulation-language. \"ALTER_TABLE\": ALTER TABLE query. \"ALTER_VIEW\": ALTER VIEW query. \"ASSERT\": ASSERT condition AS 'description'. \"CREATE_FUNCTION\": CREATE FUNCTION query. \"CREATE_MODEL\": CREATE [OR REPLACE] MODEL ... AS SELECT ... . \"CREATE_PROCEDURE\": CREATE PROCEDURE query. \"CREATE_TABLE\": CREATE [OR REPLACE] TABLE without AS SELECT. \"CREATE_TABLE_AS_SELECT\": CREATE [OR REPLACE] TABLE ... AS SELECT ... . \"CREATE_VIEW\": CREATE [OR REPLACE] VIEW ... AS SELECT ... . \"DROP_FUNCTION\" : DROP FUNCTION query. \"DROP_PROCEDURE\": DROP PROCEDURE query. \"DROP_TABLE\": DROP TABLE query. \"DROP_VIEW\": DROP VIEW query.",
+          "type": "string"
+        },
+        "timeline": {
+          "description": "[Output-only] [Beta] Describes a timeline of job execution.",
+          "items": {
+            "$ref": "QueryTimelineSample"
+          },
+          "type": "array"
+        },
+        "totalBytesBilled": {
+          "description": "[Output-only] Total bytes billed for the job.",
+          "format": "int64",
+          "type": "string"
+        },
+        "totalBytesProcessed": {
+          "description": "[Output-only] Total bytes processed for the job.",
+          "format": "int64",
+          "type": "string"
+        },
+        "totalBytesProcessedAccuracy": {
+          "description": "[Output-only] For dry-run jobs, totalBytesProcessed is an estimate and this field specifies the accuracy of the estimate. Possible values can be: UNKNOWN: accuracy of the estimate is unknown. PRECISE: estimate is precise. LOWER_BOUND: estimate is lower bound of what the query would cost. UPPER_BOUND: estimate is upper bound of what the query would cost.",
+          "type": "string"
+        },
+        "totalPartitionsProcessed": {
+          "description": "[Output-only] Total number of partitions processed from all partitioned tables referenced in the job.",
+          "format": "int64",
+          "type": "string"
+        },
+        "totalSlotMs": {
+          "description": "[Output-only] Slot-milliseconds for the job.",
+          "format": "int64",
+          "type": "string"
+        },
+        "undeclaredQueryParameters": {
+          "description": "Standard SQL only: list of undeclared query parameters detected during a dry run validation.",
+          "items": {
+            "$ref": "QueryParameter"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "JobStatistics3": {
+      "id": "JobStatistics3",
+      "properties": {
+        "badRecords": {
+          "description": "[Output-only] The number of bad records encountered. Note that if the job has failed because of more bad records encountered than the maximum allowed in the load job configuration, then this number can be less than the total number of bad records present in the input data.",
+          "format": "int64",
+          "type": "string"
+        },
+        "inputFileBytes": {
+          "description": "[Output-only] Number of bytes of source data in a load job.",
+          "format": "int64",
+          "type": "string"
+        },
+        "inputFiles": {
+          "description": "[Output-only] Number of source files in a load job.",
+          "format": "int64",
+          "type": "string"
+        },
+        "outputBytes": {
+          "description": "[Output-only] Size of the loaded data in bytes. Note that while a load job is in the running state, this value may change.",
+          "format": "int64",
+          "type": "string"
+        },
+        "outputRows": {
+          "description": "[Output-only] Number of rows imported in a load job. Note that while an import job is in the running state, this value may change.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "JobStatistics4": {
+      "id": "JobStatistics4",
+      "properties": {
+        "destinationUriFileCounts": {
+          "description": "[Output-only] Number of files per destination URI or URI pattern specified in the extract configuration. These values will be in the same order as the URIs specified in the 'destinationUris' field.",
+          "items": {
+            "format": "int64",
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "inputBytes": {
+          "description": "[Output-only] Number of user bytes extracted into the result. This is the byte count as computed by BigQuery for billing purposes.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "JobStatus": {
+      "id": "JobStatus",
+      "properties": {
+        "errorResult": {
+          "$ref": "ErrorProto",
+          "description": "[Output-only] Final error result of the job. If present, indicates that the job has completed and was unsuccessful."
+        },
+        "errors": {
+          "description": "[Output-only] The first errors encountered during the running of the job. The final message includes the number of errors that caused the process to stop. Errors here do not necessarily mean that the job has completed or was unsuccessful.",
+          "items": {
+            "$ref": "ErrorProto"
+          },
+          "type": "array"
+        },
+        "state": {
+          "description": "[Output-only] Running state of the job.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "JsonObject": {
+      "additionalProperties": {
+        "$ref": "JsonValue"
+      },
+      "description": "Represents a single JSON object.",
+      "id": "JsonObject",
+      "type": "object"
+    },
+    "JsonValue": {
+      "id": "JsonValue",
+      "type": "any"
+    },
+    "ListModelsResponse": {
+      "id": "ListModelsResponse",
+      "properties": {
+        "models": {
+          "description": "Models in the requested dataset. Only the following fields are populated: model_reference, model_type, creation_time, last_modified_time and labels.",
+          "items": {
+            "$ref": "Model"
+          },
+          "type": "array"
+        },
+        "nextPageToken": {
+          "description": "A token to request the next page of results.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ListRoutinesResponse": {
+      "id": "ListRoutinesResponse",
+      "properties": {
+        "nextPageToken": {
+          "description": "A token to request the next page of results.",
+          "type": "string"
+        },
+        "routines": {
+          "description": "Routines in the requested dataset. Unless read_mask is set in the request, only the following fields are populated: etag, project_id, dataset_id, routine_id, routine_type, creation_time, last_modified_time, and language.",
+          "items": {
+            "$ref": "Routine"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ListRowAccessPoliciesResponse": {
+      "description": "Response message for the ListRowAccessPolicies method.",
+      "id": "ListRowAccessPoliciesResponse",
+      "properties": {
+        "nextPageToken": {
+          "description": "A token to request the next page of results.",
+          "type": "string"
+        },
+        "rowAccessPolicies": {
+          "description": "Row access policies on the requested table.",
+          "items": {
+            "$ref": "RowAccessPolicy"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "LocationMetadata": {
+      "description": "BigQuery-specific metadata about a location. This will be set on google.cloud.location.Location.metadata in Cloud Location API responses.",
+      "id": "LocationMetadata",
+      "properties": {
+        "legacyLocationId": {
+          "description": "The legacy BigQuery location ID, e.g. \u201cEU\u201d for the \u201ceurope\u201d location. This is for any API consumers that need the legacy \u201cUS\u201d and \u201cEU\u201d locations.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "MaterializedViewDefinition": {
+      "id": "MaterializedViewDefinition",
+      "properties": {
+        "enableRefresh": {
+          "description": "[Optional] [TrustedTester] Enable automatic refresh of the materialized view when the base table is updated. The default value is \"true\".",
+          "type": "boolean"
+        },
+        "lastRefreshTime": {
+          "description": "[Output-only] [TrustedTester] The time when this materialized view was last modified, in milliseconds since the epoch.",
+          "format": "int64",
+          "type": "string"
+        },
+        "query": {
+          "description": "[Required] A query whose result is persisted.",
+          "type": "string"
+        },
+        "refreshIntervalMs": {
+          "description": "[Optional] [TrustedTester] The maximum frequency at which this materialized view will be refreshed. The default value is \"1800000\" (30 minutes).",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Model": {
+      "id": "Model",
+      "properties": {
+        "bestTrialId": {
+          "description": "The best trial_id across all training runs.",
+          "format": "int64",
+          "type": "string"
+        },
+        "creationTime": {
+          "description": "Output only. The time when this model was created, in millisecs since the epoch.",
+          "format": "int64",
+          "readOnly": true,
+          "type": "string"
+        },
+        "description": {
+          "description": "Optional. A user-friendly description of this model.",
+          "type": "string"
+        },
+        "encryptionConfiguration": {
+          "$ref": "EncryptionConfiguration",
+          "description": "Custom encryption configuration (e.g., Cloud KMS keys). This shows the encryption configuration of the model data while stored in BigQuery storage. This field can be used with PatchModel to update encryption key for an already encrypted model."
+        },
+        "etag": {
+          "description": "Output only. A hash of this resource.",
+          "readOnly": true,
+          "type": "string"
+        },
+        "expirationTime": {
+          "description": "Optional. The time when this model expires, in milliseconds since the epoch. If not present, the model will persist indefinitely. Expired models will be deleted and their storage reclaimed. The defaultTableExpirationMs property of the encapsulating dataset can be used to set a default expirationTime on newly created models.",
+          "format": "int64",
+          "type": "string"
+        },
+        "featureColumns": {
+          "description": "Output only. Input feature columns that were used to train this model.",
+          "items": {
+            "$ref": "StandardSqlField"
+          },
+          "readOnly": true,
+          "type": "array"
+        },
+        "friendlyName": {
+          "description": "Optional. A descriptive name for this model.",
+          "type": "string"
+        },
+        "labelColumns": {
+          "description": "Output only. Label columns that were used to train this model. The output of the model will have a \"predicted_\" prefix to these columns.",
+          "items": {
+            "$ref": "StandardSqlField"
+          },
+          "readOnly": true,
+          "type": "array"
+        },
+        "labels": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "The labels associated with this model. You can use these to organize and group your models. Label keys and values can be no longer than 63 characters, can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. Label values are optional. Label keys must start with a letter and each label in the list must have a different key.",
+          "type": "object"
+        },
+        "lastModifiedTime": {
+          "description": "Output only. The time when this model was last modified, in millisecs since the epoch.",
+          "format": "int64",
+          "readOnly": true,
+          "type": "string"
+        },
+        "location": {
+          "description": "Output only. The geographic location where the model resides. This value is inherited from the dataset.",
+          "readOnly": true,
+          "type": "string"
+        },
+        "modelReference": {
+          "$ref": "ModelReference",
+          "description": "Required. Unique identifier for this model."
+        },
+        "modelType": {
+          "description": "Output only. Type of the model resource.",
+          "enum": [
+            "MODEL_TYPE_UNSPECIFIED",
+            "LINEAR_REGRESSION",
+            "LOGISTIC_REGRESSION",
+            "KMEANS",
+            "MATRIX_FACTORIZATION",
+            "DNN_CLASSIFIER",
+            "TENSORFLOW",
+            "DNN_REGRESSOR",
+            "BOOSTED_TREE_REGRESSOR",
+            "BOOSTED_TREE_CLASSIFIER",
+            "ARIMA",
+            "AUTOML_REGRESSOR",
+            "AUTOML_CLASSIFIER",
+            "ARIMA_PLUS"
+          ],
+          "enumDescriptions": [
+            "",
+            "Linear regression model.",
+            "Logistic regression based classification model.",
+            "K-means clustering model.",
+            "Matrix factorization model.",
+            "DNN classifier model.",
+            "An imported TensorFlow model.",
+            "DNN regressor model.",
+            "Boosted tree regressor model.",
+            "Boosted tree classifier model.",
+            "ARIMA model.",
+            "[Beta] AutoML Tables regression model.",
+            "[Beta] AutoML Tables classification model.",
+            "New name for the ARIMA model."
+          ],
+          "readOnly": true,
+          "type": "string"
+        },
+        "trainingRuns": {
+          "description": "Output only. Information for all training runs in increasing order of start_time.",
+          "items": {
+            "$ref": "TrainingRun"
+          },
+          "readOnly": true,
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ModelDefinition": {
+      "id": "ModelDefinition",
+      "properties": {
+        "modelOptions": {
+          "description": "[Output-only, Beta] Model options used for the first training run. These options are immutable for subsequent training runs. Default values are used for any options not specified in the input query.",
+          "properties": {
+            "labels": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "lossType": {
+              "type": "string"
+            },
+            "modelType": {
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "trainingRuns": {
+          "description": "[Output-only, Beta] Information about ml training runs, each training run comprises of multiple iterations and there may be multiple training runs for the model if warm start is used or if a user decides to continue a previously cancelled query.",
+          "items": {
+            "$ref": "BqmlTrainingRun"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ModelReference": {
+      "id": "ModelReference",
+      "properties": {
+        "datasetId": {
+          "description": "[Required] The ID of the dataset containing this model.",
+          "type": "string"
+        },
+        "modelId": {
+          "description": "[Required] The ID of the model. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 1,024 characters.",
+          "type": "string"
+        },
+        "projectId": {
+          "description": "[Required] The ID of the project containing this model.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "MultiClassClassificationMetrics": {
+      "description": "Evaluation metrics for multi-class classification/classifier models.",
+      "id": "MultiClassClassificationMetrics",
+      "properties": {
+        "aggregateClassificationMetrics": {
+          "$ref": "AggregateClassificationMetrics",
+          "description": "Aggregate classification metrics."
+        },
+        "confusionMatrixList": {
+          "description": "Confusion matrix at different thresholds.",
+          "items": {
+            "$ref": "ConfusionMatrix"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "ParquetOptions": {
+      "id": "ParquetOptions",
+      "properties": {
+        "enableListInference": {
+          "description": "[Optional] Indicates whether to use schema inference specifically for Parquet LIST logical type.",
+          "type": "boolean"
+        },
+        "enumAsString": {
+          "description": "[Optional] Indicates whether to infer Parquet ENUM logical type as STRING instead of BYTES by default.",
+          "type": "boolean"
+        }
+      },
+      "type": "object"
+    },
+    "Policy": {
+      "description": "An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members` to a single `role`. Members can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** { \"bindings\": [ { \"role\": \"roles/resourcemanager.organizationAdmin\", \"members\": [ \"user:mike@example.com\", \"group:admins@example.com\", \"domain:google.com\", \"serviceAccount:my-project-id@appspot.gserviceaccount.com\" ] }, { \"role\": \"roles/resourcemanager.organizationViewer\", \"members\": [ \"user:eve@example.com\" ], \"condition\": { \"title\": \"expirable access\", \"description\": \"Does not grant access after Sep 2020\", \"expression\": \"request.time < timestamp('2020-10-01T00:00:00.000Z')\", } } ], \"etag\": \"BwWWja0YfJA=\", \"version\": 3 } **YAML example:** bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') - etag: BwWWja0YfJA= - version: 3 For a description of IAM and its features, see the [IAM documentation](https://cloud.google.com/iam/docs/).",
+      "id": "Policy",
+      "properties": {
+        "auditConfigs": {
+          "description": "Specifies cloud audit logging configuration for this policy.",
+          "items": {
+            "$ref": "AuditConfig"
+          },
+          "type": "array"
+        },
+        "bindings": {
+          "description": "Associates a list of `members` to a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one member.",
+          "items": {
+            "$ref": "Binding"
+          },
+          "type": "array"
+        },
+        "etag": {
+          "description": "`etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.",
+          "format": "byte",
+          "type": "string"
+        },
+        "version": {
+          "description": "Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).",
+          "format": "int32",
+          "type": "integer"
+        }
+      },
+      "type": "object"
+    },
+    "ProjectList": {
+      "id": "ProjectList",
+      "properties": {
+        "etag": {
+          "description": "A hash of the page of results",
+          "type": "string"
+        },
+        "kind": {
+          "default": "bigquery#projectList",
+          "description": "The type of list.",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "A token to request the next page of results.",
+          "type": "string"
+        },
+        "projects": {
+          "description": "Projects to which you have at least READ access.",
+          "items": {
+            "properties": {
+              "friendlyName": {
+                "description": "A descriptive name for this project.",
+                "type": "string"
+              },
+              "id": {
+                "description": "An opaque ID of this project.",
+                "type": "string"
+              },
+              "kind": {
+                "default": "bigquery#project",
+                "description": "The resource type.",
+                "type": "string"
+              },
+              "numericId": {
+                "description": "The numeric ID of this project.",
+                "format": "uint64",
+                "type": "string"
+              },
+              "projectReference": {
+                "$ref": "ProjectReference",
+                "description": "A unique reference to this project."
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "totalItems": {
+          "description": "The total number of projects in the list.",
+          "format": "int32",
+          "type": "integer"
+        }
+      },
+      "type": "object"
+    },
+    "ProjectReference": {
+      "id": "ProjectReference",
+      "properties": {
+        "projectId": {
+          "description": "[Required] ID of the project. Can be either the numeric ID or the assigned ID of the project.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "QueryParameter": {
+      "id": "QueryParameter",
+      "properties": {
+        "name": {
+          "description": "[Optional] If unset, this is a positional parameter. Otherwise, should be unique within a query.",
+          "type": "string"
+        },
+        "parameterType": {
+          "$ref": "QueryParameterType",
+          "description": "[Required] The type of this parameter."
+        },
+        "parameterValue": {
+          "$ref": "QueryParameterValue",
+          "description": "[Required] The value of this parameter."
+        }
+      },
+      "type": "object"
+    },
+    "QueryParameterType": {
+      "id": "QueryParameterType",
+      "properties": {
+        "arrayType": {
+          "$ref": "QueryParameterType",
+          "description": "[Optional] The type of the array's elements, if this is an array."
+        },
+        "structTypes": {
+          "description": "[Optional] The types of the fields of this struct, in order, if this is a struct.",
+          "items": {
+            "properties": {
+              "description": {
+                "description": "[Optional] Human-oriented description of the field.",
+                "type": "string"
+              },
+              "name": {
+                "description": "[Optional] The name of this field.",
+                "type": "string"
+              },
+              "type": {
+                "$ref": "QueryParameterType",
+                "description": "[Required] The type of this field."
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "type": {
+          "description": "[Required] The top level type of this field.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "QueryParameterValue": {
+      "id": "QueryParameterValue",
+      "properties": {
+        "arrayValues": {
+          "description": "[Optional] The array values, if this is an array type.",
+          "items": {
+            "$ref": "QueryParameterValue"
+          },
+          "type": "array"
+        },
+        "structValues": {
+          "additionalProperties": {
+            "$ref": "QueryParameterValue"
+          },
+          "description": "[Optional] The struct field values, in order of the struct type's declaration.",
+          "type": "object"
+        },
+        "value": {
+          "description": "[Optional] The value of this value, if a simple scalar type.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "QueryRequest": {
+      "id": "QueryRequest",
+      "properties": {
+        "connectionProperties": {
+          "description": "Connection properties.",
+          "items": {
+            "$ref": "ConnectionProperty"
+          },
+          "type": "array"
+        },
+        "createSession": {
+          "description": "If true, creates a new session, where session id will be a server generated random id. If false, runs query with an existing session_id passed in ConnectionProperty, otherwise runs query in non-session mode.",
+          "type": "boolean"
+        },
+        "defaultDataset": {
+          "$ref": "DatasetReference",
+          "description": "[Optional] Specifies the default datasetId and projectId to assume for any unqualified table names in the query. If not set, all table names in the query string must be qualified in the format 'datasetId.tableId'."
+        },
+        "dryRun": {
+          "description": "[Optional] If set to true, BigQuery doesn't run the job. Instead, if the query is valid, BigQuery returns statistics about the job such as how many bytes would be processed. If the query is invalid, an error returns. The default value is false.",
+          "type": "boolean"
+        },
+        "kind": {
+          "default": "bigquery#queryRequest",
+          "description": "The resource type of the request.",
+          "type": "string"
+        },
+        "labels": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "The labels associated with this job. You can use these to organize and group your jobs. Label keys and values can be no longer than 63 characters, can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. Label values are optional. Label keys must start with a letter and each label in the list must have a different key.",
+          "type": "object"
+        },
+        "location": {
+          "description": "The geographic location where the job should run. See details at https://cloud.google.com/bigquery/docs/locations#specifying_your_location.",
+          "type": "string"
+        },
+        "maxResults": {
+          "description": "[Optional] The maximum number of rows of data to return per page of results. Setting this flag to a small value such as 1000 and then paging through results might improve reliability when the query result set is large. In addition to this limit, responses are also limited to 10 MB. By default, there is no maximum row count, and only the byte limit applies.",
+          "format": "uint32",
+          "type": "integer"
+        },
+        "maximumBytesBilled": {
+          "description": "[Optional] Limits the bytes billed for this job. Queries that will have bytes billed beyond this limit will fail (without incurring a charge). If unspecified, this will be set to your project default.",
+          "format": "int64",
+          "type": "string"
+        },
+        "parameterMode": {
+          "description": "Standard SQL only. Set to POSITIONAL to use positional (?) query parameters or to NAMED to use named (@myparam) query parameters in this query.",
+          "type": "string"
+        },
+        "preserveNulls": {
+          "description": "[Deprecated] This property is deprecated.",
+          "type": "boolean"
+        },
+        "query": {
+          "annotations": {
+            "required": [
+              "bigquery.jobs.query"
+            ]
+          },
+          "description": "[Required] A query string, following the BigQuery query syntax, of the query to execute. Example: \"SELECT count(f1) FROM [myProjectId:myDatasetId.myTableId]\".",
+          "type": "string"
+        },
+        "queryParameters": {
+          "description": "Query parameters for Standard SQL queries.",
+          "items": {
+            "$ref": "QueryParameter"
+          },
+          "type": "array"
+        },
+        "requestId": {
+          "description": "A unique user provided identifier to ensure idempotent behavior for queries. Note that this is different from the job_id. It has the following properties: 1. It is case-sensitive, limited to up to 36 ASCII characters. A UUID is recommended. 2. Read only queries can ignore this token since they are nullipotent by definition. 3. For the purposes of idempotency ensured by the request_id, a request is considered duplicate of another only if they have the same request_id and are actually duplicates. When determining whether a request is a duplicate of the previous request, all parameters in the request that may affect the behavior are considered. For example, query, connection_properties, query_parameters, use_legacy_sql are parameters that affect the result and are considered when determining whether a request is a duplicate, but properties like timeout_ms don't affect the result and are thus not considered. Dry run query requests are never considered duplicate of another request. 4. When a duplicate mutating query request is detected, it returns: a. the results of the mutation if it completes successfully within the timeout. b. the running operation if it is still in progress at the end of the timeout. 5. Its lifetime is limited to 15 minutes. In other words, if two requests are sent with the same request_id, but more than 15 minutes apart, idempotency is not guaranteed.",
+          "type": "string"
+        },
+        "timeoutMs": {
+          "description": "[Optional] How long to wait for the query to complete, in milliseconds, before the request times out and returns. Note that this is only a timeout for the request, not the query. If the query takes longer to run than the timeout value, the call returns without any results and with the 'jobComplete' flag set to false. You can call GetQueryResults() to wait for the query to complete and read the results. The default value is 10000 milliseconds (10 seconds).",
+          "format": "uint32",
+          "type": "integer"
+        },
+        "useLegacySql": {
+          "default": "true",
+          "description": "Specifies whether to use BigQuery's legacy SQL dialect for this query. The default value is true. If set to false, the query will use BigQuery's standard SQL: https://cloud.google.com/bigquery/sql-reference/ When useLegacySql is set to false, the value of flattenResults is ignored; query will be run as if flattenResults is false.",
+          "type": "boolean"
+        },
+        "useQueryCache": {
+          "default": "true",
+          "description": "[Optional] Whether to look for the result in the query cache. The query cache is a best-effort cache that will be flushed whenever tables in the query are modified. The default value is true.",
+          "type": "boolean"
+        }
+      },
+      "type": "object"
+    },
+    "QueryResponse": {
+      "id": "QueryResponse",
+      "properties": {
+        "cacheHit": {
+          "description": "Whether the query result was fetched from the query cache.",
+          "type": "boolean"
+        },
+        "errors": {
+          "description": "[Output-only] The first errors or warnings encountered during the running of the job. The final message includes the number of errors that caused the process to stop. Errors here do not necessarily mean that the job has completed or was unsuccessful.",
+          "items": {
+            "$ref": "ErrorProto"
+          },
+          "type": "array"
+        },
+        "jobComplete": {
+          "description": "Whether the query has completed or not. If rows or totalRows are present, this will always be true. If this is false, totalRows will not be available.",
+          "type": "boolean"
+        },
+        "jobReference": {
+          "$ref": "JobReference",
+          "description": "Reference to the Job that was created to run the query. This field will be present even if the original request timed out, in which case GetQueryResults can be used to read the results once the query has completed. Since this API only returns the first page of results, subsequent pages can be fetched via the same mechanism (GetQueryResults)."
+        },
+        "kind": {
+          "default": "bigquery#queryResponse",
+          "description": "The resource type.",
+          "type": "string"
+        },
+        "numDmlAffectedRows": {
+          "description": "[Output-only] The number of rows affected by a DML statement. Present only for DML statements INSERT, UPDATE or DELETE.",
+          "format": "int64",
+          "type": "string"
+        },
+        "pageToken": {
+          "description": "A token used for paging results.",
+          "type": "string"
+        },
+        "rows": {
+          "description": "An object with as many results as can be contained within the maximum permitted reply size. To get any additional rows, you can call GetQueryResults and specify the jobReference returned above.",
+          "items": {
+            "$ref": "TableRow"
+          },
+          "type": "array"
+        },
+        "schema": {
+          "$ref": "TableSchema",
+          "description": "The schema of the results. Present only when the query completes successfully."
+        },
+        "sessionInfoTemplate": {
+          "$ref": "SessionInfo",
+          "description": "[Output-only] [Preview] Information of the session if this job is part of one."
+        },
+        "totalBytesProcessed": {
+          "description": "The total number of bytes processed for this query. If this query was a dry run, this is the number of bytes that would be processed if the query were run.",
+          "format": "int64",
+          "type": "string"
+        },
+        "totalRows": {
+          "description": "The total number of rows in the complete query result set, which can be more than the number of rows in this single page of results.",
+          "format": "uint64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "QueryTimelineSample": {
+      "id": "QueryTimelineSample",
+      "properties": {
+        "activeUnits": {
+          "description": "Total number of units currently being processed by workers. This does not correspond directly to slot usage. This is the largest value observed since the last sample.",
+          "format": "int64",
+          "type": "string"
+        },
+        "completedUnits": {
+          "description": "Total parallel units of work completed by this query.",
+          "format": "int64",
+          "type": "string"
+        },
+        "elapsedMs": {
+          "description": "Milliseconds elapsed since the start of query execution.",
+          "format": "int64",
+          "type": "string"
+        },
+        "pendingUnits": {
+          "description": "Total parallel units of work remaining for the active stages.",
+          "format": "int64",
+          "type": "string"
+        },
+        "totalSlotMs": {
+          "description": "Cumulative slot-ms consumed by the query.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "RangePartitioning": {
+      "id": "RangePartitioning",
+      "properties": {
+        "field": {
+          "description": "[TrustedTester] [Required] The table is partitioned by this field. The field must be a top-level NULLABLE/REQUIRED field. The only supported type is INTEGER/INT64.",
+          "type": "string"
+        },
+        "range": {
+          "description": "[TrustedTester] [Required] Defines the ranges for range partitioning.",
+          "properties": {
+            "end": {
+              "description": "[TrustedTester] [Required] The end of range partitioning, exclusive.",
+              "format": "int64",
+              "type": "string"
+            },
+            "interval": {
+              "description": "[TrustedTester] [Required] The width of each interval.",
+              "format": "int64",
+              "type": "string"
+            },
+            "start": {
+              "description": "[TrustedTester] [Required] The start of range partitioning, inclusive.",
+              "format": "int64",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        }
+      },
+      "type": "object"
+    },
+    "RankingMetrics": {
+      "description": "Evaluation metrics used by weighted-ALS models specified by feedback_type=implicit.",
+      "id": "RankingMetrics",
+      "properties": {
+        "averageRank": {
+          "description": "Determines the goodness of a ranking by computing the percentile rank from the predicted confidence and dividing it by the original rank.",
+          "format": "double",
+          "type": "number"
+        },
+        "meanAveragePrecision": {
+          "description": "Calculates a precision per user for all the items by ranking them and then averages all the precisions across all the users.",
+          "format": "double",
+          "type": "number"
+        },
+        "meanSquaredError": {
+          "description": "Similar to the mean squared error computed in regression and explicit recommendation models except instead of computing the rating directly, the output from evaluate is computed against a preference which is 1 or 0 depending on if the rating exists or not.",
+          "format": "double",
+          "type": "number"
+        },
+        "normalizedDiscountedCumulativeGain": {
+          "description": "A metric to determine the goodness of a ranking calculated from the predicted confidence by comparing it to an ideal rank measured by the original ratings.",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "RegressionMetrics": {
+      "description": "Evaluation metrics for regression and explicit feedback type matrix factorization models.",
+      "id": "RegressionMetrics",
+      "properties": {
+        "meanAbsoluteError": {
+          "description": "Mean absolute error.",
+          "format": "double",
+          "type": "number"
+        },
+        "meanSquaredError": {
+          "description": "Mean squared error.",
+          "format": "double",
+          "type": "number"
+        },
+        "meanSquaredLogError": {
+          "description": "Mean squared log error.",
+          "format": "double",
+          "type": "number"
+        },
+        "medianAbsoluteError": {
+          "description": "Median absolute error.",
+          "format": "double",
+          "type": "number"
+        },
+        "rSquared": {
+          "description": "R^2 score. This corresponds to r2_score in ML.EVALUATE.",
+          "format": "double",
+          "type": "number"
+        }
+      },
+      "type": "object"
+    },
+    "Routine": {
+      "description": "A user-defined function or a stored procedure.",
+      "id": "Routine",
+      "properties": {
+        "arguments": {
+          "description": "Optional.",
+          "items": {
+            "$ref": "Argument"
+          },
+          "type": "array"
+        },
+        "creationTime": {
+          "description": "Output only. The time when this routine was created, in milliseconds since the epoch.",
+          "format": "int64",
+          "readOnly": true,
+          "type": "string"
+        },
+        "definitionBody": {
+          "description": "Required. The body of the routine. For functions, this is the expression in the AS clause. If language=SQL, it is the substring inside (but excluding) the parentheses. For example, for the function created with the following statement: `CREATE FUNCTION JoinLines(x string, y string) as (concat(x, \"\\n\", y))` The definition_body is `concat(x, \"\\n\", y)` (\\n is not replaced with linebreak). If language=JAVASCRIPT, it is the evaluated string in the AS clause. For example, for the function created with the following statement: `CREATE FUNCTION f() RETURNS STRING LANGUAGE js AS 'return \"\\n\";\\n'` The definition_body is `return \"\\n\";\\n` Note that both \\n are replaced with linebreaks.",
+          "type": "string"
+        },
+        "description": {
+          "description": "Optional. [Experimental] The description of the routine if defined.",
+          "type": "string"
+        },
+        "determinismLevel": {
+          "description": "Optional. [Experimental] The determinism level of the JavaScript UDF if defined.",
+          "enum": [
+            "DETERMINISM_LEVEL_UNSPECIFIED",
+            "DETERMINISTIC",
+            "NOT_DETERMINISTIC"
+          ],
+          "enumDescriptions": [
+            "The determinism of the UDF is unspecified.",
+            "The UDF is deterministic, meaning that 2 function calls with the same inputs always produce the same result, even across 2 query runs.",
+            "The UDF is not deterministic."
+          ],
+          "type": "string"
+        },
+        "etag": {
+          "description": "Output only. A hash of this resource.",
+          "readOnly": true,
+          "type": "string"
+        },
+        "importedLibraries": {
+          "description": "Optional. If language = \"JAVASCRIPT\", this field stores the path of the imported JAVASCRIPT libraries.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "language": {
+          "description": "Optional. Defaults to \"SQL\".",
+          "enum": [
+            "LANGUAGE_UNSPECIFIED",
+            "SQL",
+            "JAVASCRIPT"
+          ],
+          "enumDescriptions": [
+            "",
+            "SQL language.",
+            "JavaScript language."
+          ],
+          "type": "string"
+        },
+        "lastModifiedTime": {
+          "description": "Output only. The time when this routine was last modified, in milliseconds since the epoch.",
+          "format": "int64",
+          "readOnly": true,
+          "type": "string"
+        },
+        "returnTableType": {
+          "$ref": "StandardSqlTableType",
+          "description": "Optional. Set only if Routine is a \"TABLE_VALUED_FUNCTION\"."
+        },
+        "returnType": {
+          "$ref": "StandardSqlDataType",
+          "description": "Optional if language = \"SQL\"; required otherwise. If absent, the return type is inferred from definition_body at query time in each query that references this routine. If present, then the evaluated result will be cast to the specified returned type at query time. For example, for the functions created with the following statements: * `CREATE FUNCTION Add(x FLOAT64, y FLOAT64) RETURNS FLOAT64 AS (x + y);` * `CREATE FUNCTION Increment(x FLOAT64) AS (Add(x, 1));` * `CREATE FUNCTION Decrement(x FLOAT64) RETURNS FLOAT64 AS (Add(x, -1));` The return_type is `{type_kind: \"FLOAT64\"}` for `Add` and `Decrement`, and is absent for `Increment` (inferred as FLOAT64 at query time). Suppose the function `Add` is replaced by `CREATE OR REPLACE FUNCTION Add(x INT64, y INT64) AS (x + y);` Then the inferred return type of `Increment` is automatically changed to INT64 at query time, while the return type of `Decrement` remains FLOAT64."
+        },
+        "routineReference": {
+          "$ref": "RoutineReference",
+          "description": "Required. Reference describing the ID of this routine."
+        },
+        "routineType": {
+          "description": "Required. The type of routine.",
+          "enum": [
+            "ROUTINE_TYPE_UNSPECIFIED",
+            "SCALAR_FUNCTION",
+            "PROCEDURE",
+            "TABLE_VALUED_FUNCTION"
+          ],
+          "enumDescriptions": [
+            "",
+            "Non-builtin permanent scalar function.",
+            "Stored procedure.",
+            "Non-builtin permanent TVF."
+          ],
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "RoutineReference": {
+      "id": "RoutineReference",
+      "properties": {
+        "datasetId": {
+          "description": "[Required] The ID of the dataset containing this routine.",
+          "type": "string"
+        },
+        "projectId": {
+          "description": "[Required] The ID of the project containing this routine.",
+          "type": "string"
+        },
+        "routineId": {
+          "description": "[Required] The ID of the routine. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 256 characters.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Row": {
+      "description": "A single row in the confusion matrix.",
+      "id": "Row",
+      "properties": {
+        "actualLabel": {
+          "description": "The original label of this row.",
+          "type": "string"
+        },
+        "entries": {
+          "description": "Info describing predicted label distribution.",
+          "items": {
+            "$ref": "Entry"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "RowAccessPolicy": {
+      "description": "Represents access on a subset of rows on the specified table, defined by its filter predicate. Access to the subset of rows is controlled by its IAM policy.",
+      "id": "RowAccessPolicy",
+      "properties": {
+        "creationTime": {
+          "description": "Output only. The time when this row access policy was created, in milliseconds since the epoch.",
+          "format": "google-datetime",
+          "readOnly": true,
+          "type": "string"
+        },
+        "etag": {
+          "description": "Output only. A hash of this resource.",
+          "readOnly": true,
+          "type": "string"
+        },
+        "filterPredicate": {
+          "description": "Required. A SQL boolean expression that represents the rows defined by this row access policy, similar to the boolean expression in a WHERE clause of a SELECT query on a table. References to other tables, routines, and temporary functions are not supported. Examples: region=\"EU\" date_field = CAST('2019-9-27' as DATE) nullable_field is not NULL numeric_field BETWEEN 1.0 AND 5.0",
+          "type": "string"
+        },
+        "lastModifiedTime": {
+          "description": "Output only. The time when this row access policy was last modified, in milliseconds since the epoch.",
+          "format": "google-datetime",
+          "readOnly": true,
+          "type": "string"
+        },
+        "rowAccessPolicyReference": {
+          "$ref": "RowAccessPolicyReference",
+          "description": "Required. Reference describing the ID of this row access policy."
+        }
+      },
+      "type": "object"
+    },
+    "RowAccessPolicyReference": {
+      "id": "RowAccessPolicyReference",
+      "properties": {
+        "datasetId": {
+          "description": "[Required] The ID of the dataset containing this row access policy.",
+          "type": "string"
+        },
+        "policyId": {
+          "description": "[Required] The ID of the row access policy. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 256 characters.",
+          "type": "string"
+        },
+        "projectId": {
+          "description": "[Required] The ID of the project containing this row access policy.",
+          "type": "string"
+        },
+        "tableId": {
+          "description": "[Required] The ID of the table containing this row access policy.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "RowLevelSecurityStatistics": {
+      "id": "RowLevelSecurityStatistics",
+      "properties": {
+        "rowLevelSecurityApplied": {
+          "description": "[Output-only] [Preview] Whether any accessed data was protected by row access policies.",
+          "type": "boolean"
+        }
+      },
+      "type": "object"
+    },
+    "ScriptStackFrame": {
+      "id": "ScriptStackFrame",
+      "properties": {
+        "endColumn": {
+          "description": "[Output-only] One-based end column.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "endLine": {
+          "description": "[Output-only] One-based end line.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "procedureId": {
+          "description": "[Output-only] Name of the active procedure, empty if in a top-level script.",
+          "type": "string"
+        },
+        "startColumn": {
+          "description": "[Output-only] One-based start column.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "startLine": {
+          "description": "[Output-only] One-based start line.",
+          "format": "int32",
+          "type": "integer"
+        },
+        "text": {
+          "description": "[Output-only] Text of the current statement/expression.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ScriptStatistics": {
+      "id": "ScriptStatistics",
+      "properties": {
+        "evaluationKind": {
+          "description": "[Output-only] Whether this child job was a statement or expression.",
+          "type": "string"
+        },
+        "stackFrames": {
+          "description": "Stack trace showing the line/column/procedure name of each frame on the stack at the point where the current evaluation happened. The leaf frame is first, the primary script is last. Never empty.",
+          "items": {
+            "$ref": "ScriptStackFrame"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "SessionInfo": {
+      "id": "SessionInfo",
+      "properties": {
+        "sessionId": {
+          "description": "[Output-only] // [Preview] Id of the session.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "SetIamPolicyRequest": {
+      "description": "Request message for `SetIamPolicy` method.",
+      "id": "SetIamPolicyRequest",
+      "properties": {
+        "policy": {
+          "$ref": "Policy",
+          "description": "REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Cloud Platform services (such as Projects) might reject them."
+        },
+        "updateMask": {
+          "description": "OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only the fields in the mask will be modified. If no mask is provided, the following default mask is used: `paths: \"bindings, etag\"`",
+          "format": "google-fieldmask",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "SnapshotDefinition": {
+      "id": "SnapshotDefinition",
+      "properties": {
+        "baseTableReference": {
+          "$ref": "TableReference",
+          "description": "[Required] Reference describing the ID of the table that is snapshotted."
+        },
+        "snapshotTime": {
+          "description": "[Required] The time at which the base table was snapshot.",
+          "format": "date-time",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "StandardSqlDataType": {
+      "description": "The type of a variable, e.g., a function argument. Examples: INT64: {type_kind=\"INT64\"} ARRAY: {type_kind=\"ARRAY\", array_element_type=\"STRING\"} STRUCT>: {type_kind=\"STRUCT\", struct_type={fields=[ {name=\"x\", type={type_kind=\"STRING\"}}, {name=\"y\", type={type_kind=\"ARRAY\", array_element_type=\"DATE\"}} ]}}",
+      "id": "StandardSqlDataType",
+      "properties": {
+        "arrayElementType": {
+          "$ref": "StandardSqlDataType",
+          "description": "The type of the array's elements, if type_kind = \"ARRAY\"."
+        },
+        "structType": {
+          "$ref": "StandardSqlStructType",
+          "description": "The fields of this struct, in order, if type_kind = \"STRUCT\"."
+        },
+        "typeKind": {
+          "description": "Required. The top level type of this field. Can be any standard SQL data type (e.g., \"INT64\", \"DATE\", \"ARRAY\").",
+          "enum": [
+            "TYPE_KIND_UNSPECIFIED",
+            "INT64",
+            "BOOL",
+            "FLOAT64",
+            "STRING",
+            "BYTES",
+            "TIMESTAMP",
+            "DATE",
+            "TIME",
+            "DATETIME",
+            "INTERVAL",
+            "GEOGRAPHY",
+            "NUMERIC",
+            "BIGNUMERIC",
+            "ARRAY",
+            "STRUCT"
+          ],
+          "enumDescriptions": [
+            "Invalid type.",
+            "Encoded as a string in decimal format.",
+            "Encoded as a boolean \"false\" or \"true\".",
+            "Encoded as a number, or string \"NaN\", \"Infinity\" or \"-Infinity\".",
+            "Encoded as a string value.",
+            "Encoded as a base64 string per RFC 4648, section 4.",
+            "Encoded as an RFC 3339 timestamp with mandatory \"Z\" time zone string: 1985-04-12T23:20:50.52Z",
+            "Encoded as RFC 3339 full-date format string: 1985-04-12",
+            "Encoded as RFC 3339 partial-time format string: 23:20:50.52",
+            "Encoded as RFC 3339 full-date \"T\" partial-time: 1985-04-12T23:20:50.52",
+            "Encoded as fully qualified 3 part: 0-5 15 2:30:45.6",
+            "Encoded as WKT",
+            "Encoded as a decimal string.",
+            "Encoded as a decimal string.",
+            "Encoded as a list with types matching Type.array_type.",
+            "Encoded as a list with fields of type Type.struct_type[i]. List is used because a JSON object cannot have duplicate field names."
+          ],
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "StandardSqlField": {
+      "description": "A field or a column.",
+      "id": "StandardSqlField",
+      "properties": {
+        "name": {
+          "description": "Optional. The name of this field. Can be absent for struct fields.",
+          "type": "string"
+        },
+        "type": {
+          "$ref": "StandardSqlDataType",
+          "description": "Optional. The type of this parameter. Absent if not explicitly specified (e.g., CREATE FUNCTION statement can omit the return type; in this case the output parameter does not have this \"type\" field)."
+        }
+      },
+      "type": "object"
+    },
+    "StandardSqlStructType": {
+      "id": "StandardSqlStructType",
+      "properties": {
+        "fields": {
+          "items": {
+            "$ref": "StandardSqlField"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "StandardSqlTableType": {
+      "description": "A table type",
+      "id": "StandardSqlTableType",
+      "properties": {
+        "columns": {
+          "description": "The columns in this table type",
+          "items": {
+            "$ref": "StandardSqlField"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "Streamingbuffer": {
+      "id": "Streamingbuffer",
+      "properties": {
+        "estimatedBytes": {
+          "description": "[Output-only] A lower-bound estimate of the number of bytes currently in the streaming buffer.",
+          "format": "uint64",
+          "type": "string"
+        },
+        "estimatedRows": {
+          "description": "[Output-only] A lower-bound estimate of the number of rows currently in the streaming buffer.",
+          "format": "uint64",
+          "type": "string"
+        },
+        "oldestEntryTime": {
+          "description": "[Output-only] Contains the timestamp of the oldest entry in the streaming buffer, in milliseconds since the epoch, if the streaming buffer is available.",
+          "format": "uint64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Table": {
+      "id": "Table",
+      "properties": {
+        "clustering": {
+          "$ref": "Clustering",
+          "description": "[Beta] Clustering specification for the table. Must be specified with partitioning, data in the table will be first partitioned and subsequently clustered."
+        },
+        "creationTime": {
+          "description": "[Output-only] The time when this table was created, in milliseconds since the epoch.",
+          "format": "int64",
+          "type": "string"
+        },
+        "description": {
+          "description": "[Optional] A user-friendly description of this table.",
+          "type": "string"
+        },
+        "encryptionConfiguration": {
+          "$ref": "EncryptionConfiguration",
+          "description": "Custom encryption configuration (e.g., Cloud KMS keys)."
+        },
+        "etag": {
+          "description": "[Output-only] A hash of the table metadata. Used to ensure there were no concurrent modifications to the resource when attempting an update. Not guaranteed to change when the table contents or the fields numRows, numBytes, numLongTermBytes or lastModifiedTime change.",
+          "type": "string"
+        },
+        "expirationTime": {
+          "description": "[Optional] The time when this table expires, in milliseconds since the epoch. If not present, the table will persist indefinitely. Expired tables will be deleted and their storage reclaimed. The defaultTableExpirationMs property of the encapsulating dataset can be used to set a default expirationTime on newly created tables.",
+          "format": "int64",
+          "type": "string"
+        },
+        "externalDataConfiguration": {
+          "$ref": "ExternalDataConfiguration",
+          "description": "[Optional] Describes the data format, location, and other properties of a table stored outside of BigQuery. By defining these properties, the data source can then be queried as if it were a standard BigQuery table."
+        },
+        "friendlyName": {
+          "description": "[Optional] A descriptive name for this table.",
+          "type": "string"
+        },
+        "id": {
+          "description": "[Output-only] An opaque ID uniquely identifying the table.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "bigquery#table",
+          "description": "[Output-only] The type of the resource.",
+          "type": "string"
+        },
+        "labels": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "The labels associated with this table. You can use these to organize and group your tables. Label keys and values can be no longer than 63 characters, can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. Label values are optional. Label keys must start with a letter and each label in the list must have a different key.",
+          "type": "object"
+        },
+        "lastModifiedTime": {
+          "description": "[Output-only] The time when this table was last modified, in milliseconds since the epoch.",
+          "format": "uint64",
+          "type": "string"
+        },
+        "location": {
+          "description": "[Output-only] The geographic location where the table resides. This value is inherited from the dataset.",
+          "type": "string"
+        },
+        "materializedView": {
+          "$ref": "MaterializedViewDefinition",
+          "description": "[Optional] Materialized view definition."
+        },
+        "model": {
+          "$ref": "ModelDefinition",
+          "description": "[Output-only, Beta] Present iff this table represents a ML model. Describes the training information for the model, and it is required to run 'PREDICT' queries."
+        },
+        "numBytes": {
+          "description": "[Output-only] The size of this table in bytes, excluding any data in the streaming buffer.",
+          "format": "int64",
+          "type": "string"
+        },
+        "numLongTermBytes": {
+          "description": "[Output-only] The number of bytes in the table that are considered \"long-term storage\".",
+          "format": "int64",
+          "type": "string"
+        },
+        "numPhysicalBytes": {
+          "description": "[Output-only] [TrustedTester] The physical size of this table in bytes, excluding any data in the streaming buffer. This includes compression and storage used for time travel.",
+          "format": "int64",
+          "type": "string"
+        },
+        "numRows": {
+          "description": "[Output-only] The number of rows of data in this table, excluding any data in the streaming buffer.",
+          "format": "uint64",
+          "type": "string"
+        },
+        "rangePartitioning": {
+          "$ref": "RangePartitioning",
+          "description": "[TrustedTester] Range partitioning specification for this table. Only one of timePartitioning and rangePartitioning should be specified."
+        },
+        "requirePartitionFilter": {
+          "default": "false",
+          "description": "[Optional] If set to true, queries over this table require a partition filter that can be used for partition elimination to be specified.",
+          "type": "boolean"
+        },
+        "schema": {
+          "$ref": "TableSchema",
+          "description": "[Optional] Describes the schema of this table."
+        },
+        "selfLink": {
+          "description": "[Output-only] A URL that can be used to access this resource again.",
+          "type": "string"
+        },
+        "snapshotDefinition": {
+          "$ref": "SnapshotDefinition",
+          "description": "[Output-only] Snapshot definition."
+        },
+        "streamingBuffer": {
+          "$ref": "Streamingbuffer",
+          "description": "[Output-only] Contains information regarding this table's streaming buffer, if one is present. This field will be absent if the table is not being streamed to or if there is no data in the streaming buffer."
+        },
+        "tableReference": {
+          "$ref": "TableReference",
+          "description": "[Required] Reference describing the ID of this table."
+        },
+        "timePartitioning": {
+          "$ref": "TimePartitioning",
+          "description": "Time-based partitioning specification for this table. Only one of timePartitioning and rangePartitioning should be specified."
+        },
+        "type": {
+          "description": "[Output-only] Describes the table type. The following values are supported: TABLE: A normal BigQuery table. VIEW: A virtual table defined by a SQL query. SNAPSHOT: An immutable, read-only table that is a copy of another table. [TrustedTester] MATERIALIZED_VIEW: SQL query whose result is persisted. EXTERNAL: A table that references data stored in an external storage system, such as Google Cloud Storage. The default value is TABLE.",
+          "type": "string"
+        },
+        "view": {
+          "$ref": "ViewDefinition",
+          "description": "[Optional] The view definition."
+        }
+      },
+      "type": "object"
+    },
+    "TableCell": {
+      "id": "TableCell",
+      "properties": {
+        "v": {
+          "type": "any"
+        }
+      },
+      "type": "object"
+    },
+    "TableDataInsertAllRequest": {
+      "id": "TableDataInsertAllRequest",
+      "properties": {
+        "ignoreUnknownValues": {
+          "description": "[Optional] Accept rows that contain values that do not match the schema. The unknown values are ignored. Default is false, which treats unknown values as errors.",
+          "type": "boolean"
+        },
+        "kind": {
+          "default": "bigquery#tableDataInsertAllRequest",
+          "description": "The resource type of the response.",
+          "type": "string"
+        },
+        "rows": {
+          "description": "The rows to insert.",
+          "items": {
+            "properties": {
+              "insertId": {
+                "description": "[Optional] A unique ID for each row. BigQuery uses this property to detect duplicate insertion requests on a best-effort basis.",
+                "type": "string"
+              },
+              "json": {
+                "$ref": "JsonObject",
+                "description": "[Required] A JSON object that contains a row of data. The object's properties and values must match the destination table's schema."
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "skipInvalidRows": {
+          "description": "[Optional] Insert all valid rows of a request, even if invalid rows exist. The default value is false, which causes the entire request to fail if any invalid rows exist.",
+          "type": "boolean"
+        },
+        "templateSuffix": {
+          "description": "If specified, treats the destination table as a base template, and inserts the rows into an instance table named \"{destination}{templateSuffix}\". BigQuery will manage creation of the instance table, using the schema of the base template table. See https://cloud.google.com/bigquery/streaming-data-into-bigquery#template-tables for considerations when working with templates tables.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "TableDataInsertAllResponse": {
+      "id": "TableDataInsertAllResponse",
+      "properties": {
+        "insertErrors": {
+          "description": "An array of errors for rows that were not inserted.",
+          "items": {
+            "properties": {
+              "errors": {
+                "description": "Error information for the row indicated by the index property.",
+                "items": {
+                  "$ref": "ErrorProto"
+                },
+                "type": "array"
+              },
+              "index": {
+                "description": "The index of the row that error applies to.",
+                "format": "uint32",
+                "type": "integer"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "bigquery#tableDataInsertAllResponse",
+          "description": "The resource type of the response.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "TableDataList": {
+      "id": "TableDataList",
+      "properties": {
+        "etag": {
+          "description": "A hash of this page of results.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "bigquery#tableDataList",
+          "description": "The resource type of the response.",
+          "type": "string"
+        },
+        "pageToken": {
+          "description": "A token used for paging results. Providing this token instead of the startIndex parameter can help you retrieve stable results when an underlying table is changing.",
+          "type": "string"
+        },
+        "rows": {
+          "description": "Rows of results.",
+          "items": {
+            "$ref": "TableRow"
+          },
+          "type": "array"
+        },
+        "totalRows": {
+          "description": "The total number of rows in the complete table.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "TableFieldSchema": {
+      "id": "TableFieldSchema",
+      "properties": {
+        "categories": {
+          "description": "[Optional] The categories attached to this field, used for field-level access control.",
+          "properties": {
+            "names": {
+              "description": "A list of category resource names. For example, \"projects/1/taxonomies/2/categories/3\". At most 5 categories are allowed.",
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            }
+          },
+          "type": "object"
+        },
+        "description": {
+          "description": "[Optional] The field description. The maximum length is 1,024 characters.",
+          "type": "string"
+        },
+        "fields": {
+          "description": "[Optional] Describes the nested schema fields if the type property is set to RECORD.",
+          "items": {
+            "$ref": "TableFieldSchema"
+          },
+          "type": "array"
+        },
+        "maxLength": {
+          "description": "[Optional] Maximum length of values of this field for STRINGS or BYTES. If max_length is not specified, no maximum length constraint is imposed on this field. If type = \"STRING\", then max_length represents the maximum UTF-8 length of strings in this field. If type = \"BYTES\", then max_length represents the maximum number of bytes in this field. It is invalid to set this field if type \u2260 \"STRING\" and \u2260 \"BYTES\".",
+          "format": "int64",
+          "type": "string"
+        },
+        "mode": {
+          "description": "[Optional] The field mode. Possible values include NULLABLE, REQUIRED and REPEATED. The default value is NULLABLE.",
+          "type": "string"
+        },
+        "name": {
+          "description": "[Required] The field name. The name must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_), and must start with a letter or underscore. The maximum length is 128 characters.",
+          "type": "string"
+        },
+        "policyTags": {
+          "properties": {
+            "names": {
+              "description": "A list of category resource names. For example, \"projects/1/location/eu/taxonomies/2/policyTags/3\". At most 1 policy tag is allowed.",
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            }
+          },
+          "type": "object"
+        },
+        "precision": {
+          "description": "[Optional] Precision (maximum number of total digits in base 10) and scale (maximum number of digits in the fractional part in base 10) constraints for values of this field for NUMERIC or BIGNUMERIC. It is invalid to set precision or scale if type \u2260 \"NUMERIC\" and \u2260 \"BIGNUMERIC\". If precision and scale are not specified, no value range constraint is imposed on this field insofar as values are permitted by the type. Values of this NUMERIC or BIGNUMERIC field must be in this range when: - Precision (P) and scale (S) are specified: [-10P-S + 10-S, 10P-S - 10-S] - Precision (P) is specified but not scale (and thus scale is interpreted to be equal to zero): [-10P + 1, 10P - 1]. Acceptable values for precision and scale if both are specified: - If type = \"NUMERIC\": 1 \u2264 precision - scale \u2264 29 and 0 \u2264 scale \u2264 9. - If type = \"BIGNUMERIC\": 1 \u2264 precision - scale \u2264 38 and 0 \u2264 scale \u2264 38. Acceptable values for precision if only precision is specified but not scale (and thus scale is interpreted to be equal to zero): - If type = \"NUMERIC\": 1 \u2264 precision \u2264 29. - If type = \"BIGNUMERIC\": 1 \u2264 precision \u2264 38. If scale is specified but not precision, then it is invalid.",
+          "format": "int64",
+          "type": "string"
+        },
+        "scale": {
+          "description": "[Optional] See documentation for precision.",
+          "format": "int64",
+          "type": "string"
+        },
+        "type": {
+          "description": "[Required] The field data type. Possible values include STRING, BYTES, INTEGER, INT64 (same as INTEGER), FLOAT, FLOAT64 (same as FLOAT), NUMERIC, BIGNUMERIC, BOOLEAN, BOOL (same as BOOLEAN), TIMESTAMP, DATE, TIME, DATETIME, INTERVAL, RECORD (where RECORD indicates that the field contains a nested schema) or STRUCT (same as RECORD).",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "TableList": {
+      "id": "TableList",
+      "properties": {
+        "etag": {
+          "description": "A hash of this page of results.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "bigquery#tableList",
+          "description": "The type of list.",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "A token to request the next page of results.",
+          "type": "string"
+        },
+        "tables": {
+          "description": "Tables in the requested dataset.",
+          "items": {
+            "properties": {
+              "clustering": {
+                "$ref": "Clustering",
+                "description": "[Beta] Clustering specification for this table, if configured."
+              },
+              "creationTime": {
+                "description": "The time when this table was created, in milliseconds since the epoch.",
+                "format": "int64",
+                "type": "string"
+              },
+              "expirationTime": {
+                "description": "[Optional] The time when this table expires, in milliseconds since the epoch. If not present, the table will persist indefinitely. Expired tables will be deleted and their storage reclaimed.",
+                "format": "int64",
+                "type": "string"
+              },
+              "friendlyName": {
+                "description": "The user-friendly name for this table.",
+                "type": "string"
+              },
+              "id": {
+                "description": "An opaque ID of the table",
+                "type": "string"
+              },
+              "kind": {
+                "default": "bigquery#table",
+                "description": "The resource type.",
+                "type": "string"
+              },
+              "labels": {
+                "additionalProperties": {
+                  "type": "string"
+                },
+                "description": "The labels associated with this table. You can use these to organize and group your tables.",
+                "type": "object"
+              },
+              "rangePartitioning": {
+                "$ref": "RangePartitioning",
+                "description": "The range partitioning specification for this table, if configured."
+              },
+              "tableReference": {
+                "$ref": "TableReference",
+                "description": "A reference uniquely identifying the table."
+              },
+              "timePartitioning": {
+                "$ref": "TimePartitioning",
+                "description": "The time-based partitioning specification for this table, if configured."
+              },
+              "type": {
+                "description": "The type of table. Possible values are: TABLE, VIEW.",
+                "type": "string"
+              },
+              "view": {
+                "description": "Additional details for a view.",
+                "properties": {
+                  "useLegacySql": {
+                    "description": "True if view is defined in legacy SQL dialect, false if in standard SQL.",
+                    "type": "boolean"
+                  }
+                },
+                "type": "object"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "totalItems": {
+          "description": "The total number of tables in the dataset.",
+          "format": "int32",
+          "type": "integer"
+        }
+      },
+      "type": "object"
+    },
+    "TableReference": {
+      "id": "TableReference",
+      "properties": {
+        "datasetId": {
+          "annotations": {
+            "required": [
+              "bigquery.tables.update"
+            ]
+          },
+          "description": "[Required] The ID of the dataset containing this table.",
+          "type": "string"
+        },
+        "projectId": {
+          "annotations": {
+            "required": [
+              "bigquery.tables.update"
+            ]
+          },
+          "description": "[Required] The ID of the project containing this table.",
+          "type": "string"
+        },
+        "tableId": {
+          "annotations": {
+            "required": [
+              "bigquery.tables.update"
+            ]
+          },
+          "description": "[Required] The ID of the table. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 1,024 characters.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "TableRow": {
+      "id": "TableRow",
+      "properties": {
+        "f": {
+          "description": "Represents a single row in the result set, consisting of one or more fields.",
+          "items": {
+            "$ref": "TableCell"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "TableSchema": {
+      "id": "TableSchema",
+      "properties": {
+        "fields": {
+          "description": "Describes the fields in a table.",
+          "items": {
+            "$ref": "TableFieldSchema"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "TestIamPermissionsRequest": {
+      "description": "Request message for `TestIamPermissions` method.",
+      "id": "TestIamPermissionsRequest",
+      "properties": {
+        "permissions": {
+          "description": "The set of permissions to check for the `resource`. Permissions with wildcards (such as '*' or 'storage.*') are not allowed. For more information see [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "TestIamPermissionsResponse": {
+      "description": "Response message for `TestIamPermissions` method.",
+      "id": "TestIamPermissionsResponse",
+      "properties": {
+        "permissions": {
+          "description": "A subset of `TestPermissionsRequest.permissions` that the caller is allowed.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "TimePartitioning": {
+      "id": "TimePartitioning",
+      "properties": {
+        "expirationMs": {
+          "description": "[Optional] Number of milliseconds for which to keep the storage for partitions in the table. The storage in a partition will have an expiration time of its partition time plus this value.",
+          "format": "int64",
+          "type": "string"
+        },
+        "field": {
+          "description": "[Beta] [Optional] If not set, the table is partitioned by pseudo column, referenced via either '_PARTITIONTIME' as TIMESTAMP type, or '_PARTITIONDATE' as DATE type. If field is specified, the table is instead partitioned by this field. The field must be a top-level TIMESTAMP or DATE field. Its mode must be NULLABLE or REQUIRED.",
+          "type": "string"
+        },
+        "requirePartitionFilter": {
+          "type": "boolean"
+        },
+        "type": {
+          "description": "[Required] The supported types are DAY, HOUR, MONTH, and YEAR, which will generate one partition per day, hour, month, and year, respectively. When the type is not specified, the default behavior is DAY.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "TrainingOptions": {
+      "description": "Options used in model training.",
+      "id": "TrainingOptions",
+      "properties": {
+        "adjustStepChanges": {
+          "description": "If true, detect step changes and make data adjustment in the input time series.",
+          "type": "boolean"
+        },
+        "autoArima": {
+          "description": "Whether to enable auto ARIMA or not.",
+          "type": "boolean"
+        },
+        "autoArimaMaxOrder": {
+          "description": "The max value of non-seasonal p and q.",
+          "format": "int64",
+          "type": "string"
+        },
+        "batchSize": {
+          "description": "Batch size for dnn models.",
+          "format": "int64",
+          "type": "string"
+        },
+        "cleanSpikesAndDips": {
+          "description": "If true, clean spikes and dips in the input time series.",
+          "type": "boolean"
+        },
+        "dataFrequency": {
+          "description": "The data frequency of a time series.",
+          "enum": [
+            "DATA_FREQUENCY_UNSPECIFIED",
+            "AUTO_FREQUENCY",
+            "YEARLY",
+            "QUARTERLY",
+            "MONTHLY",
+            "WEEKLY",
+            "DAILY",
+            "HOURLY",
+            "PER_MINUTE"
+          ],
+          "enumDescriptions": [
+            "",
+            "Automatically inferred from timestamps.",
+            "Yearly data.",
+            "Quarterly data.",
+            "Monthly data.",
+            "Weekly data.",
+            "Daily data.",
+            "Hourly data.",
+            "Per-minute data."
+          ],
+          "type": "string"
+        },
+        "dataSplitColumn": {
+          "description": "The column to split data with. This column won't be used as a feature. 1. When data_split_method is CUSTOM, the corresponding column should be boolean. The rows with true value tag are eval data, and the false are training data. 2. When data_split_method is SEQ, the first DATA_SPLIT_EVAL_FRACTION rows (from smallest to largest) in the corresponding column are used as training data, and the rest are eval data. It respects the order in Orderable data types: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#data-type-properties",
+          "type": "string"
+        },
+        "dataSplitEvalFraction": {
+          "description": "The fraction of evaluation data over the whole input data. The rest of data will be used as training data. The format should be double. Accurate to two decimal places. Default value is 0.2.",
+          "format": "double",
+          "type": "number"
+        },
+        "dataSplitMethod": {
+          "description": "The data split type for training and evaluation, e.g. RANDOM.",
+          "enum": [
+            "DATA_SPLIT_METHOD_UNSPECIFIED",
+            "RANDOM",
+            "CUSTOM",
+            "SEQUENTIAL",
+            "NO_SPLIT",
+            "AUTO_SPLIT"
+          ],
+          "enumDescriptions": [
+            "",
+            "Splits data randomly.",
+            "Splits data with the user provided tags.",
+            "Splits data sequentially.",
+            "Data split will be skipped.",
+            "Splits data automatically: Uses NO_SPLIT if the data size is small. Otherwise uses RANDOM."
+          ],
+          "type": "string"
+        },
+        "decomposeTimeSeries": {
+          "description": "If true, perform decompose time series and save the results.",
+          "type": "boolean"
+        },
+        "distanceType": {
+          "description": "Distance type for clustering models.",
+          "enum": [
+            "DISTANCE_TYPE_UNSPECIFIED",
+            "EUCLIDEAN",
+            "COSINE"
+          ],
+          "enumDescriptions": [
+            "",
+            "Eculidean distance.",
+            "Cosine distance."
+          ],
+          "type": "string"
+        },
+        "dropout": {
+          "description": "Dropout probability for dnn models.",
+          "format": "double",
+          "type": "number"
+        },
+        "earlyStop": {
+          "description": "Whether to stop early when the loss doesn't improve significantly any more (compared to min_relative_progress). Used only for iterative training algorithms.",
+          "type": "boolean"
+        },
+        "feedbackType": {
+          "description": "Feedback type that specifies which algorithm to run for matrix factorization.",
+          "enum": [
+            "FEEDBACK_TYPE_UNSPECIFIED",
+            "IMPLICIT",
+            "EXPLICIT"
+          ],
+          "enumDescriptions": [
+            "",
+            "Use weighted-als for implicit feedback problems.",
+            "Use nonweighted-als for explicit feedback problems."
+          ],
+          "type": "string"
+        },
+        "hiddenUnits": {
+          "description": "Hidden units for dnn models.",
+          "items": {
+            "format": "int64",
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "holidayRegion": {
+          "description": "The geographical region based on which the holidays are considered in time series modeling. If a valid value is specified, then holiday effects modeling is enabled.",
+          "enum": [
+            "HOLIDAY_REGION_UNSPECIFIED",
+            "GLOBAL",
+            "NA",
+            "JAPAC",
+            "EMEA",
+            "LAC",
+            "AE",
+            "AR",
+            "AT",
+            "AU",
+            "BE",
+            "BR",
+            "CA",
+            "CH",
+            "CL",
+            "CN",
+            "CO",
+            "CS",
+            "CZ",
+            "DE",
+            "DK",
+            "DZ",
+            "EC",
+            "EE",
+            "EG",
+            "ES",
+            "FI",
+            "FR",
+            "GB",
+            "GR",
+            "HK",
+            "HU",
+            "ID",
+            "IE",
+            "IL",
+            "IN",
+            "IR",
+            "IT",
+            "JP",
+            "KR",
+            "LV",
+            "MA",
+            "MX",
+            "MY",
+            "NG",
+            "NL",
+            "NO",
+            "NZ",
+            "PE",
+            "PH",
+            "PK",
+            "PL",
+            "PT",
+            "RO",
+            "RS",
+            "RU",
+            "SA",
+            "SE",
+            "SG",
+            "SI",
+            "SK",
+            "TH",
+            "TR",
+            "TW",
+            "UA",
+            "US",
+            "VE",
+            "VN",
+            "ZA"
+          ],
+          "enumDescriptions": [
+            "Holiday region unspecified.",
+            "Global.",
+            "North America.",
+            "Japan and Asia Pacific: Korea, Greater China, India, Australia, and New Zealand.",
+            "Europe, the Middle East and Africa.",
+            "Latin America and the Caribbean.",
+            "United Arab Emirates",
+            "Argentina",
+            "Austria",
+            "Australia",
+            "Belgium",
+            "Brazil",
+            "Canada",
+            "Switzerland",
+            "Chile",
+            "China",
+            "Colombia",
+            "Czechoslovakia",
+            "Czech Republic",
+            "Germany",
+            "Denmark",
+            "Algeria",
+            "Ecuador",
+            "Estonia",
+            "Egypt",
+            "Spain",
+            "Finland",
+            "France",
+            "Great Britain (United Kingdom)",
+            "Greece",
+            "Hong Kong",
+            "Hungary",
+            "Indonesia",
+            "Ireland",
+            "Israel",
+            "India",
+            "Iran",
+            "Italy",
+            "Japan",
+            "Korea (South)",
+            "Latvia",
+            "Morocco",
+            "Mexico",
+            "Malaysia",
+            "Nigeria",
+            "Netherlands",
+            "Norway",
+            "New Zealand",
+            "Peru",
+            "Philippines",
+            "Pakistan",
+            "Poland",
+            "Portugal",
+            "Romania",
+            "Serbia",
+            "Russian Federation",
+            "Saudi Arabia",
+            "Sweden",
+            "Singapore",
+            "Slovenia",
+            "Slovakia",
+            "Thailand",
+            "Turkey",
+            "Taiwan",
+            "Ukraine",
+            "United States",
+            "Venezuela",
+            "Viet Nam",
+            "South Africa"
+          ],
+          "type": "string"
+        },
+        "horizon": {
+          "description": "The number of periods ahead that need to be forecasted.",
+          "format": "int64",
+          "type": "string"
+        },
+        "includeDrift": {
+          "description": "Include drift when fitting an ARIMA model.",
+          "type": "boolean"
+        },
+        "initialLearnRate": {
+          "description": "Specifies the initial learning rate for the line search learn rate strategy.",
+          "format": "double",
+          "type": "number"
+        },
+        "inputLabelColumns": {
+          "description": "Name of input label columns in training data.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "itemColumn": {
+          "description": "Item column specified for matrix factorization models.",
+          "type": "string"
+        },
+        "kmeansInitializationColumn": {
+          "description": "The column used to provide the initial centroids for kmeans algorithm when kmeans_initialization_method is CUSTOM.",
+          "type": "string"
+        },
+        "kmeansInitializationMethod": {
+          "description": "The method used to initialize the centroids for kmeans algorithm.",
+          "enum": [
+            "KMEANS_INITIALIZATION_METHOD_UNSPECIFIED",
+            "RANDOM",
+            "CUSTOM",
+            "KMEANS_PLUS_PLUS"
+          ],
+          "enumDescriptions": [
+            "Unspecified initialization method.",
+            "Initializes the centroids randomly.",
+            "Initializes the centroids using data specified in kmeans_initialization_column.",
+            "Initializes with kmeans++."
+          ],
+          "type": "string"
+        },
+        "l1Regularization": {
+          "description": "L1 regularization coefficient.",
+          "format": "double",
+          "type": "number"
+        },
+        "l2Regularization": {
+          "description": "L2 regularization coefficient.",
+          "format": "double",
+          "type": "number"
+        },
+        "labelClassWeights": {
+          "additionalProperties": {
+            "format": "double",
+            "type": "number"
+          },
+          "description": "Weights associated with each label class, for rebalancing the training data. Only applicable for classification models.",
+          "type": "object"
+        },
+        "learnRate": {
+          "description": "Learning rate in training. Used only for iterative training algorithms.",
+          "format": "double",
+          "type": "number"
+        },
+        "learnRateStrategy": {
+          "description": "The strategy to determine learn rate for the current iteration.",
+          "enum": [
+            "LEARN_RATE_STRATEGY_UNSPECIFIED",
+            "LINE_SEARCH",
+            "CONSTANT"
+          ],
+          "enumDescriptions": [
+            "",
+            "Use line search to determine learning rate.",
+            "Use a constant learning rate."
+          ],
+          "type": "string"
+        },
+        "lossType": {
+          "description": "Type of loss function used during training run.",
+          "enum": [
+            "LOSS_TYPE_UNSPECIFIED",
+            "MEAN_SQUARED_LOSS",
+            "MEAN_LOG_LOSS"
+          ],
+          "enumDescriptions": [
+            "",
+            "Mean squared loss, used for linear regression.",
+            "Mean log loss, used for logistic regression."
+          ],
+          "type": "string"
+        },
+        "maxIterations": {
+          "description": "The maximum number of iterations in training. Used only for iterative training algorithms.",
+          "format": "int64",
+          "type": "string"
+        },
+        "maxTreeDepth": {
+          "description": "Maximum depth of a tree for boosted tree models.",
+          "format": "int64",
+          "type": "string"
+        },
+        "minRelativeProgress": {
+          "description": "When early_stop is true, stops training when accuracy improvement is less than 'min_relative_progress'. Used only for iterative training algorithms.",
+          "format": "double",
+          "type": "number"
+        },
+        "minSplitLoss": {
+          "description": "Minimum split loss for boosted tree models.",
+          "format": "double",
+          "type": "number"
+        },
+        "modelUri": {
+          "description": "Google Cloud Storage URI from which the model was imported. Only applicable for imported models.",
+          "type": "string"
+        },
+        "nonSeasonalOrder": {
+          "$ref": "ArimaOrder",
+          "description": "A specification of the non-seasonal part of the ARIMA model: the three components (p, d, q) are the AR order, the degree of differencing, and the MA order."
+        },
+        "numClusters": {
+          "description": "Number of clusters for clustering models.",
+          "format": "int64",
+          "type": "string"
+        },
+        "numFactors": {
+          "description": "Num factors specified for matrix factorization models.",
+          "format": "int64",
+          "type": "string"
+        },
+        "optimizationStrategy": {
+          "description": "Optimization strategy for training linear regression models.",
+          "enum": [
+            "OPTIMIZATION_STRATEGY_UNSPECIFIED",
+            "BATCH_GRADIENT_DESCENT",
+            "NORMAL_EQUATION"
+          ],
+          "enumDescriptions": [
+            "",
+            "Uses an iterative batch gradient descent algorithm.",
+            "Uses a normal equation to solve linear regression problem."
+          ],
+          "type": "string"
+        },
+        "preserveInputStructs": {
+          "description": "Whether to preserve the input structs in output feature names. Suppose there is a struct A with field b. When false (default), the output feature name is A_b. When true, the output feature name is A.b.",
+          "type": "boolean"
+        },
+        "subsample": {
+          "description": "Subsample fraction of the training data to grow tree to prevent overfitting for boosted tree models.",
+          "format": "double",
+          "type": "number"
+        },
+        "timeSeriesDataColumn": {
+          "description": "Column to be designated as time series data for ARIMA model.",
+          "type": "string"
+        },
+        "timeSeriesIdColumn": {
+          "description": "The time series id column that was used during ARIMA model training.",
+          "type": "string"
+        },
+        "timeSeriesIdColumns": {
+          "description": "The time series id columns that were used during ARIMA model training.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "timeSeriesTimestampColumn": {
+          "description": "Column to be designated as time series timestamp for ARIMA model.",
+          "type": "string"
+        },
+        "userColumn": {
+          "description": "User column specified for matrix factorization models.",
+          "type": "string"
+        },
+        "walsAlpha": {
+          "description": "Hyperparameter for matrix factoration when implicit feedback type is specified.",
+          "format": "double",
+          "type": "number"
+        },
+        "warmStart": {
+          "description": "Whether to train a model from the last checkpoint.",
+          "type": "boolean"
+        }
+      },
+      "type": "object"
+    },
+    "TrainingRun": {
+      "description": "Information about a single training query run for the model.",
+      "id": "TrainingRun",
+      "properties": {
+        "dataSplitResult": {
+          "$ref": "DataSplitResult",
+          "description": "Data split result of the training run. Only set when the input data is actually split."
+        },
+        "evaluationMetrics": {
+          "$ref": "EvaluationMetrics",
+          "description": "The evaluation metrics over training/eval data that were computed at the end of training."
+        },
+        "globalExplanations": {
+          "description": "Global explanations for important features of the model. For multi-class models, there is one entry for each label class. For other models, there is only one entry in the list.",
+          "items": {
+            "$ref": "GlobalExplanation"
+          },
+          "type": "array"
+        },
+        "results": {
+          "description": "Output of each iteration run, results.size() <= max_iterations.",
+          "items": {
+            "$ref": "IterationResult"
+          },
+          "type": "array"
+        },
+        "startTime": {
+          "description": "The start time of this training run.",
+          "format": "google-datetime",
+          "type": "string"
+        },
+        "trainingOptions": {
+          "$ref": "TrainingOptions",
+          "description": "Options that were used for this training run, includes user specified and default options that were used."
+        }
+      },
+      "type": "object"
+    },
+    "TransactionInfo": {
+      "id": "TransactionInfo",
+      "properties": {
+        "transactionId": {
+          "description": "[Output-only] // [Alpha] Id of the transaction.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "UserDefinedFunctionResource": {
+      "description": "This is used for defining User Defined Function (UDF) resources only when using legacy SQL. Users of Standard SQL should leverage either DDL (e.g. CREATE [TEMPORARY] FUNCTION ... ) or the Routines API to define UDF resources. For additional information on migrating, see: https://cloud.google.com/bigquery/docs/reference/standard-sql/migrating-from-legacy-sql#differences_in_user-defined_javascript_functions",
+      "id": "UserDefinedFunctionResource",
+      "properties": {
+        "inlineCode": {
+          "description": "[Pick one] An inline resource that contains code for a user-defined function (UDF). Providing a inline code resource is equivalent to providing a URI for a file containing the same code.",
+          "type": "string"
+        },
+        "resourceUri": {
+          "description": "[Pick one] A code resource to load from a Google Cloud Storage URI (gs://bucket/path).",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ViewDefinition": {
+      "id": "ViewDefinition",
+      "properties": {
+        "query": {
+          "description": "[Required] A query that BigQuery executes when the view is referenced.",
+          "type": "string"
+        },
+        "useLegacySql": {
+          "description": "Specifies whether to use BigQuery's legacy SQL for this view. The default value is true. If set to false, the view will use BigQuery's standard SQL: https://cloud.google.com/bigquery/sql-reference/ Queries and views that reference this view must use the same flag value.",
+          "type": "boolean"
+        },
+        "userDefinedFunctionResources": {
+          "description": "Describes user-defined function resources used in the query.",
+          "items": {
+            "$ref": "UserDefinedFunctionResource"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    }
+  },
+  "servicePath": "bigquery/v2/",
+  "title": "BigQuery API",
+  "version": "v2"
+}
\ No newline at end of file
diff --git a/scripts/test_resources/new_artifacts_dir/drive.v3.json b/scripts/test_resources/new_artifacts_dir/drive.v3.json
new file mode 100644
index 0000000..5ac70fe
--- /dev/null
+++ b/scripts/test_resources/new_artifacts_dir/drive.v3.json
@@ -0,0 +1,3947 @@
+{
+  "auth": {
+    "oauth2": {
+      "scopes": {
+        "https://www.googleapis.com/auth/drive": {
+          "description": "See, edit, create, and delete all of your Google Drive files"
+        },
+        "https://www.googleapis.com/auth/drive.appdata": {
+          "description": "See, create, and delete its own configuration data in your Google Drive"
+        },
+        "https://www.googleapis.com/auth/drive.file": {
+          "description": "See, edit, create, and delete only the specific Google Drive files you use with this app"
+        },
+        "https://www.googleapis.com/auth/drive.metadata": {
+          "description": "View and manage metadata of files in your Google Drive"
+        },
+        "https://www.googleapis.com/auth/drive.metadata.readonly": {
+          "description": "See information about your Google Drive files"
+        },
+        "https://www.googleapis.com/auth/drive.photos.readonly": {
+          "description": "View the photos, videos and albums in your Google Photos"
+        },
+        "https://www.googleapis.com/auth/drive.readonly": {
+          "description": "See and download all your Google Drive files"
+        },
+        "https://www.googleapis.com/auth/drive.scripts": {
+          "description": "Modify your Google Apps Script scripts' behavior"
+        }
+      }
+    }
+  },
+  "basePath": "/drive/v3/",
+  "baseUrl": "https://www.googleapis.com/drive/v3/",
+  "batchPath": "batch/drive/v3",
+  "description": "Manages files in Drive including uploading, downloading, searching, detecting changes, and updating sharing permissions.",
+  "discoveryVersion": "v1",
+  "documentationLink": "https://developers.google.com/drive/",
+  "etag": "\"uWj2hSb4GVjzdDlAnRd2gbM1ZQ8/Nyk9QooT1-WBB03Ilrr_sA6IsJk\"",
+  "icons": {
+    "x16": "https://ssl.gstatic.com/docs/doclist/images/drive_icon_16.png",
+    "x32": "https://ssl.gstatic.com/docs/doclist/images/drive_icon_32.png"
+  },
+  "id": "drive:v3",
+  "kind": "discovery#restDescription",
+  "name": "drive",
+  "ownerDomain": "google.com",
+  "ownerName": "Google",
+  "parameters": {
+    "alt": {
+      "default": "json",
+      "description": "Data format for the response.",
+      "enum": [
+        "json"
+      ],
+      "enumDescriptions": [
+        "Responses with Content-Type of application/json"
+      ],
+      "location": "query",
+      "type": "string"
+    },
+    "fields": {
+      "description": "Selector specifying which fields to include in a partial response.",
+      "location": "query",
+      "type": "string"
+    },
+    "key": {
+      "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.",
+      "location": "query",
+      "type": "string"
+    },
+    "oauth_token": {
+      "description": "OAuth 2.0 token for the current user.",
+      "location": "query",
+      "type": "string"
+    },
+    "prettyPrint": {
+      "default": "true",
+      "description": "Returns response with indentations and line breaks.",
+      "location": "query",
+      "type": "boolean"
+    },
+    "quotaUser": {
+      "description": "An opaque string that represents a user for quota purposes. Must not exceed 40 characters.",
+      "location": "query",
+      "type": "string"
+    },
+    "userIp": {
+      "description": "Deprecated. Please use quotaUser instead.",
+      "location": "query",
+      "type": "string"
+    }
+  },
+  "protocol": "rest",
+  "resources": {
+    "about": {
+      "methods": {
+        "get": {
+          "description": "Gets information about the user, the user's Drive, and system capabilities.",
+          "httpMethod": "GET",
+          "id": "drive.about.get",
+          "path": "about",
+          "response": {
+            "$ref": "About"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        }
+      }
+    },
+    "changes": {
+      "methods": {
+        "getStartPageToken": {
+          "description": "Gets the starting pageToken for listing future changes.",
+          "httpMethod": "GET",
+          "id": "drive.changes.getStartPageToken",
+          "parameters": {
+            "driveId": {
+              "description": "The ID of the shared drive for which the starting pageToken for listing future changes from that shared drive is returned.",
+              "location": "query",
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "teamDriveId": {
+              "description": "Deprecated use driveId instead.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "changes/startPageToken",
+          "response": {
+            "$ref": "StartPageToken"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "list": {
+          "description": "Lists the changes for a user or shared drive.",
+          "httpMethod": "GET",
+          "id": "drive.changes.list",
+          "parameterOrder": [
+            "pageToken"
+          ],
+          "parameters": {
+            "driveId": {
+              "description": "The shared drive from which changes are returned. If specified the change IDs will be reflective of the shared drive; use the combined drive ID and change ID as an identifier.",
+              "location": "query",
+              "type": "string"
+            },
+            "includeCorpusRemovals": {
+              "default": "false",
+              "description": "Whether changes should include the file resource if the file is still accessible by the user at the time of the request, even when a file was removed from the list of changes and there will be no further change entries for this file.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "includeItemsFromAllDrives": {
+              "default": "false",
+              "description": "Whether both My Drive and shared drive items should be included in results.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "includePermissionsForView": {
+              "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.",
+              "location": "query",
+              "type": "string"
+            },
+            "includeRemoved": {
+              "default": "true",
+              "description": "Whether to include changes indicating that items have been removed from the list of changes, for example by deletion or loss of access.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "includeTeamDriveItems": {
+              "default": "false",
+              "description": "Deprecated use includeItemsFromAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "pageSize": {
+              "default": "100",
+              "description": "The maximum number of changes to return per page.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "1000",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response or to the response from the getStartPageToken method.",
+              "location": "query",
+              "required": true,
+              "type": "string"
+            },
+            "restrictToMyDrive": {
+              "default": "false",
+              "description": "Whether to restrict the results to changes inside the My Drive hierarchy. This omits changes to files such as those in the Application Data folder or shared files which have not been added to My Drive.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "spaces": {
+              "default": "drive",
+              "description": "A comma-separated list of spaces to query within the user corpus. Supported values are 'drive', 'appDataFolder' and 'photos'.",
+              "location": "query",
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "teamDriveId": {
+              "description": "Deprecated use driveId instead.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "changes",
+          "response": {
+            "$ref": "ChangeList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ],
+          "supportsSubscription": true
+        },
+        "watch": {
+          "description": "Subscribes to changes for a user.",
+          "httpMethod": "POST",
+          "id": "drive.changes.watch",
+          "parameterOrder": [
+            "pageToken"
+          ],
+          "parameters": {
+            "driveId": {
+              "description": "The shared drive from which changes are returned. If specified the change IDs will be reflective of the shared drive; use the combined drive ID and change ID as an identifier.",
+              "location": "query",
+              "type": "string"
+            },
+            "includeCorpusRemovals": {
+              "default": "false",
+              "description": "Whether changes should include the file resource if the file is still accessible by the user at the time of the request, even when a file was removed from the list of changes and there will be no further change entries for this file.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "includeItemsFromAllDrives": {
+              "default": "false",
+              "description": "Whether both My Drive and shared drive items should be included in results.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "includePermissionsForView": {
+              "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.",
+              "location": "query",
+              "type": "string"
+            },
+            "includeRemoved": {
+              "default": "true",
+              "description": "Whether to include changes indicating that items have been removed from the list of changes, for example by deletion or loss of access.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "includeTeamDriveItems": {
+              "default": "false",
+              "description": "Deprecated use includeItemsFromAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "pageSize": {
+              "default": "100",
+              "description": "The maximum number of changes to return per page.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "1000",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response or to the response from the getStartPageToken method.",
+              "location": "query",
+              "required": true,
+              "type": "string"
+            },
+            "restrictToMyDrive": {
+              "default": "false",
+              "description": "Whether to restrict the results to changes inside the My Drive hierarchy. This omits changes to files such as those in the Application Data folder or shared files which have not been added to My Drive.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "spaces": {
+              "default": "drive",
+              "description": "A comma-separated list of spaces to query within the user corpus. Supported values are 'drive', 'appDataFolder' and 'photos'.",
+              "location": "query",
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "teamDriveId": {
+              "description": "Deprecated use driveId instead.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "changes/watch",
+          "request": {
+            "$ref": "Channel",
+            "parameterName": "resource"
+          },
+          "response": {
+            "$ref": "Channel"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ],
+          "supportsSubscription": true
+        }
+      }
+    },
+    "channels": {
+      "methods": {
+        "stop": {
+          "description": "Stop watching resources through this channel",
+          "httpMethod": "POST",
+          "id": "drive.channels.stop",
+          "path": "channels/stop",
+          "request": {
+            "$ref": "Channel",
+            "parameterName": "resource"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        }
+      }
+    },
+    "comments": {
+      "methods": {
+        "create": {
+          "description": "Creates a new comment on a file.",
+          "httpMethod": "POST",
+          "id": "drive.comments.create",
+          "parameterOrder": [
+            "fileId"
+          ],
+          "parameters": {
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/comments",
+          "request": {
+            "$ref": "Comment"
+          },
+          "response": {
+            "$ref": "Comment"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        },
+        "delete": {
+          "description": "Deletes a comment.",
+          "httpMethod": "DELETE",
+          "id": "drive.comments.delete",
+          "parameterOrder": [
+            "fileId",
+            "commentId"
+          ],
+          "parameters": {
+            "commentId": {
+              "description": "The ID of the comment.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/comments/{commentId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        },
+        "get": {
+          "description": "Gets a comment by ID.",
+          "httpMethod": "GET",
+          "id": "drive.comments.get",
+          "parameterOrder": [
+            "fileId",
+            "commentId"
+          ],
+          "parameters": {
+            "commentId": {
+              "description": "The ID of the comment.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "includeDeleted": {
+              "default": "false",
+              "description": "Whether to return deleted comments. Deleted comments will not include their original content.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}/comments/{commentId}",
+          "response": {
+            "$ref": "Comment"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "list": {
+          "description": "Lists a file's comments.",
+          "httpMethod": "GET",
+          "id": "drive.comments.list",
+          "parameterOrder": [
+            "fileId"
+          ],
+          "parameters": {
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "includeDeleted": {
+              "default": "false",
+              "description": "Whether to include deleted comments. Deleted comments will not include their original content.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "pageSize": {
+              "default": "20",
+              "description": "The maximum number of comments to return per page.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "100",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.",
+              "location": "query",
+              "type": "string"
+            },
+            "startModifiedTime": {
+              "description": "The minimum value of 'modifiedTime' for the result comments (RFC 3339 date-time).",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/comments",
+          "response": {
+            "$ref": "CommentList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "update": {
+          "description": "Updates a comment with patch semantics.",
+          "httpMethod": "PATCH",
+          "id": "drive.comments.update",
+          "parameterOrder": [
+            "fileId",
+            "commentId"
+          ],
+          "parameters": {
+            "commentId": {
+              "description": "The ID of the comment.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/comments/{commentId}",
+          "request": {
+            "$ref": "Comment"
+          },
+          "response": {
+            "$ref": "Comment"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        }
+      }
+    },
+    "drives": {
+      "methods": {
+        "create": {
+          "description": "Creates a new shared drive.",
+          "httpMethod": "POST",
+          "id": "drive.drives.create",
+          "parameterOrder": [
+            "requestId"
+          ],
+          "parameters": {
+            "requestId": {
+              "description": "An ID, such as a random UUID, which uniquely identifies this user's request for idempotent creation of a shared drive. A repeated request by the same user and with the same request ID will avoid creating duplicates by attempting to create the same shared drive. If the shared drive already exists a 409 error will be returned.",
+              "location": "query",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "drives",
+          "request": {
+            "$ref": "Drive"
+          },
+          "response": {
+            "$ref": "Drive"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive"
+          ]
+        },
+        "delete": {
+          "description": "Permanently deletes a shared drive for which the user is an organizer. The shared drive cannot contain any untrashed items.",
+          "httpMethod": "DELETE",
+          "id": "drive.drives.delete",
+          "parameterOrder": [
+            "driveId"
+          ],
+          "parameters": {
+            "driveId": {
+              "description": "The ID of the shared drive.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "drives/{driveId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/drive"
+          ]
+        },
+        "get": {
+          "description": "Gets a shared drive's metadata by ID.",
+          "httpMethod": "GET",
+          "id": "drive.drives.get",
+          "parameterOrder": [
+            "driveId"
+          ],
+          "parameters": {
+            "driveId": {
+              "description": "The ID of the shared drive.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if they are an administrator of the domain to which the shared drive belongs.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "drives/{driveId}",
+          "response": {
+            "$ref": "Drive"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "hide": {
+          "description": "Hides a shared drive from the default view.",
+          "httpMethod": "POST",
+          "id": "drive.drives.hide",
+          "parameterOrder": [
+            "driveId"
+          ],
+          "parameters": {
+            "driveId": {
+              "description": "The ID of the shared drive.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "drives/{driveId}/hide",
+          "response": {
+            "$ref": "Drive"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive"
+          ]
+        },
+        "list": {
+          "description": "Lists the user's shared drives.",
+          "httpMethod": "GET",
+          "id": "drive.drives.list",
+          "parameters": {
+            "pageSize": {
+              "default": "10",
+              "description": "Maximum number of shared drives to return.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "100",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Page token for shared drives.",
+              "location": "query",
+              "type": "string"
+            },
+            "q": {
+              "description": "Query string for searching shared drives.",
+              "location": "query",
+              "type": "string"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then all shared drives of the domain in which the requester is an administrator are returned.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "drives",
+          "response": {
+            "$ref": "DriveList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "unhide": {
+          "description": "Restores a shared drive to the default view.",
+          "httpMethod": "POST",
+          "id": "drive.drives.unhide",
+          "parameterOrder": [
+            "driveId"
+          ],
+          "parameters": {
+            "driveId": {
+              "description": "The ID of the shared drive.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "drives/{driveId}/unhide",
+          "response": {
+            "$ref": "Drive"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive"
+          ]
+        },
+        "update": {
+          "description": "Updates the metadate for a shared drive.",
+          "httpMethod": "PATCH",
+          "id": "drive.drives.update",
+          "parameterOrder": [
+            "driveId"
+          ],
+          "parameters": {
+            "driveId": {
+              "description": "The ID of the shared drive.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if they are an administrator of the domain to which the shared drive belongs.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "drives/{driveId}",
+          "request": {
+            "$ref": "Drive"
+          },
+          "response": {
+            "$ref": "Drive"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive"
+          ]
+        }
+      }
+    },
+    "files": {
+      "methods": {
+        "copy": {
+          "description": "Creates a copy of a file and applies any requested updates with patch semantics. Folders cannot be copied.",
+          "httpMethod": "POST",
+          "id": "drive.files.copy",
+          "parameterOrder": [
+            "fileId"
+          ],
+          "parameters": {
+            "enforceSingleParent": {
+              "default": "false",
+              "description": "Deprecated. Copying files into multiple folders is no longer supported. Use shortcuts instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "ignoreDefaultVisibility": {
+              "default": "false",
+              "description": "Whether to ignore the domain's default visibility settings for the created file. Domain administrators can choose to make all uploaded files visible to the domain by default; this parameter bypasses that behavior for the request. Permissions are still inherited from parent folders.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "includePermissionsForView": {
+              "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.",
+              "location": "query",
+              "type": "string"
+            },
+            "keepRevisionForever": {
+              "default": "false",
+              "description": "Whether to set the 'keepForever' field in the new head revision. This is only applicable to files with binary content in Google Drive. Only 200 revisions for the file can be kept forever. If the limit is reached, try deleting pinned revisions.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "ocrLanguage": {
+              "description": "A language hint for OCR processing during image import (ISO 639-1 code).",
+              "location": "query",
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}/copy",
+          "request": {
+            "$ref": "File"
+          },
+          "response": {
+            "$ref": "File"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.photos.readonly"
+          ]
+        },
+        "create": {
+          "description": "Creates a new file.",
+          "httpMethod": "POST",
+          "id": "drive.files.create",
+          "mediaUpload": {
+            "accept": [
+              "*/*"
+            ],
+            "maxSize": "5120GB",
+            "protocols": {
+              "resumable": {
+                "multipart": true,
+                "path": "/resumable/upload/drive/v3/files"
+              },
+              "simple": {
+                "multipart": true,
+                "path": "/upload/drive/v3/files"
+              }
+            }
+          },
+          "parameters": {
+            "enforceSingleParent": {
+              "default": "false",
+              "description": "Deprecated. Creating files in multiple folders is no longer supported.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "ignoreDefaultVisibility": {
+              "default": "false",
+              "description": "Whether to ignore the domain's default visibility settings for the created file. Domain administrators can choose to make all uploaded files visible to the domain by default; this parameter bypasses that behavior for the request. Permissions are still inherited from parent folders.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "includePermissionsForView": {
+              "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.",
+              "location": "query",
+              "type": "string"
+            },
+            "keepRevisionForever": {
+              "default": "false",
+              "description": "Whether to set the 'keepForever' field in the new head revision. This is only applicable to files with binary content in Google Drive. Only 200 revisions for the file can be kept forever. If the limit is reached, try deleting pinned revisions.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "ocrLanguage": {
+              "description": "A language hint for OCR processing during image import (ISO 639-1 code).",
+              "location": "query",
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "useContentAsIndexableText": {
+              "default": "false",
+              "description": "Whether to use the uploaded content as indexable text.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files",
+          "request": {
+            "$ref": "File"
+          },
+          "response": {
+            "$ref": "File"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file"
+          ],
+          "supportsMediaUpload": true,
+          "supportsSubscription": true
+        },
+        "delete": {
+          "description": "Permanently deletes a file owned by the user without moving it to the trash. If the file belongs to a shared drive the user must be an organizer on the parent. If the target is a folder, all descendants owned by the user are also deleted.",
+          "httpMethod": "DELETE",
+          "id": "drive.files.delete",
+          "parameterOrder": [
+            "fileId"
+          ],
+          "parameters": {
+            "enforceSingleParent": {
+              "default": "false",
+              "description": "Deprecated. If an item is not in a shared drive and its last parent is deleted but the item itself is not, the item will be placed under its owner's root.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        },
+        "emptyTrash": {
+          "description": "Permanently deletes all of the user's trashed files.",
+          "httpMethod": "DELETE",
+          "id": "drive.files.emptyTrash",
+          "parameters": {
+            "enforceSingleParent": {
+              "default": "false",
+              "description": "Deprecated. If an item is not in a shared drive and its last parent is deleted but the item itself is not, the item will be placed under its owner's root.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/trash",
+          "scopes": [
+            "https://www.googleapis.com/auth/drive"
+          ]
+        },
+        "export": {
+          "description": "Exports a Google Doc to the requested MIME type and returns the exported content. Please note that the exported content is limited to 10MB.",
+          "httpMethod": "GET",
+          "id": "drive.files.export",
+          "parameterOrder": [
+            "fileId",
+            "mimeType"
+          ],
+          "parameters": {
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "mimeType": {
+              "description": "The MIME type of the format requested for this export.",
+              "location": "query",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/export",
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ],
+          "supportsMediaDownload": true
+        },
+        "generateIds": {
+          "description": "Generates a set of file IDs which can be provided in create or copy requests.",
+          "httpMethod": "GET",
+          "id": "drive.files.generateIds",
+          "parameters": {
+            "count": {
+              "default": "10",
+              "description": "The number of IDs to return.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "1000",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "space": {
+              "default": "drive",
+              "description": "The space in which the IDs can be used to create new files. Supported values are 'drive' and 'appDataFolder'.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "files/generateIds",
+          "response": {
+            "$ref": "GeneratedIds"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        },
+        "get": {
+          "description": "Gets a file's metadata or content by ID.",
+          "httpMethod": "GET",
+          "id": "drive.files.get",
+          "parameterOrder": [
+            "fileId"
+          ],
+          "parameters": {
+            "acknowledgeAbuse": {
+              "default": "false",
+              "description": "Whether the user is acknowledging the risk of downloading known malware or other abusive files. This is only applicable when alt=media.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "includePermissionsForView": {
+              "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.",
+              "location": "query",
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}",
+          "response": {
+            "$ref": "File"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ],
+          "supportsMediaDownload": true,
+          "supportsSubscription": true,
+          "useMediaDownloadService": true
+        },
+        "list": {
+          "description": "Lists or searches files.",
+          "httpMethod": "GET",
+          "id": "drive.files.list",
+          "parameters": {
+            "corpora": {
+              "description": "Groupings of files to which the query applies. Supported groupings are: 'user' (files created by, opened by, or shared directly with the user), 'drive' (files in the specified shared drive as indicated by the 'driveId'), 'domain' (files shared to the user's domain), and 'allDrives' (A combination of 'user' and 'drive' for all drives where the user is a member). When able, use 'user' or 'drive', instead of 'allDrives', for efficiency.",
+              "location": "query",
+              "type": "string"
+            },
+            "corpus": {
+              "description": "The source of files to list. Deprecated: use 'corpora' instead.",
+              "enum": [
+                "domain",
+                "user"
+              ],
+              "enumDescriptions": [
+                "Files shared to the user's domain.",
+                "Files owned by or shared to the user. If a user has permissions on a Shared Drive, the files inside it won't be retrieved unless the user has created, opened, or shared the file."
+              ],
+              "location": "query",
+              "type": "string"
+            },
+            "driveId": {
+              "description": "ID of the shared drive to search.",
+              "location": "query",
+              "type": "string"
+            },
+            "includeItemsFromAllDrives": {
+              "default": "false",
+              "description": "Whether both My Drive and shared drive items should be included in results.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "includePermissionsForView": {
+              "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.",
+              "location": "query",
+              "type": "string"
+            },
+            "includeTeamDriveItems": {
+              "default": "false",
+              "description": "Deprecated use includeItemsFromAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "orderBy": {
+              "description": "A comma-separated list of sort keys. Valid keys are 'createdTime', 'folder', 'modifiedByMeTime', 'modifiedTime', 'name', 'name_natural', 'quotaBytesUsed', 'recency', 'sharedWithMeTime', 'starred', and 'viewedByMeTime'. Each key sorts ascending by default, but may be reversed with the 'desc' modifier. Example usage: ?orderBy=folder,modifiedTime desc,name. Please note that there is a current limitation for users with approximately one million files in which the requested sort order is ignored.",
+              "location": "query",
+              "type": "string"
+            },
+            "pageSize": {
+              "default": "100",
+              "description": "The maximum number of files to return per page. Partial or empty result pages are possible even before the end of the files list has been reached.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "1000",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.",
+              "location": "query",
+              "type": "string"
+            },
+            "q": {
+              "description": "A query for filtering the file results. See the \"Search for Files\" guide for supported syntax.",
+              "location": "query",
+              "type": "string"
+            },
+            "spaces": {
+              "default": "drive",
+              "description": "A comma-separated list of spaces to query within the corpus. Supported values are 'drive', 'appDataFolder' and 'photos'.",
+              "location": "query",
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "teamDriveId": {
+              "description": "Deprecated use driveId instead.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "files",
+          "response": {
+            "$ref": "FileList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "update": {
+          "description": "Updates a file's metadata and/or content. This method supports patch semantics.",
+          "httpMethod": "PATCH",
+          "id": "drive.files.update",
+          "mediaUpload": {
+            "accept": [
+              "*/*"
+            ],
+            "maxSize": "5120GB",
+            "protocols": {
+              "resumable": {
+                "multipart": true,
+                "path": "/resumable/upload/drive/v3/files/{fileId}"
+              },
+              "simple": {
+                "multipart": true,
+                "path": "/upload/drive/v3/files/{fileId}"
+              }
+            }
+          },
+          "parameterOrder": [
+            "fileId"
+          ],
+          "parameters": {
+            "addParents": {
+              "description": "A comma-separated list of parent IDs to add.",
+              "location": "query",
+              "type": "string"
+            },
+            "enforceSingleParent": {
+              "default": "false",
+              "description": "Deprecated. Adding files to multiple folders is no longer supported. Use shortcuts instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "includePermissionsForView": {
+              "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.",
+              "location": "query",
+              "type": "string"
+            },
+            "keepRevisionForever": {
+              "default": "false",
+              "description": "Whether to set the 'keepForever' field in the new head revision. This is only applicable to files with binary content in Google Drive. Only 200 revisions for the file can be kept forever. If the limit is reached, try deleting pinned revisions.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "ocrLanguage": {
+              "description": "A language hint for OCR processing during image import (ISO 639-1 code).",
+              "location": "query",
+              "type": "string"
+            },
+            "removeParents": {
+              "description": "A comma-separated list of parent IDs to remove.",
+              "location": "query",
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "useContentAsIndexableText": {
+              "default": "false",
+              "description": "Whether to use the uploaded content as indexable text.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}",
+          "request": {
+            "$ref": "File"
+          },
+          "response": {
+            "$ref": "File"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.scripts"
+          ],
+          "supportsMediaUpload": true
+        },
+        "watch": {
+          "description": "Subscribes to changes to a file",
+          "httpMethod": "POST",
+          "id": "drive.files.watch",
+          "parameterOrder": [
+            "fileId"
+          ],
+          "parameters": {
+            "acknowledgeAbuse": {
+              "default": "false",
+              "description": "Whether the user is acknowledging the risk of downloading known malware or other abusive files. This is only applicable when alt=media.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "includePermissionsForView": {
+              "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.",
+              "location": "query",
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}/watch",
+          "request": {
+            "$ref": "Channel",
+            "parameterName": "resource"
+          },
+          "response": {
+            "$ref": "Channel"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ],
+          "supportsMediaDownload": true,
+          "supportsSubscription": true,
+          "useMediaDownloadService": true
+        }
+      }
+    },
+    "permissions": {
+      "methods": {
+        "create": {
+          "description": "Creates a permission for a file or shared drive.",
+          "httpMethod": "POST",
+          "id": "drive.permissions.create",
+          "parameterOrder": [
+            "fileId"
+          ],
+          "parameters": {
+            "emailMessage": {
+              "description": "A plain text custom message to include in the notification email.",
+              "location": "query",
+              "type": "string"
+            },
+            "enforceSingleParent": {
+              "default": "false",
+              "description": "Deprecated. See moveToNewOwnersRoot for details.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "fileId": {
+              "description": "The ID of the file or shared drive.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "moveToNewOwnersRoot": {
+              "default": "false",
+              "description": "This parameter will only take effect if the item is not in a shared drive and the request is attempting to transfer the ownership of the item. If set to true, the item will be moved to the new owner's My Drive root folder and all prior parents removed. If set to false, parents are not changed.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "sendNotificationEmail": {
+              "description": "Whether to send a notification email when sharing to users or groups. This defaults to true for users and groups, and is not allowed for other requests. It must not be disabled for ownership transfers.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "transferOwnership": {
+              "default": "false",
+              "description": "Whether to transfer ownership to the specified user and downgrade the current owner to a writer. This parameter is required as an acknowledgement of the side effect.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if the file ID parameter refers to a shared drive and the requester is an administrator of the domain to which the shared drive belongs.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}/permissions",
+          "request": {
+            "$ref": "Permission"
+          },
+          "response": {
+            "$ref": "Permission"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        },
+        "delete": {
+          "description": "Deletes a permission.",
+          "httpMethod": "DELETE",
+          "id": "drive.permissions.delete",
+          "parameterOrder": [
+            "fileId",
+            "permissionId"
+          ],
+          "parameters": {
+            "fileId": {
+              "description": "The ID of the file or shared drive.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "permissionId": {
+              "description": "The ID of the permission.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if the file ID parameter refers to a shared drive and the requester is an administrator of the domain to which the shared drive belongs.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}/permissions/{permissionId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        },
+        "get": {
+          "description": "Gets a permission by ID.",
+          "httpMethod": "GET",
+          "id": "drive.permissions.get",
+          "parameterOrder": [
+            "fileId",
+            "permissionId"
+          ],
+          "parameters": {
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "permissionId": {
+              "description": "The ID of the permission.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if the file ID parameter refers to a shared drive and the requester is an administrator of the domain to which the shared drive belongs.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}/permissions/{permissionId}",
+          "response": {
+            "$ref": "Permission"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "list": {
+          "description": "Lists a file's or shared drive's permissions.",
+          "httpMethod": "GET",
+          "id": "drive.permissions.list",
+          "parameterOrder": [
+            "fileId"
+          ],
+          "parameters": {
+            "fileId": {
+              "description": "The ID of the file or shared drive.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "includePermissionsForView": {
+              "description": "Specifies which additional view's permissions to include in the response. Only 'published' is supported.",
+              "location": "query",
+              "type": "string"
+            },
+            "pageSize": {
+              "description": "The maximum number of permissions to return per page. When not set for files in a shared drive, at most 100 results will be returned. When not set for files that are not in a shared drive, the entire list will be returned.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "100",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.",
+              "location": "query",
+              "type": "string"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if the file ID parameter refers to a shared drive and the requester is an administrator of the domain to which the shared drive belongs.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}/permissions",
+          "response": {
+            "$ref": "PermissionList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "update": {
+          "description": "Updates a permission with patch semantics.",
+          "httpMethod": "PATCH",
+          "id": "drive.permissions.update",
+          "parameterOrder": [
+            "fileId",
+            "permissionId"
+          ],
+          "parameters": {
+            "fileId": {
+              "description": "The ID of the file or shared drive.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "permissionId": {
+              "description": "The ID of the permission.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "removeExpiration": {
+              "default": "false",
+              "description": "Whether to remove the expiration date.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsAllDrives": {
+              "default": "false",
+              "description": "Whether the requesting application supports both My Drives and shared drives.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "supportsTeamDrives": {
+              "default": "false",
+              "description": "Deprecated use supportsAllDrives instead.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "transferOwnership": {
+              "default": "false",
+              "description": "Whether to transfer ownership to the specified user and downgrade the current owner to a writer. This parameter is required as an acknowledgement of the side effect.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if the file ID parameter refers to a shared drive and the requester is an administrator of the domain to which the shared drive belongs.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "files/{fileId}/permissions/{permissionId}",
+          "request": {
+            "$ref": "Permission"
+          },
+          "response": {
+            "$ref": "Permission"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        }
+      }
+    },
+    "replies": {
+      "methods": {
+        "create": {
+          "description": "Creates a new reply to a comment.",
+          "httpMethod": "POST",
+          "id": "drive.replies.create",
+          "parameterOrder": [
+            "fileId",
+            "commentId"
+          ],
+          "parameters": {
+            "commentId": {
+              "description": "The ID of the comment.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/comments/{commentId}/replies",
+          "request": {
+            "$ref": "Reply"
+          },
+          "response": {
+            "$ref": "Reply"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        },
+        "delete": {
+          "description": "Deletes a reply.",
+          "httpMethod": "DELETE",
+          "id": "drive.replies.delete",
+          "parameterOrder": [
+            "fileId",
+            "commentId",
+            "replyId"
+          ],
+          "parameters": {
+            "commentId": {
+              "description": "The ID of the comment.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "replyId": {
+              "description": "The ID of the reply.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/comments/{commentId}/replies/{replyId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        },
+        "get": {
+          "description": "Gets a reply by ID.",
+          "httpMethod": "GET",
+          "id": "drive.replies.get",
+          "parameterOrder": [
+            "fileId",
+            "commentId",
+            "replyId"
+          ],
+          "parameters": {
+            "commentId": {
+              "description": "The ID of the comment.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "includeDeleted": {
+              "default": "false",
+              "description": "Whether to return deleted replies. Deleted replies will not include their original content.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "replyId": {
+              "description": "The ID of the reply.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/comments/{commentId}/replies/{replyId}",
+          "response": {
+            "$ref": "Reply"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "list": {
+          "description": "Lists a comment's replies.",
+          "httpMethod": "GET",
+          "id": "drive.replies.list",
+          "parameterOrder": [
+            "fileId",
+            "commentId"
+          ],
+          "parameters": {
+            "commentId": {
+              "description": "The ID of the comment.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "includeDeleted": {
+              "default": "false",
+              "description": "Whether to include deleted replies. Deleted replies will not include their original content.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "pageSize": {
+              "default": "20",
+              "description": "The maximum number of replies to return per page.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "100",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/comments/{commentId}/replies",
+          "response": {
+            "$ref": "ReplyList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "update": {
+          "description": "Updates a reply with patch semantics.",
+          "httpMethod": "PATCH",
+          "id": "drive.replies.update",
+          "parameterOrder": [
+            "fileId",
+            "commentId",
+            "replyId"
+          ],
+          "parameters": {
+            "commentId": {
+              "description": "The ID of the comment.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "replyId": {
+              "description": "The ID of the reply.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/comments/{commentId}/replies/{replyId}",
+          "request": {
+            "$ref": "Reply"
+          },
+          "response": {
+            "$ref": "Reply"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        }
+      }
+    },
+    "revisions": {
+      "methods": {
+        "delete": {
+          "description": "Permanently deletes a file version. You can only delete revisions for files with binary content in Google Drive, like images or videos. Revisions for other files, like Google Docs or Sheets, and the last remaining file version can't be deleted.",
+          "httpMethod": "DELETE",
+          "id": "drive.revisions.delete",
+          "parameterOrder": [
+            "fileId",
+            "revisionId"
+          ],
+          "parameters": {
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "revisionId": {
+              "description": "The ID of the revision.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/revisions/{revisionId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        },
+        "get": {
+          "description": "Gets a revision's metadata or content by ID.",
+          "httpMethod": "GET",
+          "id": "drive.revisions.get",
+          "parameterOrder": [
+            "fileId",
+            "revisionId"
+          ],
+          "parameters": {
+            "acknowledgeAbuse": {
+              "default": "false",
+              "description": "Whether the user is acknowledging the risk of downloading known malware or other abusive files. This is only applicable when alt=media.",
+              "location": "query",
+              "type": "boolean"
+            },
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "revisionId": {
+              "description": "The ID of the revision.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/revisions/{revisionId}",
+          "response": {
+            "$ref": "Revision"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ],
+          "supportsMediaDownload": true,
+          "useMediaDownloadService": true
+        },
+        "list": {
+          "description": "Lists a file's revisions.",
+          "httpMethod": "GET",
+          "id": "drive.revisions.list",
+          "parameterOrder": [
+            "fileId"
+          ],
+          "parameters": {
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "pageSize": {
+              "default": "200",
+              "description": "The maximum number of revisions to return per page.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "1000",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "The token for continuing a previous list request on the next page. This should be set to the value of 'nextPageToken' from the previous response.",
+              "location": "query",
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/revisions",
+          "response": {
+            "$ref": "RevisionList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.metadata",
+            "https://www.googleapis.com/auth/drive.metadata.readonly",
+            "https://www.googleapis.com/auth/drive.photos.readonly",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "update": {
+          "description": "Updates a revision with patch semantics.",
+          "httpMethod": "PATCH",
+          "id": "drive.revisions.update",
+          "parameterOrder": [
+            "fileId",
+            "revisionId"
+          ],
+          "parameters": {
+            "fileId": {
+              "description": "The ID of the file.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "revisionId": {
+              "description": "The ID of the revision.",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "files/{fileId}/revisions/{revisionId}",
+          "request": {
+            "$ref": "Revision"
+          },
+          "response": {
+            "$ref": "Revision"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.appdata",
+            "https://www.googleapis.com/auth/drive.file"
+          ]
+        }
+      }
+    },
+    "teamdrives": {
+      "methods": {
+        "create": {
+          "description": "Deprecated use drives.create instead.",
+          "httpMethod": "POST",
+          "id": "drive.teamdrives.create",
+          "parameterOrder": [
+            "requestId"
+          ],
+          "parameters": {
+            "requestId": {
+              "description": "An ID, such as a random UUID, which uniquely identifies this user's request for idempotent creation of a Team Drive. A repeated request by the same user and with the same request ID will avoid creating duplicates by attempting to create the same Team Drive. If the Team Drive already exists a 409 error will be returned.",
+              "location": "query",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "teamdrives",
+          "request": {
+            "$ref": "TeamDrive"
+          },
+          "response": {
+            "$ref": "TeamDrive"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive"
+          ]
+        },
+        "delete": {
+          "description": "Deprecated use drives.delete instead.",
+          "httpMethod": "DELETE",
+          "id": "drive.teamdrives.delete",
+          "parameterOrder": [
+            "teamDriveId"
+          ],
+          "parameters": {
+            "teamDriveId": {
+              "description": "The ID of the Team Drive",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            }
+          },
+          "path": "teamdrives/{teamDriveId}",
+          "scopes": [
+            "https://www.googleapis.com/auth/drive"
+          ]
+        },
+        "get": {
+          "description": "Deprecated use drives.get instead.",
+          "httpMethod": "GET",
+          "id": "drive.teamdrives.get",
+          "parameterOrder": [
+            "teamDriveId"
+          ],
+          "parameters": {
+            "teamDriveId": {
+              "description": "The ID of the Team Drive",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if they are an administrator of the domain to which the Team Drive belongs.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "teamdrives/{teamDriveId}",
+          "response": {
+            "$ref": "TeamDrive"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "list": {
+          "description": "Deprecated use drives.list instead.",
+          "httpMethod": "GET",
+          "id": "drive.teamdrives.list",
+          "parameters": {
+            "pageSize": {
+              "default": "10",
+              "description": "Maximum number of Team Drives to return.",
+              "format": "int32",
+              "location": "query",
+              "maximum": "100",
+              "minimum": "1",
+              "type": "integer"
+            },
+            "pageToken": {
+              "description": "Page token for Team Drives.",
+              "location": "query",
+              "type": "string"
+            },
+            "q": {
+              "description": "Query string for searching Team Drives.",
+              "location": "query",
+              "type": "string"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then all Team Drives of the domain in which the requester is an administrator are returned.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "teamdrives",
+          "response": {
+            "$ref": "TeamDriveList"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.readonly"
+          ]
+        },
+        "update": {
+          "description": "Deprecated use drives.update instead",
+          "httpMethod": "PATCH",
+          "id": "drive.teamdrives.update",
+          "parameterOrder": [
+            "teamDriveId"
+          ],
+          "parameters": {
+            "teamDriveId": {
+              "description": "The ID of the Team Drive",
+              "location": "path",
+              "required": true,
+              "type": "string"
+            },
+            "useDomainAdminAccess": {
+              "default": "false",
+              "description": "Issue the request as a domain administrator; if set to true, then the requester will be granted access if they are an administrator of the domain to which the Team Drive belongs.",
+              "location": "query",
+              "type": "boolean"
+            }
+          },
+          "path": "teamdrives/{teamDriveId}",
+          "request": {
+            "$ref": "TeamDrive"
+          },
+          "response": {
+            "$ref": "TeamDrive"
+          },
+          "scopes": [
+            "https://www.googleapis.com/auth/drive"
+          ]
+        }
+      }
+    }
+  },
+  "revision": "20210322",
+  "rootUrl": "https://www.googleapis.com/",
+  "schemas": {
+    "About": {
+      "description": "Information about the user, the user's Drive, and system capabilities.",
+      "id": "About",
+      "properties": {
+        "appInstalled": {
+          "description": "Whether the user has installed the requesting app.",
+          "type": "boolean"
+        },
+        "canCreateDrives": {
+          "description": "Whether the user can create shared drives.",
+          "type": "boolean"
+        },
+        "canCreateTeamDrives": {
+          "description": "Deprecated - use canCreateDrives instead.",
+          "type": "boolean"
+        },
+        "driveThemes": {
+          "description": "A list of themes that are supported for shared drives.",
+          "items": {
+            "properties": {
+              "backgroundImageLink": {
+                "description": "A link to this theme's background image.",
+                "type": "string"
+              },
+              "colorRgb": {
+                "description": "The color of this theme as an RGB hex string.",
+                "type": "string"
+              },
+              "id": {
+                "description": "The ID of the theme.",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "exportFormats": {
+          "additionalProperties": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "description": "A map of source MIME type to possible targets for all supported exports.",
+          "type": "object"
+        },
+        "folderColorPalette": {
+          "description": "The currently supported folder colors as RGB hex strings.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "importFormats": {
+          "additionalProperties": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "description": "A map of source MIME type to possible targets for all supported imports.",
+          "type": "object"
+        },
+        "kind": {
+          "default": "drive#about",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#about\".",
+          "type": "string"
+        },
+        "maxImportSizes": {
+          "additionalProperties": {
+            "format": "int64",
+            "type": "string"
+          },
+          "description": "A map of maximum import sizes by MIME type, in bytes.",
+          "type": "object"
+        },
+        "maxUploadSize": {
+          "description": "The maximum upload size in bytes.",
+          "format": "int64",
+          "type": "string"
+        },
+        "storageQuota": {
+          "description": "The user's storage quota limits and usage. All fields are measured in bytes.",
+          "properties": {
+            "limit": {
+              "description": "The usage limit, if applicable. This will not be present if the user has unlimited storage.",
+              "format": "int64",
+              "type": "string"
+            },
+            "usage": {
+              "description": "The total usage across all services.",
+              "format": "int64",
+              "type": "string"
+            },
+            "usageInDrive": {
+              "description": "The usage by all files in Google Drive.",
+              "format": "int64",
+              "type": "string"
+            },
+            "usageInDriveTrash": {
+              "description": "The usage by trashed files in Google Drive.",
+              "format": "int64",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "teamDriveThemes": {
+          "description": "Deprecated - use driveThemes instead.",
+          "items": {
+            "properties": {
+              "backgroundImageLink": {
+                "description": "Deprecated - use driveThemes/backgroundImageLink instead.",
+                "type": "string"
+              },
+              "colorRgb": {
+                "description": "Deprecated - use driveThemes/colorRgb instead.",
+                "type": "string"
+              },
+              "id": {
+                "description": "Deprecated - use driveThemes/id instead.",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "user": {
+          "$ref": "User",
+          "description": "The authenticated user."
+        }
+      },
+      "type": "object"
+    },
+    "Change": {
+      "description": "A change to a file or shared drive.",
+      "id": "Change",
+      "properties": {
+        "changeType": {
+          "description": "The type of the change. Possible values are file and drive.",
+          "type": "string"
+        },
+        "drive": {
+          "$ref": "Drive",
+          "description": "The updated state of the shared drive. Present if the changeType is drive, the user is still a member of the shared drive, and the shared drive has not been deleted."
+        },
+        "driveId": {
+          "description": "The ID of the shared drive associated with this change.",
+          "type": "string"
+        },
+        "file": {
+          "$ref": "File",
+          "description": "The updated state of the file. Present if the type is file and the file has not been removed from this list of changes."
+        },
+        "fileId": {
+          "description": "The ID of the file which has changed.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "drive#change",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#change\".",
+          "type": "string"
+        },
+        "removed": {
+          "description": "Whether the file or shared drive has been removed from this list of changes, for example by deletion or loss of access.",
+          "type": "boolean"
+        },
+        "teamDrive": {
+          "$ref": "TeamDrive",
+          "description": "Deprecated - use drive instead."
+        },
+        "teamDriveId": {
+          "description": "Deprecated - use driveId instead.",
+          "type": "string"
+        },
+        "time": {
+          "description": "The time of this change (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "type": {
+          "description": "Deprecated - use changeType instead.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ChangeList": {
+      "description": "A list of changes for a user.",
+      "id": "ChangeList",
+      "properties": {
+        "changes": {
+          "description": "The list of changes. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.",
+          "items": {
+            "$ref": "Change"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "drive#changeList",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#changeList\".",
+          "type": "string"
+        },
+        "newStartPageToken": {
+          "description": "The starting page token for future changes. This will be present only if the end of the current changes list has been reached.",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "The page token for the next page of changes. This will be absent if the end of the changes list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Channel": {
+      "description": "An notification channel used to watch for resource changes.",
+      "id": "Channel",
+      "properties": {
+        "address": {
+          "description": "The address where notifications are delivered for this channel.",
+          "type": "string"
+        },
+        "expiration": {
+          "description": "Date and time of notification channel expiration, expressed as a Unix timestamp, in milliseconds. Optional.",
+          "format": "int64",
+          "type": "string"
+        },
+        "id": {
+          "description": "A UUID or similar unique string that identifies this channel.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "api#channel",
+          "description": "Identifies this as a notification channel used to watch for changes to a resource, which is \"api#channel\".",
+          "type": "string"
+        },
+        "params": {
+          "additionalProperties": {
+            "description": "Declares a new parameter by name.",
+            "type": "string"
+          },
+          "description": "Additional parameters controlling delivery channel behavior. Optional.",
+          "type": "object"
+        },
+        "payload": {
+          "description": "A Boolean value to indicate whether payload is wanted. Optional.",
+          "type": "boolean"
+        },
+        "resourceId": {
+          "description": "An opaque ID that identifies the resource being watched on this channel. Stable across different API versions.",
+          "type": "string"
+        },
+        "resourceUri": {
+          "description": "A version-specific identifier for the watched resource.",
+          "type": "string"
+        },
+        "token": {
+          "description": "An arbitrary string delivered to the target address with each notification delivered over this channel. Optional.",
+          "type": "string"
+        },
+        "type": {
+          "description": "The type of delivery mechanism used for this channel. Valid values are \"web_hook\" (or \"webhook\"). Both values refer to a channel where Http requests are used to deliver messages.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Comment": {
+      "description": "A comment on a file.",
+      "id": "Comment",
+      "properties": {
+        "anchor": {
+          "description": "A region of the document represented as a JSON string. See anchor documentation for details on how to define and interpret anchor properties.",
+          "type": "string"
+        },
+        "author": {
+          "$ref": "User",
+          "description": "The author of the comment. The author's email address and permission ID will not be populated."
+        },
+        "content": {
+          "annotations": {
+            "required": [
+              "drive.comments.create",
+              "drive.comments.update"
+            ]
+          },
+          "description": "The plain text content of the comment. This field is used for setting the content, while htmlContent should be displayed.",
+          "type": "string"
+        },
+        "createdTime": {
+          "description": "The time at which the comment was created (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "deleted": {
+          "description": "Whether the comment has been deleted. A deleted comment has no content.",
+          "type": "boolean"
+        },
+        "htmlContent": {
+          "description": "The content of the comment with HTML formatting.",
+          "type": "string"
+        },
+        "id": {
+          "description": "The ID of the comment.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "drive#comment",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#comment\".",
+          "type": "string"
+        },
+        "modifiedTime": {
+          "description": "The last time the comment or any of its replies was modified (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "quotedFileContent": {
+          "description": "The file content to which the comment refers, typically within the anchor region. For a text file, for example, this would be the text at the location of the comment.",
+          "properties": {
+            "mimeType": {
+              "description": "The MIME type of the quoted content.",
+              "type": "string"
+            },
+            "value": {
+              "description": "The quoted content itself. This is interpreted as plain text if set through the API.",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "replies": {
+          "description": "The full list of replies to the comment in chronological order.",
+          "items": {
+            "$ref": "Reply"
+          },
+          "type": "array"
+        },
+        "resolved": {
+          "description": "Whether the comment has been resolved by one of its replies.",
+          "type": "boolean"
+        }
+      },
+      "type": "object"
+    },
+    "CommentList": {
+      "description": "A list of comments on a file.",
+      "id": "CommentList",
+      "properties": {
+        "comments": {
+          "description": "The list of comments. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.",
+          "items": {
+            "$ref": "Comment"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "drive#commentList",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#commentList\".",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "The page token for the next page of comments. This will be absent if the end of the comments list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ContentRestriction": {
+      "description": "A restriction for accessing the content of the file.",
+      "id": "ContentRestriction",
+      "properties": {
+        "readOnly": {
+          "description": "Whether the content of the file is read-only. If a file is read-only, a new revision of the file may not be added, comments may not be added or modified, and the title of the file may not be modified.",
+          "type": "boolean"
+        },
+        "reason": {
+          "description": "Reason for why the content of the file is restricted. This is only mutable on requests that also set readOnly=true.",
+          "type": "string"
+        },
+        "restrictingUser": {
+          "$ref": "User",
+          "description": "The user who set the content restriction. Only populated if readOnly is true."
+        },
+        "restrictionTime": {
+          "description": "The time at which the content restriction was set (formatted RFC 3339 timestamp). Only populated if readOnly is true.",
+          "format": "date-time",
+          "type": "string"
+        },
+        "type": {
+          "description": "The type of the content restriction. Currently the only possible value is globalContentRestriction.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Drive": {
+      "description": "Representation of a shared drive.",
+      "id": "Drive",
+      "properties": {
+        "backgroundImageFile": {
+          "description": "An image file and cropping parameters from which a background image for this shared drive is set. This is a write only field; it can only be set on drive.drives.update requests that don't set themeId. When specified, all fields of the backgroundImageFile must be set.",
+          "properties": {
+            "id": {
+              "description": "The ID of an image file in Google Drive to use for the background image.",
+              "type": "string"
+            },
+            "width": {
+              "description": "The width of the cropped image in the closed range of 0 to 1. This value represents the width of the cropped image divided by the width of the entire image. The height is computed by applying a width to height aspect ratio of 80 to 9. The resulting image must be at least 1280 pixels wide and 144 pixels high.",
+              "format": "float",
+              "type": "number"
+            },
+            "xCoordinate": {
+              "description": "The X coordinate of the upper left corner of the cropping area in the background image. This is a value in the closed range of 0 to 1. This value represents the horizontal distance from the left side of the entire image to the left side of the cropping area divided by the width of the entire image.",
+              "format": "float",
+              "type": "number"
+            },
+            "yCoordinate": {
+              "description": "The Y coordinate of the upper left corner of the cropping area in the background image. This is a value in the closed range of 0 to 1. This value represents the vertical distance from the top side of the entire image to the top side of the cropping area divided by the height of the entire image.",
+              "format": "float",
+              "type": "number"
+            }
+          },
+          "type": "object"
+        },
+        "backgroundImageLink": {
+          "description": "A short-lived link to this shared drive's background image.",
+          "type": "string"
+        },
+        "capabilities": {
+          "description": "Capabilities the current user has on this shared drive.",
+          "properties": {
+            "canAddChildren": {
+              "description": "Whether the current user can add children to folders in this shared drive.",
+              "type": "boolean"
+            },
+            "canChangeCopyRequiresWriterPermissionRestriction": {
+              "description": "Whether the current user can change the copyRequiresWriterPermission restriction of this shared drive.",
+              "type": "boolean"
+            },
+            "canChangeDomainUsersOnlyRestriction": {
+              "description": "Whether the current user can change the domainUsersOnly restriction of this shared drive.",
+              "type": "boolean"
+            },
+            "canChangeDriveBackground": {
+              "description": "Whether the current user can change the background of this shared drive.",
+              "type": "boolean"
+            },
+            "canChangeDriveMembersOnlyRestriction": {
+              "description": "Whether the current user can change the driveMembersOnly restriction of this shared drive.",
+              "type": "boolean"
+            },
+            "canComment": {
+              "description": "Whether the current user can comment on files in this shared drive.",
+              "type": "boolean"
+            },
+            "canCopy": {
+              "description": "Whether the current user can copy files in this shared drive.",
+              "type": "boolean"
+            },
+            "canDeleteChildren": {
+              "description": "Whether the current user can delete children from folders in this shared drive.",
+              "type": "boolean"
+            },
+            "canDeleteDrive": {
+              "description": "Whether the current user can delete this shared drive. Attempting to delete the shared drive may still fail if there are untrashed items inside the shared drive.",
+              "type": "boolean"
+            },
+            "canDownload": {
+              "description": "Whether the current user can download files in this shared drive.",
+              "type": "boolean"
+            },
+            "canEdit": {
+              "description": "Whether the current user can edit files in this shared drive",
+              "type": "boolean"
+            },
+            "canListChildren": {
+              "description": "Whether the current user can list the children of folders in this shared drive.",
+              "type": "boolean"
+            },
+            "canManageMembers": {
+              "description": "Whether the current user can add members to this shared drive or remove them or change their role.",
+              "type": "boolean"
+            },
+            "canReadRevisions": {
+              "description": "Whether the current user can read the revisions resource of files in this shared drive.",
+              "type": "boolean"
+            },
+            "canRename": {
+              "description": "Whether the current user can rename files or folders in this shared drive.",
+              "type": "boolean"
+            },
+            "canRenameDrive": {
+              "description": "Whether the current user can rename this shared drive.",
+              "type": "boolean"
+            },
+            "canShare": {
+              "description": "Whether the current user can share files or folders in this shared drive.",
+              "type": "boolean"
+            },
+            "canTrashChildren": {
+              "description": "Whether the current user can trash children from folders in this shared drive.",
+              "type": "boolean"
+            }
+          },
+          "type": "object"
+        },
+        "colorRgb": {
+          "description": "The color of this shared drive as an RGB hex string. It can only be set on a drive.drives.update request that does not set themeId.",
+          "type": "string"
+        },
+        "createdTime": {
+          "description": "The time at which the shared drive was created (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "hidden": {
+          "description": "Whether the shared drive is hidden from default view.",
+          "type": "boolean"
+        },
+        "id": {
+          "description": "The ID of this shared drive which is also the ID of the top level folder of this shared drive.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "drive#drive",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#drive\".",
+          "type": "string"
+        },
+        "name": {
+          "description": "The name of this shared drive.",
+          "type": "string"
+        },
+        "restrictions": {
+          "description": "A set of restrictions that apply to this shared drive or items inside this shared drive.",
+          "properties": {
+            "adminManagedRestrictions": {
+              "description": "Whether administrative privileges on this shared drive are required to modify restrictions.",
+              "type": "boolean"
+            },
+            "copyRequiresWriterPermission": {
+              "description": "Whether the options to copy, print, or download files inside this shared drive, should be disabled for readers and commenters. When this restriction is set to true, it will override the similarly named field to true for any file inside this shared drive.",
+              "type": "boolean"
+            },
+            "domainUsersOnly": {
+              "description": "Whether access to this shared drive and items inside this shared drive is restricted to users of the domain to which this shared drive belongs. This restriction may be overridden by other sharing policies controlled outside of this shared drive.",
+              "type": "boolean"
+            },
+            "driveMembersOnly": {
+              "description": "Whether access to items inside this shared drive is restricted to its members.",
+              "type": "boolean"
+            }
+          },
+          "type": "object"
+        },
+        "themeId": {
+          "description": "The ID of the theme from which the background image and color will be set. The set of possible driveThemes can be retrieved from a drive.about.get response. When not specified on a drive.drives.create request, a random theme is chosen from which the background image and color are set. This is a write-only field; it can only be set on requests that don't set colorRgb or backgroundImageFile.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "DriveList": {
+      "description": "A list of shared drives.",
+      "id": "DriveList",
+      "properties": {
+        "drives": {
+          "description": "The list of shared drives. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.",
+          "items": {
+            "$ref": "Drive"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "drive#driveList",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#driveList\".",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "The page token for the next page of shared drives. This will be absent if the end of the list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "File": {
+      "description": "The metadata for a file.",
+      "id": "File",
+      "properties": {
+        "appProperties": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "A collection of arbitrary key-value pairs which are private to the requesting app.\nEntries with null values are cleared in update and copy requests. These properties can only be retrieved using an authenticated request. An authenticated request uses an access token obtained with a OAuth 2 client ID. You cannot use an API key to retrieve private properties.",
+          "type": "object"
+        },
+        "capabilities": {
+          "description": "Capabilities the current user has on this file. Each capability corresponds to a fine-grained action that a user may take.",
+          "properties": {
+            "canAddChildren": {
+              "description": "Whether the current user can add children to this folder. This is always false when the item is not a folder.",
+              "type": "boolean"
+            },
+            "canAddFolderFromAnotherDrive": {
+              "description": "Whether the current user can add a folder from another drive (different shared drive or My Drive) to this folder. This is false when the item is not a folder. Only populated for items in shared drives.",
+              "type": "boolean"
+            },
+            "canAddMyDriveParent": {
+              "description": "Whether the current user can add a parent for the item without removing an existing parent in the same request. Not populated for shared drive files.",
+              "type": "boolean"
+            },
+            "canChangeCopyRequiresWriterPermission": {
+              "description": "Whether the current user can change the copyRequiresWriterPermission restriction of this file.",
+              "type": "boolean"
+            },
+            "canChangeViewersCanCopyContent": {
+              "description": "Deprecated",
+              "type": "boolean"
+            },
+            "canComment": {
+              "description": "Whether the current user can comment on this file.",
+              "type": "boolean"
+            },
+            "canCopy": {
+              "description": "Whether the current user can copy this file. For an item in a shared drive, whether the current user can copy non-folder descendants of this item, or this item itself if it is not a folder.",
+              "type": "boolean"
+            },
+            "canDelete": {
+              "description": "Whether the current user can delete this file.",
+              "type": "boolean"
+            },
+            "canDeleteChildren": {
+              "description": "Whether the current user can delete children of this folder. This is false when the item is not a folder. Only populated for items in shared drives.",
+              "type": "boolean"
+            },
+            "canDownload": {
+              "description": "Whether the current user can download this file.",
+              "type": "boolean"
+            },
+            "canEdit": {
+              "description": "Whether the current user can edit this file. Other factors may limit the type of changes a user can make to a file. For example, see canChangeCopyRequiresWriterPermission or canModifyContent.",
+              "type": "boolean"
+            },
+            "canListChildren": {
+              "description": "Whether the current user can list the children of this folder. This is always false when the item is not a folder.",
+              "type": "boolean"
+            },
+            "canModifyContent": {
+              "description": "Whether the current user can modify the content of this file.",
+              "type": "boolean"
+            },
+            "canModifyContentRestriction": {
+              "description": "Whether the current user can modify restrictions on content of this file.",
+              "type": "boolean"
+            },
+            "canMoveChildrenOutOfDrive": {
+              "description": "Whether the current user can move children of this folder outside of the shared drive. This is false when the item is not a folder. Only populated for items in shared drives.",
+              "type": "boolean"
+            },
+            "canMoveChildrenOutOfTeamDrive": {
+              "description": "Deprecated - use canMoveChildrenOutOfDrive instead.",
+              "type": "boolean"
+            },
+            "canMoveChildrenWithinDrive": {
+              "description": "Whether the current user can move children of this folder within this drive. This is false when the item is not a folder. Note that a request to move the child may still fail depending on the current user's access to the child and to the destination folder.",
+              "type": "boolean"
+            },
+            "canMoveChildrenWithinTeamDrive": {
+              "description": "Deprecated - use canMoveChildrenWithinDrive instead.",
+              "type": "boolean"
+            },
+            "canMoveItemIntoTeamDrive": {
+              "description": "Deprecated - use canMoveItemOutOfDrive instead.",
+              "type": "boolean"
+            },
+            "canMoveItemOutOfDrive": {
+              "description": "Whether the current user can move this item outside of this drive by changing its parent. Note that a request to change the parent of the item may still fail depending on the new parent that is being added.",
+              "type": "boolean"
+            },
+            "canMoveItemOutOfTeamDrive": {
+              "description": "Deprecated - use canMoveItemOutOfDrive instead.",
+              "type": "boolean"
+            },
+            "canMoveItemWithinDrive": {
+              "description": "Whether the current user can move this item within this drive. Note that a request to change the parent of the item may still fail depending on the new parent that is being added and the parent that is being removed.",
+              "type": "boolean"
+            },
+            "canMoveItemWithinTeamDrive": {
+              "description": "Deprecated - use canMoveItemWithinDrive instead.",
+              "type": "boolean"
+            },
+            "canMoveTeamDriveItem": {
+              "description": "Deprecated - use canMoveItemWithinDrive or canMoveItemOutOfDrive instead.",
+              "type": "boolean"
+            },
+            "canReadDrive": {
+              "description": "Whether the current user can read the shared drive to which this file belongs. Only populated for items in shared drives.",
+              "type": "boolean"
+            },
+            "canReadRevisions": {
+              "description": "Whether the current user can read the revisions resource of this file. For a shared drive item, whether revisions of non-folder descendants of this item, or this item itself if it is not a folder, can be read.",
+              "type": "boolean"
+            },
+            "canReadTeamDrive": {
+              "description": "Deprecated - use canReadDrive instead.",
+              "type": "boolean"
+            },
+            "canRemoveChildren": {
+              "description": "Whether the current user can remove children from this folder. This is always false when the item is not a folder. For a folder in a shared drive, use canDeleteChildren or canTrashChildren instead.",
+              "type": "boolean"
+            },
+            "canRemoveMyDriveParent": {
+              "description": "Whether the current user can remove a parent from the item without adding another parent in the same request. Not populated for shared drive files.",
+              "type": "boolean"
+            },
+            "canRename": {
+              "description": "Whether the current user can rename this file.",
+              "type": "boolean"
+            },
+            "canShare": {
+              "description": "Whether the current user can modify the sharing settings for this file.",
+              "type": "boolean"
+            },
+            "canTrash": {
+              "description": "Whether the current user can move this file to trash.",
+              "type": "boolean"
+            },
+            "canTrashChildren": {
+              "description": "Whether the current user can trash children of this folder. This is false when the item is not a folder. Only populated for items in shared drives.",
+              "type": "boolean"
+            },
+            "canUntrash": {
+              "description": "Whether the current user can restore this file from trash.",
+              "type": "boolean"
+            }
+          },
+          "type": "object"
+        },
+        "contentHints": {
+          "description": "Additional information about the content of the file. These fields are never populated in responses.",
+          "properties": {
+            "indexableText": {
+              "description": "Text to be indexed for the file to improve fullText queries. This is limited to 128KB in length and may contain HTML elements.",
+              "type": "string"
+            },
+            "thumbnail": {
+              "description": "A thumbnail for the file. This will only be used if Google Drive cannot generate a standard thumbnail.",
+              "properties": {
+                "image": {
+                  "description": "The thumbnail data encoded with URL-safe Base64 (RFC 4648 section 5).",
+                  "format": "byte",
+                  "type": "string"
+                },
+                "mimeType": {
+                  "description": "The MIME type of the thumbnail.",
+                  "type": "string"
+                }
+              },
+              "type": "object"
+            }
+          },
+          "type": "object"
+        },
+        "contentRestrictions": {
+          "description": "Restrictions for accessing the content of the file. Only populated if such a restriction exists.",
+          "items": {
+            "$ref": "ContentRestriction"
+          },
+          "type": "array"
+        },
+        "copyRequiresWriterPermission": {
+          "description": "Whether the options to copy, print, or download this file, should be disabled for readers and commenters.",
+          "type": "boolean"
+        },
+        "createdTime": {
+          "description": "The time at which the file was created (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "description": {
+          "description": "A short description of the file.",
+          "type": "string"
+        },
+        "driveId": {
+          "description": "ID of the shared drive the file resides in. Only populated for items in shared drives.",
+          "type": "string"
+        },
+        "explicitlyTrashed": {
+          "description": "Whether the file has been explicitly trashed, as opposed to recursively trashed from a parent folder.",
+          "type": "boolean"
+        },
+        "exportLinks": {
+          "additionalProperties": {
+            "description": "A mapping from export format to URL",
+            "type": "string"
+          },
+          "description": "Links for exporting Docs Editors files to specific formats.",
+          "type": "object"
+        },
+        "fileExtension": {
+          "description": "The final component of fullFileExtension. This is only available for files with binary content in Google Drive.",
+          "type": "string"
+        },
+        "folderColorRgb": {
+          "description": "The color for a folder as an RGB hex string. The supported colors are published in the folderColorPalette field of the About resource.\nIf an unsupported color is specified, the closest color in the palette will be used instead.",
+          "type": "string"
+        },
+        "fullFileExtension": {
+          "description": "The full file extension extracted from the name field. May contain multiple concatenated extensions, such as \"tar.gz\". This is only available for files with binary content in Google Drive.\nThis is automatically updated when the name field changes, however it is not cleared if the new name does not contain a valid extension.",
+          "type": "string"
+        },
+        "hasAugmentedPermissions": {
+          "description": "Whether there are permissions directly on this file. This field is only populated for items in shared drives.",
+          "type": "boolean"
+        },
+        "hasThumbnail": {
+          "description": "Whether this file has a thumbnail. This does not indicate whether the requesting app has access to the thumbnail. To check access, look for the presence of the thumbnailLink field.",
+          "type": "boolean"
+        },
+        "headRevisionId": {
+          "description": "The ID of the file's head revision. This is currently only available for files with binary content in Google Drive.",
+          "type": "string"
+        },
+        "iconLink": {
+          "description": "A static, unauthenticated link to the file's icon.",
+          "type": "string"
+        },
+        "id": {
+          "description": "The ID of the file.",
+          "type": "string"
+        },
+        "imageMediaMetadata": {
+          "description": "Additional metadata about image media, if available.",
+          "properties": {
+            "aperture": {
+              "description": "The aperture used to create the photo (f-number).",
+              "format": "float",
+              "type": "number"
+            },
+            "cameraMake": {
+              "description": "The make of the camera used to create the photo.",
+              "type": "string"
+            },
+            "cameraModel": {
+              "description": "The model of the camera used to create the photo.",
+              "type": "string"
+            },
+            "colorSpace": {
+              "description": "The color space of the photo.",
+              "type": "string"
+            },
+            "exposureBias": {
+              "description": "The exposure bias of the photo (APEX value).",
+              "format": "float",
+              "type": "number"
+            },
+            "exposureMode": {
+              "description": "The exposure mode used to create the photo.",
+              "type": "string"
+            },
+            "exposureTime": {
+              "description": "The length of the exposure, in seconds.",
+              "format": "float",
+              "type": "number"
+            },
+            "flashUsed": {
+              "description": "Whether a flash was used to create the photo.",
+              "type": "boolean"
+            },
+            "focalLength": {
+              "description": "The focal length used to create the photo, in millimeters.",
+              "format": "float",
+              "type": "number"
+            },
+            "height": {
+              "description": "The height of the image in pixels.",
+              "format": "int32",
+              "type": "integer"
+            },
+            "isoSpeed": {
+              "description": "The ISO speed used to create the photo.",
+              "format": "int32",
+              "type": "integer"
+            },
+            "lens": {
+              "description": "The lens used to create the photo.",
+              "type": "string"
+            },
+            "location": {
+              "description": "Geographic location information stored in the image.",
+              "properties": {
+                "altitude": {
+                  "description": "The altitude stored in the image.",
+                  "format": "double",
+                  "type": "number"
+                },
+                "latitude": {
+                  "description": "The latitude stored in the image.",
+                  "format": "double",
+                  "type": "number"
+                },
+                "longitude": {
+                  "description": "The longitude stored in the image.",
+                  "format": "double",
+                  "type": "number"
+                }
+              },
+              "type": "object"
+            },
+            "maxApertureValue": {
+              "description": "The smallest f-number of the lens at the focal length used to create the photo (APEX value).",
+              "format": "float",
+              "type": "number"
+            },
+            "meteringMode": {
+              "description": "The metering mode used to create the photo.",
+              "type": "string"
+            },
+            "rotation": {
+              "description": "The number of clockwise 90 degree rotations applied from the image's original orientation.",
+              "format": "int32",
+              "type": "integer"
+            },
+            "sensor": {
+              "description": "The type of sensor used to create the photo.",
+              "type": "string"
+            },
+            "subjectDistance": {
+              "description": "The distance to the subject of the photo, in meters.",
+              "format": "int32",
+              "type": "integer"
+            },
+            "time": {
+              "description": "The date and time the photo was taken (EXIF DateTime).",
+              "type": "string"
+            },
+            "whiteBalance": {
+              "description": "The white balance mode used to create the photo.",
+              "type": "string"
+            },
+            "width": {
+              "description": "The width of the image in pixels.",
+              "format": "int32",
+              "type": "integer"
+            }
+          },
+          "type": "object"
+        },
+        "isAppAuthorized": {
+          "description": "Whether the file was created or opened by the requesting app.",
+          "type": "boolean"
+        },
+        "kind": {
+          "default": "drive#file",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#file\".",
+          "type": "string"
+        },
+        "lastModifyingUser": {
+          "$ref": "User",
+          "description": "The last user to modify the file."
+        },
+        "md5Checksum": {
+          "description": "The MD5 checksum for the content of the file. This is only applicable to files with binary content in Google Drive.",
+          "type": "string"
+        },
+        "mimeType": {
+          "description": "The MIME type of the file.\nGoogle Drive will attempt to automatically detect an appropriate value from uploaded content if no value is provided. The value cannot be changed unless a new revision is uploaded.\nIf a file is created with a Google Doc MIME type, the uploaded content will be imported if possible. The supported import formats are published in the About resource.",
+          "type": "string"
+        },
+        "modifiedByMe": {
+          "description": "Whether the file has been modified by this user.",
+          "type": "boolean"
+        },
+        "modifiedByMeTime": {
+          "description": "The last time the file was modified by the user (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "modifiedTime": {
+          "description": "The last time the file was modified by anyone (RFC 3339 date-time).\nNote that setting modifiedTime will also update modifiedByMeTime for the user.",
+          "format": "date-time",
+          "type": "string"
+        },
+        "name": {
+          "description": "The name of the file. This is not necessarily unique within a folder. Note that for immutable items such as the top level folders of shared drives, My Drive root folder, and Application Data folder the name is constant.",
+          "type": "string"
+        },
+        "originalFilename": {
+          "description": "The original filename of the uploaded content if available, or else the original value of the name field. This is only available for files with binary content in Google Drive.",
+          "type": "string"
+        },
+        "ownedByMe": {
+          "description": "Whether the user owns the file. Not populated for items in shared drives.",
+          "type": "boolean"
+        },
+        "owners": {
+          "description": "The owners of the file. Currently, only certain legacy files may have more than one owner. Not populated for items in shared drives.",
+          "items": {
+            "$ref": "User"
+          },
+          "type": "array"
+        },
+        "parents": {
+          "description": "The IDs of the parent folders which contain the file.\nIf not specified as part of a create request, the file will be placed directly in the user's My Drive folder. If not specified as part of a copy request, the file will inherit any discoverable parents of the source file. Update requests must use the addParents and removeParents parameters to modify the parents list.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "permissionIds": {
+          "description": "List of permission IDs for users with access to this file.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "permissions": {
+          "description": "The full list of permissions for the file. This is only available if the requesting user can share the file. Not populated for items in shared drives.",
+          "items": {
+            "$ref": "Permission"
+          },
+          "type": "array"
+        },
+        "properties": {
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "A collection of arbitrary key-value pairs which are visible to all apps.\nEntries with null values are cleared in update and copy requests.",
+          "type": "object"
+        },
+        "quotaBytesUsed": {
+          "description": "The number of storage quota bytes used by the file. This includes the head revision as well as previous revisions with keepForever enabled.",
+          "format": "int64",
+          "type": "string"
+        },
+        "shared": {
+          "description": "Whether the file has been shared. Not populated for items in shared drives.",
+          "type": "boolean"
+        },
+        "sharedWithMeTime": {
+          "description": "The time at which the file was shared with the user, if applicable (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "sharingUser": {
+          "$ref": "User",
+          "description": "The user who shared the file with the requesting user, if applicable."
+        },
+        "shortcutDetails": {
+          "description": "Shortcut file details. Only populated for shortcut files, which have the mimeType field set to application/vnd.google-apps.shortcut.",
+          "properties": {
+            "targetId": {
+              "description": "The ID of the file that this shortcut points to.",
+              "type": "string"
+            },
+            "targetMimeType": {
+              "description": "The MIME type of the file that this shortcut points to. The value of this field is a snapshot of the target's MIME type, captured when the shortcut is created.",
+              "type": "string"
+            }
+          },
+          "type": "object"
+        },
+        "size": {
+          "description": "The size of the file's content in bytes. This is applicable to binary files in Google Drive and Google Docs files.",
+          "format": "int64",
+          "type": "string"
+        },
+        "spaces": {
+          "description": "The list of spaces which contain the file. The currently supported values are 'drive', 'appDataFolder' and 'photos'.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "starred": {
+          "description": "Whether the user has starred the file.",
+          "type": "boolean"
+        },
+        "teamDriveId": {
+          "description": "Deprecated - use driveId instead.",
+          "type": "string"
+        },
+        "thumbnailLink": {
+          "description": "A short-lived link to the file's thumbnail, if available. Typically lasts on the order of hours. Only populated when the requesting app can access the file's content. If the file isn't shared publicly, the URL returned in Files.thumbnailLink must be fetched using a credentialed request.",
+          "type": "string"
+        },
+        "thumbnailVersion": {
+          "description": "The thumbnail version for use in thumbnail cache invalidation.",
+          "format": "int64",
+          "type": "string"
+        },
+        "trashed": {
+          "description": "Whether the file has been trashed, either explicitly or from a trashed parent folder. Only the owner may trash a file. The trashed item is excluded from all files.list responses returned for any user who does not own the file. However, all users with access to the file can see the trashed item metadata in an API response. All users with access can copy, download, export, and share the file.",
+          "type": "boolean"
+        },
+        "trashedTime": {
+          "description": "The time that the item was trashed (RFC 3339 date-time). Only populated for items in shared drives.",
+          "format": "date-time",
+          "type": "string"
+        },
+        "trashingUser": {
+          "$ref": "User",
+          "description": "If the file has been explicitly trashed, the user who trashed it. Only populated for items in shared drives."
+        },
+        "version": {
+          "description": "A monotonically increasing version number for the file. This reflects every change made to the file on the server, even those not visible to the user.",
+          "format": "int64",
+          "type": "string"
+        },
+        "videoMediaMetadata": {
+          "description": "Additional metadata about video media. This may not be available immediately upon upload.",
+          "properties": {
+            "durationMillis": {
+              "description": "The duration of the video in milliseconds.",
+              "format": "int64",
+              "type": "string"
+            },
+            "height": {
+              "description": "The height of the video in pixels.",
+              "format": "int32",
+              "type": "integer"
+            },
+            "width": {
+              "description": "The width of the video in pixels.",
+              "format": "int32",
+              "type": "integer"
+            }
+          },
+          "type": "object"
+        },
+        "viewedByMe": {
+          "description": "Whether the file has been viewed by this user.",
+          "type": "boolean"
+        },
+        "viewedByMeTime": {
+          "description": "The last time the file was viewed by the user (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "viewersCanCopyContent": {
+          "description": "Deprecated - use copyRequiresWriterPermission instead.",
+          "type": "boolean"
+        },
+        "webContentLink": {
+          "description": "A link for downloading the content of the file in a browser. This is only available for files with binary content in Google Drive.",
+          "type": "string"
+        },
+        "webViewLink": {
+          "description": "A link for opening the file in a relevant Google editor or viewer in a browser.",
+          "type": "string"
+        },
+        "writersCanShare": {
+          "description": "Whether users with only writer permission can modify the file's permissions. Not populated for items in shared drives.",
+          "type": "boolean"
+        }
+      },
+      "type": "object"
+    },
+    "FileList": {
+      "description": "A list of files.",
+      "id": "FileList",
+      "properties": {
+        "files": {
+          "description": "The list of files. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.",
+          "items": {
+            "$ref": "File"
+          },
+          "type": "array"
+        },
+        "incompleteSearch": {
+          "description": "Whether the search process was incomplete. If true, then some search results may be missing, since all documents were not searched. This may occur when searching multiple drives with the \"allDrives\" corpora, but all corpora could not be searched. When this happens, it is suggested that clients narrow their query by choosing a different corpus such as \"user\" or \"drive\".",
+          "type": "boolean"
+        },
+        "kind": {
+          "default": "drive#fileList",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#fileList\".",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "The page token for the next page of files. This will be absent if the end of the files list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "GeneratedIds": {
+      "description": "A list of generated file IDs which can be provided in create requests.",
+      "id": "GeneratedIds",
+      "properties": {
+        "ids": {
+          "description": "The IDs generated for the requesting user in the specified space.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "kind": {
+          "default": "drive#generatedIds",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#generatedIds\".",
+          "type": "string"
+        },
+        "space": {
+          "description": "The type of file that can be created with these IDs.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "Permission": {
+      "description": "A permission for a file. A permission grants a user, group, domain or the world access to a file or a folder hierarchy.",
+      "id": "Permission",
+      "properties": {
+        "allowFileDiscovery": {
+          "description": "Whether the permission allows the file to be discovered through search. This is only applicable for permissions of type domain or anyone.",
+          "type": "boolean"
+        },
+        "deleted": {
+          "description": "Whether the account associated with this permission has been deleted. This field only pertains to user and group permissions.",
+          "type": "boolean"
+        },
+        "displayName": {
+          "description": "The \"pretty\" name of the value of the permission. The following is a list of examples for each type of permission:  \n- user - User's full name, as defined for their Google account, such as \"Joe Smith.\" \n- group - Name of the Google Group, such as \"The Company Administrators.\" \n- domain - String domain name, such as \"thecompany.com.\" \n- anyone - No displayName is present.",
+          "type": "string"
+        },
+        "domain": {
+          "description": "The domain to which this permission refers.",
+          "type": "string"
+        },
+        "emailAddress": {
+          "description": "The email address of the user or group to which this permission refers.",
+          "type": "string"
+        },
+        "expirationTime": {
+          "description": "The time at which this permission will expire (RFC 3339 date-time). Expiration times have the following restrictions:  \n- They can only be set on user and group permissions \n- The time must be in the future \n- The time cannot be more than a year in the future",
+          "format": "date-time",
+          "type": "string"
+        },
+        "id": {
+          "description": "The ID of this permission. This is a unique identifier for the grantee, and is published in User resources as permissionId. IDs should be treated as opaque values.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "drive#permission",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#permission\".",
+          "type": "string"
+        },
+        "permissionDetails": {
+          "description": "Details of whether the permissions on this shared drive item are inherited or directly on this item. This is an output-only field which is present only for shared drive items.",
+          "items": {
+            "properties": {
+              "inherited": {
+                "description": "Whether this permission is inherited. This field is always populated. This is an output-only field.",
+                "type": "boolean"
+              },
+              "inheritedFrom": {
+                "description": "The ID of the item from which this permission is inherited. This is an output-only field.",
+                "type": "string"
+              },
+              "permissionType": {
+                "description": "The permission type for this user. While new values may be added in future, the following are currently possible:  \n- file \n- member",
+                "type": "string"
+              },
+              "role": {
+                "description": "The primary role for this user. While new values may be added in the future, the following are currently possible:  \n- organizer \n- fileOrganizer \n- writer \n- commenter \n- reader",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "photoLink": {
+          "description": "A link to the user's profile photo, if available.",
+          "type": "string"
+        },
+        "role": {
+          "annotations": {
+            "required": [
+              "drive.permissions.create"
+            ]
+          },
+          "description": "The role granted by this permission. While new values may be supported in the future, the following are currently allowed:  \n- owner \n- organizer \n- fileOrganizer \n- writer \n- commenter \n- reader",
+          "type": "string"
+        },
+        "teamDrivePermissionDetails": {
+          "description": "Deprecated - use permissionDetails instead.",
+          "items": {
+            "properties": {
+              "inherited": {
+                "description": "Deprecated - use permissionDetails/inherited instead.",
+                "type": "boolean"
+              },
+              "inheritedFrom": {
+                "description": "Deprecated - use permissionDetails/inheritedFrom instead.",
+                "type": "string"
+              },
+              "role": {
+                "description": "Deprecated - use permissionDetails/role instead.",
+                "type": "string"
+              },
+              "teamDrivePermissionType": {
+                "description": "Deprecated - use permissionDetails/permissionType instead.",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "type": "array"
+        },
+        "type": {
+          "annotations": {
+            "required": [
+              "drive.permissions.create"
+            ]
+          },
+          "description": "The type of the grantee. Valid values are:  \n- user \n- group \n- domain \n- anyone  When creating a permission, if type is user or group, you must provide an emailAddress for the user or group. When type is domain, you must provide a domain. There isn't extra information required for a anyone type.",
+          "type": "string"
+        },
+        "view": {
+          "description": "Indicates the view for this permission. Only populated for permissions that belong to a view. published is the only supported value.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "PermissionList": {
+      "description": "A list of permissions for a file.",
+      "id": "PermissionList",
+      "properties": {
+        "kind": {
+          "default": "drive#permissionList",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#permissionList\".",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "The page token for the next page of permissions. This field will be absent if the end of the permissions list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results.",
+          "type": "string"
+        },
+        "permissions": {
+          "description": "The list of permissions. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.",
+          "items": {
+            "$ref": "Permission"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "Reply": {
+      "description": "A reply to a comment on a file.",
+      "id": "Reply",
+      "properties": {
+        "action": {
+          "description": "The action the reply performed to the parent comment. Valid values are:  \n- resolve \n- reopen",
+          "type": "string"
+        },
+        "author": {
+          "$ref": "User",
+          "description": "The author of the reply. The author's email address and permission ID will not be populated."
+        },
+        "content": {
+          "annotations": {
+            "required": [
+              "drive.replies.update"
+            ]
+          },
+          "description": "The plain text content of the reply. This field is used for setting the content, while htmlContent should be displayed. This is required on creates if no action is specified.",
+          "type": "string"
+        },
+        "createdTime": {
+          "description": "The time at which the reply was created (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "deleted": {
+          "description": "Whether the reply has been deleted. A deleted reply has no content.",
+          "type": "boolean"
+        },
+        "htmlContent": {
+          "description": "The content of the reply with HTML formatting.",
+          "type": "string"
+        },
+        "id": {
+          "description": "The ID of the reply.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "drive#reply",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#reply\".",
+          "type": "string"
+        },
+        "modifiedTime": {
+          "description": "The last time the reply was modified (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "ReplyList": {
+      "description": "A list of replies to a comment on a file.",
+      "id": "ReplyList",
+      "properties": {
+        "kind": {
+          "default": "drive#replyList",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#replyList\".",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "The page token for the next page of replies. This will be absent if the end of the replies list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results.",
+          "type": "string"
+        },
+        "replies": {
+          "description": "The list of replies. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.",
+          "items": {
+            "$ref": "Reply"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "Revision": {
+      "description": "The metadata for a revision to a file.",
+      "id": "Revision",
+      "properties": {
+        "exportLinks": {
+          "additionalProperties": {
+            "description": "A mapping from export format to URL",
+            "type": "string"
+          },
+          "description": "Links for exporting Docs Editors files to specific formats.",
+          "type": "object"
+        },
+        "id": {
+          "description": "The ID of the revision.",
+          "type": "string"
+        },
+        "keepForever": {
+          "description": "Whether to keep this revision forever, even if it is no longer the head revision. If not set, the revision will be automatically purged 30 days after newer content is uploaded. This can be set on a maximum of 200 revisions for a file.\nThis field is only applicable to files with binary content in Drive.",
+          "type": "boolean"
+        },
+        "kind": {
+          "default": "drive#revision",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#revision\".",
+          "type": "string"
+        },
+        "lastModifyingUser": {
+          "$ref": "User",
+          "description": "The last user to modify this revision."
+        },
+        "md5Checksum": {
+          "description": "The MD5 checksum of the revision's content. This is only applicable to files with binary content in Drive.",
+          "type": "string"
+        },
+        "mimeType": {
+          "description": "The MIME type of the revision.",
+          "type": "string"
+        },
+        "modifiedTime": {
+          "description": "The last time the revision was modified (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "originalFilename": {
+          "description": "The original filename used to create this revision. This is only applicable to files with binary content in Drive.",
+          "type": "string"
+        },
+        "publishAuto": {
+          "description": "Whether subsequent revisions will be automatically republished. This is only applicable to Docs Editors files.",
+          "type": "boolean"
+        },
+        "published": {
+          "description": "Whether this revision is published. This is only applicable to Docs Editors files.",
+          "type": "boolean"
+        },
+        "publishedLink": {
+          "description": "A link to the published revision. This is only populated for Google Sites files.",
+          "type": "string"
+        },
+        "publishedOutsideDomain": {
+          "description": "Whether this revision is published outside the domain. This is only applicable to Docs Editors files.",
+          "type": "boolean"
+        },
+        "size": {
+          "description": "The size of the revision's content in bytes. This is only applicable to files with binary content in Drive.",
+          "format": "int64",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "RevisionList": {
+      "description": "A list of revisions of a file.",
+      "id": "RevisionList",
+      "properties": {
+        "kind": {
+          "default": "drive#revisionList",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#revisionList\".",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "The page token for the next page of revisions. This will be absent if the end of the revisions list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results.",
+          "type": "string"
+        },
+        "revisions": {
+          "description": "The list of revisions. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.",
+          "items": {
+            "$ref": "Revision"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "StartPageToken": {
+      "id": "StartPageToken",
+      "properties": {
+        "kind": {
+          "default": "drive#startPageToken",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#startPageToken\".",
+          "type": "string"
+        },
+        "startPageToken": {
+          "description": "The starting page token for listing changes.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "TeamDrive": {
+      "description": "Deprecated: use the drive collection instead.",
+      "id": "TeamDrive",
+      "properties": {
+        "backgroundImageFile": {
+          "description": "An image file and cropping parameters from which a background image for this Team Drive is set. This is a write only field; it can only be set on drive.teamdrives.update requests that don't set themeId. When specified, all fields of the backgroundImageFile must be set.",
+          "properties": {
+            "id": {
+              "description": "The ID of an image file in Drive to use for the background image.",
+              "type": "string"
+            },
+            "width": {
+              "description": "The width of the cropped image in the closed range of 0 to 1. This value represents the width of the cropped image divided by the width of the entire image. The height is computed by applying a width to height aspect ratio of 80 to 9. The resulting image must be at least 1280 pixels wide and 144 pixels high.",
+              "format": "float",
+              "type": "number"
+            },
+            "xCoordinate": {
+              "description": "The X coordinate of the upper left corner of the cropping area in the background image. This is a value in the closed range of 0 to 1. This value represents the horizontal distance from the left side of the entire image to the left side of the cropping area divided by the width of the entire image.",
+              "format": "float",
+              "type": "number"
+            },
+            "yCoordinate": {
+              "description": "The Y coordinate of the upper left corner of the cropping area in the background image. This is a value in the closed range of 0 to 1. This value represents the vertical distance from the top side of the entire image to the top side of the cropping area divided by the height of the entire image.",
+              "format": "float",
+              "type": "number"
+            }
+          },
+          "type": "object"
+        },
+        "backgroundImageLink": {
+          "description": "A short-lived link to this Team Drive's background image.",
+          "type": "string"
+        },
+        "capabilities": {
+          "description": "Capabilities the current user has on this Team Drive.",
+          "properties": {
+            "canAddChildren": {
+              "description": "Whether the current user can add children to folders in this Team Drive.",
+              "type": "boolean"
+            },
+            "canChangeCopyRequiresWriterPermissionRestriction": {
+              "description": "Whether the current user can change the copyRequiresWriterPermission restriction of this Team Drive.",
+              "type": "boolean"
+            },
+            "canChangeDomainUsersOnlyRestriction": {
+              "description": "Whether the current user can change the domainUsersOnly restriction of this Team Drive.",
+              "type": "boolean"
+            },
+            "canChangeTeamDriveBackground": {
+              "description": "Whether the current user can change the background of this Team Drive.",
+              "type": "boolean"
+            },
+            "canChangeTeamMembersOnlyRestriction": {
+              "description": "Whether the current user can change the teamMembersOnly restriction of this Team Drive.",
+              "type": "boolean"
+            },
+            "canComment": {
+              "description": "Whether the current user can comment on files in this Team Drive.",
+              "type": "boolean"
+            },
+            "canCopy": {
+              "description": "Whether the current user can copy files in this Team Drive.",
+              "type": "boolean"
+            },
+            "canDeleteChildren": {
+              "description": "Whether the current user can delete children from folders in this Team Drive.",
+              "type": "boolean"
+            },
+            "canDeleteTeamDrive": {
+              "description": "Whether the current user can delete this Team Drive. Attempting to delete the Team Drive may still fail if there are untrashed items inside the Team Drive.",
+              "type": "boolean"
+            },
+            "canDownload": {
+              "description": "Whether the current user can download files in this Team Drive.",
+              "type": "boolean"
+            },
+            "canEdit": {
+              "description": "Whether the current user can edit files in this Team Drive",
+              "type": "boolean"
+            },
+            "canListChildren": {
+              "description": "Whether the current user can list the children of folders in this Team Drive.",
+              "type": "boolean"
+            },
+            "canManageMembers": {
+              "description": "Whether the current user can add members to this Team Drive or remove them or change their role.",
+              "type": "boolean"
+            },
+            "canReadRevisions": {
+              "description": "Whether the current user can read the revisions resource of files in this Team Drive.",
+              "type": "boolean"
+            },
+            "canRemoveChildren": {
+              "description": "Deprecated - use canDeleteChildren or canTrashChildren instead.",
+              "type": "boolean"
+            },
+            "canRename": {
+              "description": "Whether the current user can rename files or folders in this Team Drive.",
+              "type": "boolean"
+            },
+            "canRenameTeamDrive": {
+              "description": "Whether the current user can rename this Team Drive.",
+              "type": "boolean"
+            },
+            "canShare": {
+              "description": "Whether the current user can share files or folders in this Team Drive.",
+              "type": "boolean"
+            },
+            "canTrashChildren": {
+              "description": "Whether the current user can trash children from folders in this Team Drive.",
+              "type": "boolean"
+            }
+          },
+          "type": "object"
+        },
+        "colorRgb": {
+          "description": "The color of this Team Drive as an RGB hex string. It can only be set on a drive.teamdrives.update request that does not set themeId.",
+          "type": "string"
+        },
+        "createdTime": {
+          "description": "The time at which the Team Drive was created (RFC 3339 date-time).",
+          "format": "date-time",
+          "type": "string"
+        },
+        "id": {
+          "description": "The ID of this Team Drive which is also the ID of the top level folder of this Team Drive.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "drive#teamDrive",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#teamDrive\".",
+          "type": "string"
+        },
+        "name": {
+          "description": "The name of this Team Drive.",
+          "type": "string"
+        },
+        "restrictions": {
+          "description": "A set of restrictions that apply to this Team Drive or items inside this Team Drive.",
+          "properties": {
+            "adminManagedRestrictions": {
+              "description": "Whether administrative privileges on this Team Drive are required to modify restrictions.",
+              "type": "boolean"
+            },
+            "copyRequiresWriterPermission": {
+              "description": "Whether the options to copy, print, or download files inside this Team Drive, should be disabled for readers and commenters. When this restriction is set to true, it will override the similarly named field to true for any file inside this Team Drive.",
+              "type": "boolean"
+            },
+            "domainUsersOnly": {
+              "description": "Whether access to this Team Drive and items inside this Team Drive is restricted to users of the domain to which this Team Drive belongs. This restriction may be overridden by other sharing policies controlled outside of this Team Drive.",
+              "type": "boolean"
+            },
+            "teamMembersOnly": {
+              "description": "Whether access to items inside this Team Drive is restricted to members of this Team Drive.",
+              "type": "boolean"
+            }
+          },
+          "type": "object"
+        },
+        "themeId": {
+          "description": "The ID of the theme from which the background image and color will be set. The set of possible teamDriveThemes can be retrieved from a drive.about.get response. When not specified on a drive.teamdrives.create request, a random theme is chosen from which the background image and color are set. This is a write-only field; it can only be set on requests that don't set colorRgb or backgroundImageFile.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    },
+    "TeamDriveList": {
+      "description": "A list of Team Drives.",
+      "id": "TeamDriveList",
+      "properties": {
+        "kind": {
+          "default": "drive#teamDriveList",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#teamDriveList\".",
+          "type": "string"
+        },
+        "nextPageToken": {
+          "description": "The page token for the next page of Team Drives. This will be absent if the end of the Team Drives list has been reached. If the token is rejected for any reason, it should be discarded, and pagination should be restarted from the first page of results.",
+          "type": "string"
+        },
+        "teamDrives": {
+          "description": "The list of Team Drives. If nextPageToken is populated, then this list may be incomplete and an additional page of results should be fetched.",
+          "items": {
+            "$ref": "TeamDrive"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
+    "User": {
+      "description": "Information about a Drive user.",
+      "id": "User",
+      "properties": {
+        "displayName": {
+          "description": "A plain text displayable name for this user.",
+          "type": "string"
+        },
+        "emailAddress": {
+          "description": "The email address of the user. This may not be present in certain contexts if the user has not made their email address visible to the requester.",
+          "type": "string"
+        },
+        "kind": {
+          "default": "drive#user",
+          "description": "Identifies what kind of resource this is. Value: the fixed string \"drive#user\".",
+          "type": "string"
+        },
+        "me": {
+          "description": "Whether this user is the requesting user.",
+          "type": "boolean"
+        },
+        "permissionId": {
+          "description": "The user's ID as visible in Permission resources.",
+          "type": "string"
+        },
+        "photoLink": {
+          "description": "A link to the user's profile photo, if available.",
+          "type": "string"
+        }
+      },
+      "type": "object"
+    }
+  },
+  "servicePath": "drive/v3/",
+  "title": "Drive API",
+  "version": "v3"
+}
\ No newline at end of file
diff --git a/scripts/updatediscoveryartifacts.py b/scripts/updatediscoveryartifacts.py
new file mode 100644
index 0000000..1821ba8
--- /dev/null
+++ b/scripts/updatediscoveryartifacts.py
@@ -0,0 +1,72 @@
+# Copyright 2021 Google LLC
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     https://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import pathlib
+import shutil
+import subprocess
+import tempfile
+
+import describe
+import changesummary
+
+
+SCRIPTS_DIR = pathlib.Path(__file__).parent.resolve()
+DISCOVERY_DOC_DIR = SCRIPTS_DIR / ".." / "googleapiclient" / "discovery_cache" / "documents"
+REFERENCE_DOC_DIR = SCRIPTS_DIR / ".." / "docs" / "dyn"
+TEMP_DIR = SCRIPTS_DIR / "temp"
+
+# Clear discovery documents and reference documents directory
+shutil.rmtree(DISCOVERY_DOC_DIR, ignore_errors=True)
+shutil.rmtree(REFERENCE_DOC_DIR, ignore_errors=True)
+
+# Clear temporary directory
+shutil.rmtree(TEMP_DIR, ignore_errors=True)
+
+# Check out a fresh copy
+subprocess.call(['git', 'checkout', DISCOVERY_DOC_DIR])
+subprocess.call(['git', 'checkout', REFERENCE_DOC_DIR])
+
+# Snapshot current discovery artifacts to a temporary directory
+with tempfile.TemporaryDirectory() as current_discovery_doc_dir:
+    shutil.copytree(DISCOVERY_DOC_DIR, current_discovery_doc_dir, dirs_exist_ok=True)
+
+    # Download discovery artifacts and generate documentation
+    describe.generate_all_api_documents()
+
+    # Get a list of files changed using `git diff`
+    git_diff_output = subprocess.check_output(['git',
+                                      'diff',
+                                      'origin/master',
+                                      '--name-only',
+                                      '--',
+                                      DISCOVERY_DOC_DIR / '*.json',
+                                      REFERENCE_DOC_DIR / '*.html',
+                                      REFERENCE_DOC_DIR / '*.md',
+                                      ],
+                                      universal_newlines=True)
+
+    # Create lists of the changed files
+    all_changed_files = [pathlib.Path(file_name).name for file_name in git_diff_output.split('\n')]
+    json_changed_files = [file for file in all_changed_files if file.endswith(".json")]
+
+    # Create temporary directory
+    pathlib.Path(TEMP_DIR).mkdir()
+
+    # Analyze the changes in discovery artifacts using the changesummary module
+    changesummary.ChangeSummary(DISCOVERY_DOC_DIR, current_discovery_doc_dir, TEMP_DIR, json_changed_files).detect_discovery_changes()
+
+    # Write a list of the files changed to a file called `changed files` which will be used in the `createcommits.sh` script.
+    with open(TEMP_DIR / "changed_files", "w") as f:
+        f.writelines('\n'.join(all_changed_files))