# BigQuery API — Full Reference Manifest
# Auto-generated by reference.py — DO NOT HAND-EDIT
# This file contains EVERY schema and operation from the discovery doc.
# Use it as a reference when extending codegen/manifests/bigquery.toml
#
# Schemas: 208 total, 25 in manifest
# Operations: 47 total, 16 in manifest
#
# Legend:
# [IN MANIFEST] = already in the curated manifest
# format: byte = needs format = "bytes" override
# RESERVED_WORD = needs rust_name + serde_rename override
# ======================================================================
# SCHEMAS (208 total)
# ======================================================================
# --- AggregateClassificationMetrics (7 fields) ---
# Aggregate metrics for classification/classifier models. For multi-class models, the metrics are eith
# [[types]]
# schema = "AggregateClassificationMetrics"
# include_fields = ["accuracy", "f1Score", "logLoss", "precision", "recall", "rocAuc", "threshold"]
#
# accuracy: number, format: double
# f1Score: number, format: double
# logLoss: number, format: double
# precision: number, format: double
# recall: number, format: double
# rocAuc: number, format: double
# threshold: number, format: double
# --- AggregationThresholdPolicy (2 fields) ---
# Represents privacy policy associated with "aggregation threshold" method.
# [[types]]
# schema = "AggregationThresholdPolicy"
# include_fields = ["privacyUnitColumns", "threshold"]
#
# privacyUnitColumns: array<string>
# threshold: string, format: int64
# --- Argument (5 fields) ---
# Input/output argument of a function or a stored procedure.
# [[types]]
# schema = "Argument"
# include_fields = ["argumentKind", "dataType", "isAggregate", "mode", "name"]
#
# argumentKind: string, enum: [ARGUMENT_KIND_UNSPECIFIED, FIXED_TYPE, ANY_TYPE]
# dataType: $ref: StandardSqlDataType
# isAggregate: boolean
# mode: string, enum: [MODE_UNSPECIFIED, IN, OUT, INOUT]
# name: string
#
# [types.field_overrides]
# name = { required = true }
# # argumentKind = { enum_type = "ArgumentArgumentKind" }
# # mode = { enum_type = "ArgumentMode" }
# --- ArimaCoefficients (3 fields) ---
# Arima coefficients.
# [[types]]
# schema = "ArimaCoefficients"
# include_fields = ["autoRegressiveCoefficients", "interceptCoefficient", "movingAverageCoefficients"]
#
# autoRegressiveCoefficients: array<number>
# interceptCoefficient: number, format: double
# movingAverageCoefficients: array<number>
# --- ArimaFittingMetrics (3 fields) ---
# ARIMA model fitting metrics.
# [[types]]
# schema = "ArimaFittingMetrics"
# include_fields = ["aic", "logLikelihood", "variance"]
#
# aic: number, format: double
# logLikelihood: number, format: double
# variance: number, format: double
# --- ArimaForecastingMetrics (6 fields) ---
# Model evaluation metrics for ARIMA forecasting models.
# [[types]]
# schema = "ArimaForecastingMetrics"
# include_fields = ["arimaFittingMetrics", "arimaSingleModelForecastingMetrics", "hasDrift", "nonSeasonalOrder", "seasonalPeriods", "timeSeriesId"]
#
# arimaFittingMetrics: array<ArimaFittingMetrics>
# arimaSingleModelForecastingMetrics: array<ArimaSingleModelForecastingMetrics>
# hasDrift: array<boolean>
# nonSeasonalOrder: array<ArimaOrder>
# seasonalPeriods: array<string>
# timeSeriesId: array<string>
# --- ArimaModelInfo (10 fields) ---
# Arima model information.
# [[types]]
# schema = "ArimaModelInfo"
# include_fields = ["arimaCoefficients", "arimaFittingMetrics", "hasDrift", "hasHolidayEffect", "hasSpikesAndDips", "hasStepChanges", "nonSeasonalOrder", "seasonalPeriods", "timeSeriesId", "timeSeriesIds"]
#
# arimaCoefficients: $ref: ArimaCoefficients
# arimaFittingMetrics: $ref: ArimaFittingMetrics
# hasDrift: boolean
# hasHolidayEffect: boolean
# hasSpikesAndDips: boolean
# hasStepChanges: boolean
# nonSeasonalOrder: $ref: ArimaOrder
# seasonalPeriods: array<string>
# timeSeriesId: string
# timeSeriesIds: array<string>
# --- ArimaOrder (3 fields) ---
# Arima order, can be used for both non-seasonal and seasonal parts.
# [[types]]
# schema = "ArimaOrder"
# include_fields = ["d", "p", "q"]
#
# d: string, format: int64
# p: string, format: int64
# q: string, format: int64
# --- ArimaResult (2 fields) ---
# (Auto-)arima fitting result. Wrap everything in ArimaResult for easier refactoring if we want to use
# [[types]]
# schema = "ArimaResult"
# include_fields = ["arimaModelInfo", "seasonalPeriods"]
#
# arimaModelInfo: array<ArimaModelInfo>
# seasonalPeriods: array<string>
# --- ArimaSingleModelForecastingMetrics (9 fields) ---
# Model evaluation metrics for a single ARIMA forecasting model.
# [[types]]
# schema = "ArimaSingleModelForecastingMetrics"
# include_fields = ["arimaFittingMetrics", "hasDrift", "hasHolidayEffect", "hasSpikesAndDips", "hasStepChanges", "nonSeasonalOrder", "seasonalPeriods", "timeSeriesId", "timeSeriesIds"]
#
# arimaFittingMetrics: $ref: ArimaFittingMetrics
# hasDrift: boolean
# hasHolidayEffect: boolean
# hasSpikesAndDips: boolean
# hasStepChanges: boolean
# nonSeasonalOrder: $ref: ArimaOrder
# seasonalPeriods: array<string>
# timeSeriesId: string
# timeSeriesIds: array<string>
# --- AuditConfig (2 fields) ---
# Specifies the audit configuration for a service. The configuration determines which permission types
# [[types]]
# schema = "AuditConfig"
# include_fields = ["auditLogConfigs", "service"]
#
# auditLogConfigs: array<AuditLogConfig>
# service: string
# --- AuditLogConfig (2 fields) ---
# Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "l
# [[types]]
# schema = "AuditLogConfig"
# include_fields = ["exemptedMembers", "logType"]
#
# exemptedMembers: array<string>
# logType: string, enum: [LOG_TYPE_UNSPECIFIED, ADMIN_READ, DATA_WRITE, DATA_READ]
#
# [types.field_overrides]
# # logType = { enum_type = "AuditLogConfigLogType" }
# --- AvroOptions (1 fields) ---
# Options for external data sources.
# [[types]]
# schema = "AvroOptions"
# include_fields = ["useAvroLogicalTypes"]
#
# useAvroLogicalTypes: boolean
# --- BatchDeleteRowAccessPoliciesRequest (2 fields) ---
# Request message for the BatchDeleteRowAccessPoliciesRequest method.
# [[types]]
# schema = "BatchDeleteRowAccessPoliciesRequest"
# include_fields = ["force", "policyIds"]
#
# force: boolean
# policyIds: array<string>
# --- BiEngineReason (2 fields) ---
# Reason why BI Engine didn't accelerate the query (or sub-query).
# [[types]]
# schema = "BiEngineReason"
# include_fields = ["code", "message"]
#
# code: string, enum: [CODE_UNSPECIFIED, NO_RESERVATION, INSUFFICIENT_RESERVATION, UNSUPPORTED_SQL_TEXT, ... +3], readOnly
# message: string, readOnly
#
# [types.field_overrides]
# # code = { enum_type = "BiEngineReasonCode" }
# --- BiEngineStatistics (3 fields) ---
# Statistics for a BI Engine specific query. Populated as part of JobStatistics2
# [[types]]
# schema = "BiEngineStatistics"
# include_fields = ["accelerationMode", "biEngineMode", "biEngineReasons"]
#
# accelerationMode: string, enum: [BI_ENGINE_ACCELERATION_MODE_UNSPECIFIED, BI_ENGINE_DISABLED, PARTIAL_INPUT, FULL_INPUT, FULL_QUERY], readOnly
# biEngineMode: string, enum: [ACCELERATION_MODE_UNSPECIFIED, DISABLED, PARTIAL, FULL], readOnly
# biEngineReasons: array<BiEngineReason>
#
# [types.field_overrides]
# # accelerationMode = { enum_type = "BiEngineStatisticsAccelerationMode" }
# # biEngineMode = { enum_type = "BiEngineStatisticsBiEngineMode" }
# --- BigLakeConfiguration (4 fields) ---
# Configuration for BigQuery tables for Apache Iceberg (formerly BigLake managed tables.)
# [[types]]
# schema = "BigLakeConfiguration"
# include_fields = ["connectionId", "fileFormat", "storageUri", "tableFormat"]
#
# connectionId: string
# fileFormat: string, enum: [FILE_FORMAT_UNSPECIFIED, PARQUET]
# storageUri: string
# tableFormat: string, enum: [TABLE_FORMAT_UNSPECIFIED, ICEBERG]
#
# [types.field_overrides]
# # fileFormat = { enum_type = "BigLakeConfigurationFileFormat" }
# # tableFormat = { enum_type = "BigLakeConfigurationTableFormat" }
# --- BigQueryModelTraining (2 fields) ---
# [[types]]
# schema = "BigQueryModelTraining"
# include_fields = ["currentIteration", "expectedTotalIterations"]
#
# currentIteration: integer, format: int32
# expectedTotalIterations: string, format: int64
# --- BigtableColumn (7 fields) ---
# Information related to a Bigtable column.
# WARNING: format:"byte" fields: qualifierEncoded
# WARNING: reserved words: type
# [[types]]
# schema = "BigtableColumn"
# include_fields = ["encoding", "fieldName", "onlyReadLatest", "protoConfig", "qualifierEncoded", "qualifierString", "type"]
#
# encoding: string
# fieldName: string
# onlyReadLatest: boolean
# protoConfig: $ref: BigtableProtoConfig
# qualifierEncoded: string, format: byte
# qualifierString: string
# type: string, RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# qualifierEncoded = { format = "bytes" }
# --- BigtableColumnFamily (6 fields) ---
# Information related to a Bigtable column family.
# WARNING: reserved words: type
# [[types]]
# schema = "BigtableColumnFamily"
# include_fields = ["columns", "encoding", "familyId", "onlyReadLatest", "protoConfig", "type"]
#
# columns: array<BigtableColumn>
# encoding: string
# familyId: string
# onlyReadLatest: boolean
# protoConfig: $ref: BigtableProtoConfig
# type: string, RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# --- BigtableOptions (4 fields) ---
# Options specific to Google Cloud Bigtable data sources.
# [[types]]
# schema = "BigtableOptions"
# include_fields = ["columnFamilies", "ignoreUnspecifiedColumnFamilies", "outputColumnFamiliesAsJson", "readRowkeyAsString"]
#
# columnFamilies: array<BigtableColumnFamily>
# ignoreUnspecifiedColumnFamilies: boolean
# outputColumnFamiliesAsJson: boolean
# readRowkeyAsString: boolean
# --- BigtableProtoConfig (2 fields) ---
# Information related to a Bigtable protobuf column.
# [[types]]
# schema = "BigtableProtoConfig"
# include_fields = ["protoMessageName", "schemaBundleId"]
#
# protoMessageName: string
# schemaBundleId: string
# --- BinaryClassificationMetrics (4 fields) ---
# Evaluation metrics for binary classification/classifier models.
# [[types]]
# schema = "BinaryClassificationMetrics"
# include_fields = ["aggregateClassificationMetrics", "binaryConfusionMatrixList", "negativeLabel", "positiveLabel"]
#
# aggregateClassificationMetrics: $ref: AggregateClassificationMetrics
# binaryConfusionMatrixList: array<BinaryConfusionMatrix>
# negativeLabel: string
# positiveLabel: string
# --- BinaryConfusionMatrix (9 fields) ---
# Confusion matrix for binary classification models.
# [[types]]
# schema = "BinaryConfusionMatrix"
# include_fields = ["accuracy", "f1Score", "falseNegatives", "falsePositives", "positiveClassThreshold", "precision", "recall", "trueNegatives", "truePositives"]
#
# accuracy: number, format: double
# f1Score: number, format: double
# falseNegatives: string, format: int64
# falsePositives: string, format: int64
# positiveClassThreshold: number, format: double
# precision: number, format: double
# recall: number, format: double
# trueNegatives: string, format: int64
# truePositives: string, format: int64
# --- Binding (3 fields) ---
# Associates `members`, or principals, with a `role`.
# [[types]]
# schema = "Binding"
# include_fields = ["condition", "members", "role"]
#
# condition: $ref: Expr
# members: array<string>
# role: string
# --- BqmlIterationResult (5 fields) ---
# [[types]]
# schema = "BqmlIterationResult"
# include_fields = ["durationMs", "evalLoss", "index", "learnRate", "trainingLoss"]
#
# durationMs: string, format: int64
# evalLoss: number, format: double
# index: integer, format: int32
# learnRate: number, format: double
# trainingLoss: number, format: double
# --- BqmlTrainingRun (4 fields) ---
# [[types]]
# schema = "BqmlTrainingRun"
# include_fields = ["iterationResults", "startTime", "state", "trainingOptions"]
#
# iterationResults: array<BqmlIterationResult>
# startTime: string, format: date-time
# state: string
# trainingOptions: object
# --- CategoricalValue (1 fields) ---
# Representative value of a categorical feature.
# [[types]]
# schema = "CategoricalValue"
# include_fields = ["categoryCounts"]
#
# categoryCounts: array<CategoryCount>
# --- CategoryCount (2 fields) ---
# Represents the count of a single category within the cluster.
# [[types]]
# schema = "CategoryCount"
# include_fields = ["category", "count"]
#
# category: string
# count: string, format: int64
# --- CloneDefinition (2 fields) ---
# Information about base table and clone time of a table clone.
# [[types]]
# schema = "CloneDefinition"
# include_fields = ["baseTableReference", "cloneTime"]
#
# baseTableReference: $ref: TableReference
# cloneTime: string, format: date-time
# --- Cluster (3 fields) ---
# Message containing the information about one cluster.
# [[types]]
# schema = "Cluster"
# include_fields = ["centroidId", "count", "featureValues"]
#
# centroidId: string, format: int64
# count: string, format: int64
# featureValues: array<FeatureValue>
# --- ClusterInfo (3 fields) ---
# Information about a single cluster for clustering model.
# [[types]]
# schema = "ClusterInfo"
# include_fields = ["centroidId", "clusterRadius", "clusterSize"]
#
# centroidId: string, format: int64
# clusterRadius: number, format: double
# clusterSize: string, format: int64
# --- Clustering (1 fields) [IN MANIFEST] ---
# Configures table clustering.
# [[types]]
# schema = "Clustering"
# include_fields = ["fields"]
#
# fields: array<string>
# --- ClusteringMetrics (3 fields) ---
# Evaluation metrics for clustering models.
# [[types]]
# schema = "ClusteringMetrics"
# include_fields = ["clusters", "daviesBouldinIndex", "meanSquaredDistance"]
#
# clusters: array<Cluster>
# daviesBouldinIndex: number, format: double
# meanSquaredDistance: number, format: double
# --- ConfusionMatrix (2 fields) ---
# Confusion matrix for multi-class classification models.
# [[types]]
# schema = "ConfusionMatrix"
# include_fields = ["confidenceThreshold", "rows"]
#
# confidenceThreshold: number, format: double
# rows: array<Row>
# --- ConnectionProperty (2 fields) ---
# A connection-level property to customize query behavior. Under JDBC, these correspond directly to co
# [[types]]
# schema = "ConnectionProperty"
# include_fields = ["key", "value"]
#
# key: string
# value: string
# --- CsvOptions (10 fields) ---
# Information related to a CSV data source.
# [[types]]
# schema = "CsvOptions"
# include_fields = ["allowJaggedRows", "allowQuotedNewlines", "encoding", "fieldDelimiter", "nullMarker", "nullMarkers", "preserveAsciiControlCharacters", "quote", "skipLeadingRows", "sourceColumnMatch"]
#
# allowJaggedRows: boolean
# allowQuotedNewlines: boolean
# encoding: string
# fieldDelimiter: string
# nullMarker: string
# nullMarkers: array<string>
# preserveAsciiControlCharacters: boolean
# quote: string
# skipLeadingRows: string, format: int64
# sourceColumnMatch: string
# --- DataFormatOptions (2 fields) ---
# Options for data format adjustments.
# [[types]]
# schema = "DataFormatOptions"
# include_fields = ["timestampOutputFormat", "useInt64Timestamp"]
#
# timestampOutputFormat: string, enum: [TIMESTAMP_OUTPUT_FORMAT_UNSPECIFIED, FLOAT64, INT64, ISO8601_STRING]
# useInt64Timestamp: boolean
#
# [types.field_overrides]
# # timestampOutputFormat = { enum_type = "DataFormatOptionsTimestampOutputFormat" }
# --- DataMaskingStatistics (1 fields) ---
# Statistics for data-masking.
# [[types]]
# schema = "DataMaskingStatistics"
# include_fields = ["dataMaskingApplied"]
#
# dataMaskingApplied: boolean
# --- DataPolicyOption (1 fields) ---
# Data policy option. For more information, see [Mask data by applying data policies to a column](http
# [[types]]
# schema = "DataPolicyOption"
# include_fields = ["name"]
#
# name: string
#
# [types.field_overrides]
# name = { required = true }
# --- DataSplitResult (3 fields) ---
# Data split result. This contains references to the training and evaluation data tables that were use
# [[types]]
# schema = "DataSplitResult"
# include_fields = ["evaluationTable", "testTable", "trainingTable"]
#
# evaluationTable: $ref: TableReference
# testTable: $ref: TableReference
# trainingTable: $ref: TableReference
# --- Dataset (30 fields) [IN MANIFEST] ---
# Represents a BigQuery dataset.
# WARNING: reserved words: type
# [[types]]
# schema = "Dataset"
# include_fields = ["access", "creationTime", "datasetReference", "defaultCollation", "defaultEncryptionConfiguration", "defaultPartitionExpirationMs", "defaultRoundingMode", "defaultTableExpirationMs", "description", "etag", "externalCatalogDatasetOptions", "externalDatasetReference", "friendlyName", "id", "isCaseInsensitive", "kind", "labels", "lastModifiedTime", "linkedDatasetMetadata", "linkedDatasetSource", "location", "maxTimeTravelHours", "resourceTags", "restrictions", "satisfiesPzi", "satisfiesPzs", "selfLink", "storageBillingModel", "tags", "type"]
#
# access: array<object>
# creationTime: string, format: int64, readOnly
# datasetReference: $ref: DatasetReference
# defaultCollation: string
# defaultEncryptionConfiguration: $ref: EncryptionConfiguration
# defaultPartitionExpirationMs: string, format: int64
# defaultRoundingMode: string, enum: [ROUNDING_MODE_UNSPECIFIED, ROUND_HALF_AWAY_FROM_ZERO, ROUND_HALF_EVEN]
# defaultTableExpirationMs: string, format: int64
# description: string
# etag: string, readOnly
# externalCatalogDatasetOptions: $ref: ExternalCatalogDatasetOptions
# externalDatasetReference: $ref: ExternalDatasetReference
# friendlyName: string
# id: string, readOnly
# isCaseInsensitive: boolean
# kind: string, readOnly
# labels: map<string, string>
# lastModifiedTime: string, format: int64, readOnly
# linkedDatasetMetadata: $ref: LinkedDatasetMetadata, readOnly
# linkedDatasetSource: $ref: LinkedDatasetSource
# location: string
# maxTimeTravelHours: string, format: int64
# resourceTags: map<string, string>
# restrictions: $ref: RestrictionConfig, readOnly
# satisfiesPzi: boolean, readOnly
# satisfiesPzs: boolean, readOnly
# selfLink: string, readOnly
# storageBillingModel: string, enum: [STORAGE_BILLING_MODEL_UNSPECIFIED, LOGICAL, PHYSICAL]
# tags: array<object>, readOnly
# type: string, readOnly, RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # defaultRoundingMode = { enum_type = "DatasetDefaultRoundingMode" }
# # storageBillingModel = { enum_type = "DatasetStorageBillingModel" }
# --- DatasetAccessEntry (2 fields) ---
# Grants all resources of particular types in a particular dataset read access to the current dataset.
# [[types]]
# schema = "DatasetAccessEntry"
# include_fields = ["dataset", "targetTypes"]
#
# dataset: $ref: DatasetReference
# targetTypes: array<string>
# --- DatasetList (5 fields) [IN MANIFEST] ---
# Response format for a page of results when listing datasets.
# [[types]]
# schema = "DatasetList"
# include_fields = ["datasets", "etag", "kind", "nextPageToken", "unreachable"]
#
# datasets: array<object>
# etag: string, readOnly
# kind: string, readOnly
# nextPageToken: string
# unreachable: array<string>
# --- DatasetReference (2 fields) [IN MANIFEST] ---
# Identifier for a dataset.
# [[types]]
# schema = "DatasetReference"
# include_fields = ["datasetId", "projectId"]
#
# datasetId: string
# projectId: string
# --- DestinationTableProperties (4 fields) ---
# Properties for the destination table.
# [[types]]
# schema = "DestinationTableProperties"
# include_fields = ["description", "expirationTime", "friendlyName", "labels"]
#
# description: string
# expirationTime: string, format: date-time
# friendlyName: string
# labels: map<string, string>
# --- DifferentialPrivacyPolicy (8 fields) ---
# Represents privacy policy associated with "differential privacy" method.
# [[types]]
# schema = "DifferentialPrivacyPolicy"
# include_fields = ["deltaBudget", "deltaBudgetRemaining", "deltaPerQuery", "epsilonBudget", "epsilonBudgetRemaining", "maxEpsilonPerQuery", "maxGroupsContributed", "privacyUnitColumn"]
#
# deltaBudget: number, format: double
# deltaBudgetRemaining: number, format: double, readOnly
# deltaPerQuery: number, format: double
# epsilonBudget: number, format: double
# epsilonBudgetRemaining: number, format: double, readOnly
# maxEpsilonPerQuery: number, format: double
# maxGroupsContributed: string, format: int64
# privacyUnitColumn: string
# --- DimensionalityReductionMetrics (1 fields) ---
# Model evaluation metrics for dimensionality reduction models.
# [[types]]
# schema = "DimensionalityReductionMetrics"
# include_fields = ["totalExplainedVarianceRatio"]
#
# totalExplainedVarianceRatio: number, format: double
# --- DmlStatistics (3 fields) ---
# Detailed statistics for DML statements
# [[types]]
# schema = "DmlStatistics"
# include_fields = ["deletedRowCount", "insertedRowCount", "updatedRowCount"]
#
# deletedRowCount: string, format: int64, readOnly
# insertedRowCount: string, format: int64, readOnly
# updatedRowCount: string, format: int64, readOnly
# --- DoubleCandidates (1 fields) ---
# Discrete candidates of a double hyperparameter.
# [[types]]
# schema = "DoubleCandidates"
# include_fields = ["candidates"]
#
# candidates: array<number>
# --- DoubleHparamSearchSpace (2 fields) ---
# Search space for a double hyperparameter.
# [[types]]
# schema = "DoubleHparamSearchSpace"
# include_fields = ["candidates", "range"]
#
# candidates: $ref: DoubleCandidates
# range: $ref: DoubleRange
# --- DoubleRange (2 fields) ---
# Range of a double hyperparameter.
# [[types]]
# schema = "DoubleRange"
# include_fields = ["max", "min"]
#
# max: number, format: double
# min: number, format: double
# --- EncryptionConfiguration (1 fields) ---
# Configuration for Cloud KMS encryption settings.
# [[types]]
# schema = "EncryptionConfiguration"
# include_fields = ["kmsKeyName"]
#
# kmsKeyName: string
# --- Entry (2 fields) ---
# A single entry in the confusion matrix.
# [[types]]
# schema = "Entry"
# include_fields = ["itemCount", "predictedLabel"]
#
# itemCount: string, format: int64
# predictedLabel: string
# --- ErrorProto (4 fields) [IN MANIFEST] ---
# Error details.
# [[types]]
# schema = "ErrorProto"
# include_fields = ["debugInfo", "location", "message", "reason"]
#
# debugInfo: string
# location: string
# message: string
# reason: string
# --- EvaluationMetrics (7 fields) ---
# Evaluation metrics of a model. These are either computed on all training data or just the eval data
# [[types]]
# schema = "EvaluationMetrics"
# include_fields = ["arimaForecastingMetrics", "binaryClassificationMetrics", "clusteringMetrics", "dimensionalityReductionMetrics", "multiClassClassificationMetrics", "rankingMetrics", "regressionMetrics"]
#
# arimaForecastingMetrics: $ref: ArimaForecastingMetrics
# binaryClassificationMetrics: $ref: BinaryClassificationMetrics
# clusteringMetrics: $ref: ClusteringMetrics
# dimensionalityReductionMetrics: $ref: DimensionalityReductionMetrics
# multiClassClassificationMetrics: $ref: MultiClassClassificationMetrics
# rankingMetrics: $ref: RankingMetrics
# regressionMetrics: $ref: RegressionMetrics
# --- ExplainQueryStage (31 fields) ---
# A single stage of query execution.
# [[types]]
# schema = "ExplainQueryStage"
# include_fields = ["completedParallelInputs", "computeMode", "computeMsAvg", "computeMsMax", "computeRatioAvg", "computeRatioMax", "endMs", "id", "inputStages", "name", "parallelInputs", "readMsAvg", "readMsMax", "readRatioAvg", "readRatioMax", "recordsRead", "recordsWritten", "shuffleOutputBytes", "shuffleOutputBytesSpilled", "slotMs", "startMs", "status", "steps", "waitMsAvg", "waitMsMax", "waitRatioAvg", "waitRatioMax", "writeMsAvg", "writeMsMax", "writeRatioAvg", "writeRatioMax"]
#
# completedParallelInputs: string, format: int64
# computeMode: string, enum: [COMPUTE_MODE_UNSPECIFIED, BIGQUERY, BI_ENGINE], readOnly
# computeMsAvg: string, format: int64
# computeMsMax: string, format: int64
# computeRatioAvg: number, format: double
# computeRatioMax: number, format: double
# endMs: string, format: int64
# id: string, format: int64
# inputStages: array<string>
# name: string
# parallelInputs: string, format: int64
# readMsAvg: string, format: int64
# readMsMax: string, format: int64
# readRatioAvg: number, format: double
# readRatioMax: number, format: double
# recordsRead: string, format: int64
# recordsWritten: string, format: int64
# shuffleOutputBytes: string, format: int64
# shuffleOutputBytesSpilled: string, format: int64
# slotMs: string, format: int64
# startMs: string, format: int64
# status: string
# steps: array<ExplainQueryStep>
# waitMsAvg: string, format: int64
# waitMsMax: string, format: int64
# waitRatioAvg: number, format: double
# waitRatioMax: number, format: double
# writeMsAvg: string, format: int64
# writeMsMax: string, format: int64
# writeRatioAvg: number, format: double
# writeRatioMax: number, format: double
#
# [types.field_overrides]
# name = { required = true }
# # computeMode = { enum_type = "ExplainQueryStageComputeMode" }
# --- ExplainQueryStep (2 fields) ---
# An operation within a stage.
# [[types]]
# schema = "ExplainQueryStep"
# include_fields = ["kind", "substeps"]
#
# kind: string
# substeps: array<string>
# --- Explanation (2 fields) ---
# Explanation for a single feature.
# [[types]]
# schema = "Explanation"
# include_fields = ["attribution", "featureName"]
#
# attribution: number, format: double
# featureName: string
# --- ExportDataStatistics (2 fields) ---
# Statistics for the EXPORT DATA statement as part of Query Job. EXTRACT JOB statistics are populated
# [[types]]
# schema = "ExportDataStatistics"
# include_fields = ["fileCount", "rowCount"]
#
# fileCount: string, format: int64
# rowCount: string, format: int64
# --- Expr (4 fields) ---
# Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expr
# [[types]]
# schema = "Expr"
# include_fields = ["description", "expression", "location", "title"]
#
# description: string
# expression: string
# location: string
# title: string
# --- ExternalCatalogDatasetOptions (2 fields) ---
# Options defining open source compatible datasets living in the BigQuery catalog. Contains metadata o
# [[types]]
# schema = "ExternalCatalogDatasetOptions"
# include_fields = ["defaultStorageLocationUri", "parameters"]
#
# defaultStorageLocationUri: string
# parameters: map<string, string>
# --- ExternalCatalogTableOptions (3 fields) ---
# Metadata about open source compatible table. The fields contained in these options correspond to Hiv
# [[types]]
# schema = "ExternalCatalogTableOptions"
# include_fields = ["connectionId", "parameters", "storageDescriptor"]
#
# connectionId: string
# parameters: map<string, string>
# storageDescriptor: $ref: StorageDescriptor
# --- ExternalDataConfiguration (27 fields) ---
# [[types]]
# schema = "ExternalDataConfiguration"
# include_fields = ["autodetect", "avroOptions", "bigtableOptions", "compression", "connectionId", "csvOptions", "dateFormat", "datetimeFormat", "decimalTargetTypes", "fileSetSpecType", "googleSheetsOptions", "hivePartitioningOptions", "ignoreUnknownValues", "jsonExtension", "jsonOptions", "maxBadRecords", "metadataCacheMode", "objectMetadata", "parquetOptions", "referenceFileSchemaUri", "schema", "sourceFormat", "sourceUris", "timeFormat", "timeZone", "timestampFormat", "timestampTargetPrecision"]
#
# autodetect: boolean
# avroOptions: $ref: AvroOptions
# bigtableOptions: $ref: BigtableOptions
# compression: string
# connectionId: string
# csvOptions: $ref: CsvOptions
# dateFormat: string
# datetimeFormat: string
# decimalTargetTypes: array<string>
# fileSetSpecType: string, enum: [FILE_SET_SPEC_TYPE_FILE_SYSTEM_MATCH, FILE_SET_SPEC_TYPE_NEW_LINE_DELIMITED_MANIFEST]
# googleSheetsOptions: $ref: GoogleSheetsOptions
# hivePartitioningOptions: $ref: HivePartitioningOptions
# ignoreUnknownValues: boolean
# jsonExtension: string, enum: [JSON_EXTENSION_UNSPECIFIED, GEOJSON]
# jsonOptions: $ref: JsonOptions
# maxBadRecords: integer, format: int32
# metadataCacheMode: string, enum: [METADATA_CACHE_MODE_UNSPECIFIED, AUTOMATIC, MANUAL]
# objectMetadata: string, enum: [OBJECT_METADATA_UNSPECIFIED, DIRECTORY, SIMPLE]
# parquetOptions: $ref: ParquetOptions
# referenceFileSchemaUri: string
# schema: $ref: TableSchema
# sourceFormat: string
# sourceUris: array<string>
# timeFormat: string
# timeZone: string
# timestampFormat: string
# timestampTargetPrecision: array<integer>
#
# [types.field_overrides]
# # fileSetSpecType = { enum_type = "ExternalDataConfigurationFileSetSpecType" }
# # jsonExtension = { enum_type = "ExternalDataConfigurationJsonExtension" }
# # metadataCacheMode = { enum_type = "ExternalDataConfigurationMetadataCacheMode" }
# # objectMetadata = { enum_type = "ExternalDataConfigurationObjectMetadata" }
# --- ExternalDatasetReference (2 fields) [IN MANIFEST] ---
# Configures the access a dataset defined in an external metadata storage.
# [[types]]
# schema = "ExternalDatasetReference"
# include_fields = ["connection", "externalSource"]
#
# connection: string
# externalSource: string
# --- ExternalRuntimeOptions (5 fields) ---
# Options for the runtime of the external system.
# [[types]]
# schema = "ExternalRuntimeOptions"
# include_fields = ["containerCpu", "containerMemory", "maxBatchingRows", "runtimeConnection", "runtimeVersion"]
#
# containerCpu: number, format: double
# containerMemory: string
# maxBatchingRows: string, format: int64
# runtimeConnection: string
# runtimeVersion: string
# --- ExternalServiceCost (6 fields) ---
# The external service cost is a portion of the total cost, these costs are not additive with total_by
# [[types]]
# schema = "ExternalServiceCost"
# include_fields = ["billingMethod", "bytesBilled", "bytesProcessed", "externalService", "reservedSlotCount", "slotMs"]
#
# billingMethod: string
# bytesBilled: string, format: int64
# bytesProcessed: string, format: int64
# externalService: string
# reservedSlotCount: string, format: int64
# slotMs: string, format: int64
# --- FeatureValue (3 fields) ---
# Representative value of a single feature within the cluster.
# [[types]]
# schema = "FeatureValue"
# include_fields = ["categoricalValue", "featureColumn", "numericalValue"]
#
# categoricalValue: $ref: CategoricalValue
# featureColumn: string
# numericalValue: number, format: double
# --- ForeignTypeInfo (1 fields) ---
# Metadata about the foreign data type definition such as the system in which the type is defined.
# [[types]]
# schema = "ForeignTypeInfo"
# include_fields = ["typeSystem"]
#
# typeSystem: string, enum: [TYPE_SYSTEM_UNSPECIFIED, HIVE]
#
# [types.field_overrides]
# # typeSystem = { enum_type = "ForeignTypeInfoTypeSystem" }
# --- ForeignViewDefinition (2 fields) ---
# A view can be represented in multiple ways. Each representation has its own dialect. This message st
# [[types]]
# schema = "ForeignViewDefinition"
# include_fields = ["dialect", "query"]
#
# dialect: string
# query: string
# --- GetIamPolicyRequest (1 fields) ---
# Request message for `GetIamPolicy` method.
# [[types]]
# schema = "GetIamPolicyRequest"
# include_fields = ["options"]
#
# options: $ref: GetPolicyOptions
# --- GetPolicyOptions (1 fields) ---
# Encapsulates settings provided to GetIamPolicy.
# [[types]]
# schema = "GetPolicyOptions"
# include_fields = ["requestedPolicyVersion"]
#
# requestedPolicyVersion: integer, format: int32
# --- GetQueryResultsResponse (12 fields) ---
# Response object of GetQueryResults.
# [[types]]
# schema = "GetQueryResultsResponse"
# include_fields = ["cacheHit", "errors", "etag", "jobComplete", "jobReference", "kind", "numDmlAffectedRows", "pageToken", "rows", "schema", "totalBytesProcessed", "totalRows"]
#
# cacheHit: boolean
# errors: array<ErrorProto>, readOnly
# etag: string
# jobComplete: boolean
# jobReference: $ref: JobReference
# kind: string
# numDmlAffectedRows: string, format: int64, readOnly
# pageToken: string
# rows: array<TableRow>
# schema: $ref: TableSchema
# totalBytesProcessed: string, format: int64
# totalRows: string, format: uint64
# --- GetServiceAccountResponse (2 fields) ---
# Response object of GetServiceAccount
# [[types]]
# schema = "GetServiceAccountResponse"
# include_fields = ["email", "kind"]
#
# email: string
# kind: string
# --- GlobalExplanation (2 fields) ---
# Global explanations containing the top most important features after training.
# [[types]]
# schema = "GlobalExplanation"
# include_fields = ["classLabel", "explanations"]
#
# classLabel: string
# explanations: array<Explanation>
# --- GoogleSheetsOptions (2 fields) ---
# Options specific to Google Sheets data sources.
# [[types]]
# schema = "GoogleSheetsOptions"
# include_fields = ["range", "skipLeadingRows"]
#
# range: string
# skipLeadingRows: string, format: int64
# --- HighCardinalityJoin (4 fields) ---
# High cardinality join detailed information.
# [[types]]
# schema = "HighCardinalityJoin"
# include_fields = ["leftRows", "outputRows", "rightRows", "stepIndex"]
#
# leftRows: string, format: int64, readOnly
# outputRows: string, format: int64, readOnly
# rightRows: string, format: int64, readOnly
# stepIndex: integer, format: int32, readOnly
# --- HivePartitioningOptions (4 fields) ---
# Options for configuring hive partitioning detect.
# [[types]]
# schema = "HivePartitioningOptions"
# include_fields = ["fields", "mode", "requirePartitionFilter", "sourceUriPrefix"]
#
# fields: array<string>, readOnly
# mode: string
# requirePartitionFilter: boolean
# sourceUriPrefix: string
# --- HparamSearchSpaces (22 fields) ---
# Hyperparameter search spaces. These should be a subset of training_options.
# [[types]]
# schema = "HparamSearchSpaces"
# include_fields = ["activationFn", "batchSize", "boosterType", "colsampleBylevel", "colsampleBynode", "colsampleBytree", "dartNormalizeType", "dropout", "hiddenUnits", "l1Reg", "l2Reg", "learnRate", "maxTreeDepth", "minSplitLoss", "minTreeChildWeight", "numClusters", "numFactors", "numParallelTree", "optimizer", "subsample", "treeMethod", "walsAlpha"]
#
# activationFn: $ref: StringHparamSearchSpace
# batchSize: $ref: IntHparamSearchSpace
# boosterType: $ref: StringHparamSearchSpace
# colsampleBylevel: $ref: DoubleHparamSearchSpace
# colsampleBynode: $ref: DoubleHparamSearchSpace
# colsampleBytree: $ref: DoubleHparamSearchSpace
# dartNormalizeType: $ref: StringHparamSearchSpace
# dropout: $ref: DoubleHparamSearchSpace
# hiddenUnits: $ref: IntArrayHparamSearchSpace
# l1Reg: $ref: DoubleHparamSearchSpace
# l2Reg: $ref: DoubleHparamSearchSpace
# learnRate: $ref: DoubleHparamSearchSpace
# maxTreeDepth: $ref: IntHparamSearchSpace
# minSplitLoss: $ref: DoubleHparamSearchSpace
# minTreeChildWeight: $ref: IntHparamSearchSpace
# numClusters: $ref: IntHparamSearchSpace
# numFactors: $ref: IntHparamSearchSpace
# numParallelTree: $ref: IntHparamSearchSpace
# optimizer: $ref: StringHparamSearchSpace
# subsample: $ref: DoubleHparamSearchSpace
# treeMethod: $ref: StringHparamSearchSpace
# walsAlpha: $ref: DoubleHparamSearchSpace
# --- HparamTuningTrial (10 fields) ---
# Training info of a trial in [hyperparameter tuning](https://cloud.google.com/bigquery-ml/docs/refere
# [[types]]
# schema = "HparamTuningTrial"
# include_fields = ["endTimeMs", "errorMessage", "evalLoss", "evaluationMetrics", "hparamTuningEvaluationMetrics", "hparams", "startTimeMs", "status", "trainingLoss", "trialId"]
#
# endTimeMs: string, format: int64
# errorMessage: string
# evalLoss: number, format: double
# evaluationMetrics: $ref: EvaluationMetrics
# hparamTuningEvaluationMetrics: $ref: EvaluationMetrics
# hparams: $ref: TrainingOptions
# startTimeMs: string, format: int64
# status: string, enum: [TRIAL_STATUS_UNSPECIFIED, NOT_STARTED, RUNNING, SUCCEEDED, ... +3]
# trainingLoss: number, format: double
# trialId: string, format: int64
#
# [types.field_overrides]
# # status = { enum_type = "HparamTuningTrialStatus" }
# --- IncrementalResultStats (3 fields) ---
# Statistics related to Incremental Query Results. Populated as part of JobStatistics2. This feature i
# [[types]]
# schema = "IncrementalResultStats"
# include_fields = ["disabledReason", "resultSetLastModifyTime", "resultSetLastReplaceTime"]
#
# disabledReason: string, enum: [DISABLED_REASON_UNSPECIFIED, OTHER, UNSUPPORTED_OPERATOR], readOnly
# resultSetLastModifyTime: string, format: google-datetime, readOnly
# resultSetLastReplaceTime: string, format: google-datetime, readOnly
#
# [types.field_overrides]
# # disabledReason = { enum_type = "IncrementalResultStatsDisabledReason" }
# --- IndexPruningStats (4 fields) ---
# Statistics for index pruning.
# [[types]]
# schema = "IndexPruningStats"
# include_fields = ["baseTable", "indexId", "postIndexPruningParallelInputCount", "preIndexPruningParallelInputCount"]
#
# baseTable: $ref: TableReference
# indexId: string
# postIndexPruningParallelInputCount: string, format: int64
# preIndexPruningParallelInputCount: string, format: int64
# --- IndexUnusedReason (4 fields) ---
# Reason about why no search index was used in the search query (or sub-query).
# [[types]]
# schema = "IndexUnusedReason"
# include_fields = ["baseTable", "code", "indexName", "message"]
#
# baseTable: $ref: TableReference
# code: string, enum: [CODE_UNSPECIFIED, INDEX_CONFIG_NOT_AVAILABLE, PENDING_INDEX_CREATION, BASE_TABLE_TRUNCATED, ... +18]
# indexName: string
# message: string
#
# [types.field_overrides]
# # code = { enum_type = "IndexUnusedReasonCode" }
# --- InputDataChange (1 fields) ---
# Details about the input data change insight.
# [[types]]
# schema = "InputDataChange"
# include_fields = ["recordsReadDiffPercentage"]
#
# recordsReadDiffPercentage: number, format: float, readOnly
# --- IntArray (1 fields) ---
# An array of int.
# [[types]]
# schema = "IntArray"
# include_fields = ["elements"]
#
# elements: array<string>
# --- IntArrayHparamSearchSpace (1 fields) ---
# Search space for int array.
# [[types]]
# schema = "IntArrayHparamSearchSpace"
# include_fields = ["candidates"]
#
# candidates: array<IntArray>
# --- IntCandidates (1 fields) ---
# Discrete candidates of an int hyperparameter.
# [[types]]
# schema = "IntCandidates"
# include_fields = ["candidates"]
#
# candidates: array<string>
# --- IntHparamSearchSpace (2 fields) ---
# Search space for an int hyperparameter.
# [[types]]
# schema = "IntHparamSearchSpace"
# include_fields = ["candidates", "range"]
#
# candidates: $ref: IntCandidates
# range: $ref: IntRange
# --- IntRange (2 fields) ---
# Range of an int hyperparameter.
# [[types]]
# schema = "IntRange"
# include_fields = ["max", "min"]
#
# max: string, format: int64
# min: string, format: int64
# --- IterationResult (8 fields) ---
# Information about a single iteration of the training run.
# [[types]]
# schema = "IterationResult"
# include_fields = ["arimaResult", "clusterInfos", "durationMs", "evalLoss", "index", "learnRate", "principalComponentInfos", "trainingLoss"]
#
# arimaResult: $ref: ArimaResult
# clusterInfos: array<ClusterInfo>
# durationMs: string, format: int64
# evalLoss: number, format: double
# index: integer, format: int32
# learnRate: number, format: double
# principalComponentInfos: array<PrincipalComponentInfo>
# trainingLoss: number, format: double
# --- Job (11 fields) [IN MANIFEST] ---
# [[types]]
# schema = "Job"
# include_fields = ["configuration", "etag", "id", "jobCreationReason", "jobReference", "kind", "principal_subject", "selfLink", "statistics", "status", "user_email"]
#
# configuration: $ref: JobConfiguration
# etag: string, readOnly
# id: string, readOnly
# jobCreationReason: $ref: JobCreationReason, readOnly
# jobReference: $ref: JobReference
# kind: string, readOnly
# principal_subject: string, readOnly
# selfLink: string, readOnly
# statistics: $ref: JobStatistics, readOnly
# status: $ref: JobStatus, readOnly
# user_email: string, readOnly
# --- JobCancelResponse (2 fields) [IN MANIFEST] ---
# Describes format of a jobs cancellation response.
# [[types]]
# schema = "JobCancelResponse"
# include_fields = ["job", "kind"]
#
# job: $ref: Job
# kind: string
# --- JobConfiguration (10 fields) [IN MANIFEST] ---
# [[types]]
# schema = "JobConfiguration"
# include_fields = ["copy", "dryRun", "extract", "jobTimeoutMs", "jobType", "labels", "load", "maxSlots", "query", "reservation"]
#
# copy: $ref: JobConfigurationTableCopy
# dryRun: boolean
# extract: $ref: JobConfigurationExtract
# jobTimeoutMs: string, format: int64
# jobType: string
# labels: map<string, string>
# load: $ref: JobConfigurationLoad
# maxSlots: integer, format: int32
# query: $ref: JobConfigurationQuery
# reservation: string
# --- JobConfigurationExtract (10 fields) ---
# JobConfigurationExtract configures a job that exports data from a BigQuery table into Google Cloud S
# [[types]]
# schema = "JobConfigurationExtract"
# include_fields = ["compression", "destinationFormat", "destinationUri", "destinationUris", "fieldDelimiter", "modelExtractOptions", "printHeader", "sourceModel", "sourceTable", "useAvroLogicalTypes"]
#
# compression: string
# destinationFormat: string
# destinationUri: string
# destinationUris: array<string>
# fieldDelimiter: string
# modelExtractOptions: $ref: ModelExtractOptions
# printHeader: boolean
# sourceModel: $ref: ModelReference
# sourceTable: $ref: TableReference
# useAvroLogicalTypes: boolean
# --- JobConfigurationLoad (45 fields) ---
# JobConfigurationLoad contains the configuration properties for loading data into a destination table
# [[types]]
# schema = "JobConfigurationLoad"
# include_fields = ["allowJaggedRows", "allowQuotedNewlines", "autodetect", "clustering", "columnNameCharacterMap", "connectionProperties", "copyFilesOnly", "createDisposition", "createSession", "dateFormat", "datetimeFormat", "decimalTargetTypes", "destinationEncryptionConfiguration", "destinationTable", "destinationTableProperties", "encoding", "fieldDelimiter", "fileSetSpecType", "hivePartitioningOptions", "ignoreUnknownValues", "jsonExtension", "maxBadRecords", "nullMarker", "nullMarkers", "parquetOptions", "preserveAsciiControlCharacters", "projectionFields", "quote", "rangePartitioning", "referenceFileSchemaUri", "schema", "schemaInline", "schemaInlineFormat", "schemaUpdateOptions", "skipLeadingRows", "sourceColumnMatch", "sourceFormat", "sourceUris", "timeFormat", "timePartitioning", "timeZone", "timestampFormat", "timestampTargetPrecision", "useAvroLogicalTypes", "writeDisposition"]
#
# allowJaggedRows: boolean
# allowQuotedNewlines: boolean
# autodetect: boolean
# clustering: $ref: Clustering
# columnNameCharacterMap: string, enum: [COLUMN_NAME_CHARACTER_MAP_UNSPECIFIED, STRICT, V1, V2]
# connectionProperties: array<ConnectionProperty>
# copyFilesOnly: boolean
# createDisposition: string
# createSession: boolean
# dateFormat: string
# datetimeFormat: string
# decimalTargetTypes: array<string>
# destinationEncryptionConfiguration: $ref: EncryptionConfiguration
# destinationTable: $ref: TableReference
# destinationTableProperties: $ref: DestinationTableProperties
# encoding: string
# fieldDelimiter: string
# fileSetSpecType: string, enum: [FILE_SET_SPEC_TYPE_FILE_SYSTEM_MATCH, FILE_SET_SPEC_TYPE_NEW_LINE_DELIMITED_MANIFEST]
# hivePartitioningOptions: $ref: HivePartitioningOptions
# ignoreUnknownValues: boolean
# jsonExtension: string, enum: [JSON_EXTENSION_UNSPECIFIED, GEOJSON]
# maxBadRecords: integer, format: int32
# nullMarker: string
# nullMarkers: array<string>
# parquetOptions: $ref: ParquetOptions
# preserveAsciiControlCharacters: boolean
# projectionFields: array<string>
# quote: string
# rangePartitioning: $ref: RangePartitioning
# referenceFileSchemaUri: string
# schema: $ref: TableSchema
# schemaInline: string
# schemaInlineFormat: string
# schemaUpdateOptions: array<string>
# skipLeadingRows: integer, format: int32
# sourceColumnMatch: string, enum: [SOURCE_COLUMN_MATCH_UNSPECIFIED, POSITION, NAME]
# sourceFormat: string
# sourceUris: array<string>
# timeFormat: string
# timePartitioning: $ref: TimePartitioning
# timeZone: string
# timestampFormat: string
# timestampTargetPrecision: array<integer>
# useAvroLogicalTypes: boolean
# writeDisposition: string
#
# [types.field_overrides]
# # columnNameCharacterMap = { enum_type = "JobConfigurationLoadColumnNameCharacterMap" }
# # fileSetSpecType = { enum_type = "JobConfigurationLoadFileSetSpecType" }
# # jsonExtension = { enum_type = "JobConfigurationLoadJsonExtension" }
# # sourceColumnMatch = { enum_type = "JobConfigurationLoadSourceColumnMatch" }
# --- JobConfigurationQuery (28 fields) [IN MANIFEST] ---
# JobConfigurationQuery configures a BigQuery query job.
# [[types]]
# schema = "JobConfigurationQuery"
# include_fields = ["allowLargeResults", "clustering", "connectionProperties", "continuous", "createDisposition", "createSession", "defaultDataset", "destinationEncryptionConfiguration", "destinationTable", "flattenResults", "maximumBillingTier", "maximumBytesBilled", "parameterMode", "preserveNulls", "priority", "query", "queryParameters", "rangePartitioning", "schemaUpdateOptions", "scriptOptions", "systemVariables", "tableDefinitions", "timePartitioning", "useLegacySql", "useQueryCache", "userDefinedFunctionResources", "writeDisposition", "writeIncrementalResults"]
#
# allowLargeResults: boolean
# clustering: $ref: Clustering
# connectionProperties: array<ConnectionProperty>
# continuous: boolean
# createDisposition: string
# createSession: boolean
# defaultDataset: $ref: DatasetReference
# destinationEncryptionConfiguration: $ref: EncryptionConfiguration
# destinationTable: $ref: TableReference
# flattenResults: boolean
# maximumBillingTier: integer, format: int32
# maximumBytesBilled: string, format: int64
# parameterMode: string
# preserveNulls: boolean
# priority: string
# query: string
# queryParameters: array<QueryParameter>
# rangePartitioning: $ref: RangePartitioning
# schemaUpdateOptions: array<string>
# scriptOptions: $ref: ScriptOptions
# systemVariables: $ref: SystemVariables, readOnly
# tableDefinitions: map<string, ExternalDataConfiguration>
# timePartitioning: $ref: TimePartitioning
# useLegacySql: boolean
# useQueryCache: boolean
# userDefinedFunctionResources: array<UserDefinedFunctionResource>
# writeDisposition: string
# writeIncrementalResults: boolean
# --- JobConfigurationTableCopy (8 fields) ---
# JobConfigurationTableCopy configures a job that copies data from one table to another. For more info
# [[types]]
# schema = "JobConfigurationTableCopy"
# include_fields = ["createDisposition", "destinationEncryptionConfiguration", "destinationExpirationTime", "destinationTable", "operationType", "sourceTable", "sourceTables", "writeDisposition"]
#
# createDisposition: string
# destinationEncryptionConfiguration: $ref: EncryptionConfiguration
# destinationExpirationTime: string, format: google-datetime
# destinationTable: $ref: TableReference
# operationType: string, enum: [OPERATION_TYPE_UNSPECIFIED, COPY, SNAPSHOT, RESTORE, CLONE]
# sourceTable: $ref: TableReference
# sourceTables: array<TableReference>
# writeDisposition: string
#
# [types.field_overrides]
# # operationType = { enum_type = "JobConfigurationTableCopyOperationType" }
# --- JobCreationReason (1 fields) ---
# Reason about why a Job was created from a [`jobs.query`](https://cloud.google.com/bigquery/docs/refe
# [[types]]
# schema = "JobCreationReason"
# include_fields = ["code"]
#
# code: string, enum: [CODE_UNSPECIFIED, REQUESTED, LONG_RUNNING, LARGE_RESULTS, OTHER], readOnly
#
# [types.field_overrides]
# # code = { enum_type = "JobCreationReasonCode" }
# --- JobList (5 fields) [IN MANIFEST] ---
# JobList is the response format for a jobs.list call.
# [[types]]
# schema = "JobList"
# include_fields = ["etag", "jobs", "kind", "nextPageToken", "unreachable"]
#
# etag: string
# jobs: array<object>
# kind: string
# nextPageToken: string
# unreachable: array<string>
# --- JobReference (3 fields) [IN MANIFEST] ---
# A job reference is a fully qualified identifier for referring to a job.
# [[types]]
# schema = "JobReference"
# include_fields = ["jobId", "location", "projectId"]
#
# jobId: string
# location: string
# projectId: string
# --- JobStatistics (23 fields) [IN MANIFEST] ---
# Statistics for a single job execution.
# [[types]]
# schema = "JobStatistics"
# include_fields = ["completionRatio", "copy", "creationTime", "dataMaskingStatistics", "edition", "endTime", "extract", "finalExecutionDurationMs", "load", "numChildJobs", "parentJobId", "query", "quotaDeferments", "reservationGroupPath", "reservationUsage", "reservation_id", "rowLevelSecurityStatistics", "scriptStatistics", "sessionInfo", "startTime", "totalBytesProcessed", "totalSlotMs", "transactionInfo"]
#
# completionRatio: number, format: double, readOnly
# copy: $ref: JobStatistics5, readOnly
# creationTime: string, format: int64, readOnly
# dataMaskingStatistics: $ref: DataMaskingStatistics, readOnly
# edition: string, enum: [RESERVATION_EDITION_UNSPECIFIED, STANDARD, ENTERPRISE, ENTERPRISE_PLUS], readOnly
# endTime: string, format: int64, readOnly
# extract: $ref: JobStatistics4, readOnly
# finalExecutionDurationMs: string, format: int64, readOnly
# load: $ref: JobStatistics3, readOnly
# numChildJobs: string, format: int64, readOnly
# parentJobId: string, readOnly
# query: $ref: JobStatistics2, readOnly
# quotaDeferments: array<string>, readOnly
# reservationGroupPath: array<string>, readOnly
# reservationUsage: array<object>, readOnly
# reservation_id: string, readOnly
# rowLevelSecurityStatistics: $ref: RowLevelSecurityStatistics, readOnly
# scriptStatistics: $ref: ScriptStatistics, readOnly
# sessionInfo: $ref: SessionInfo, readOnly
# startTime: string, format: int64, readOnly
# totalBytesProcessed: string, format: int64, readOnly
# totalSlotMs: string, format: int64, readOnly
# transactionInfo: $ref: TransactionInfo, readOnly
#
# [types.field_overrides]
# # edition = { enum_type = "JobStatisticsEdition" }
# --- JobStatistics2 (46 fields) ---
# Statistics for a query job.
# [[types]]
# schema = "JobStatistics2"
# include_fields = ["biEngineStatistics", "billingTier", "cacheHit", "dclTargetDataset", "dclTargetTable", "dclTargetView", "ddlAffectedRowAccessPolicyCount", "ddlDestinationTable", "ddlOperationPerformed", "ddlTargetDataset", "ddlTargetRoutine", "ddlTargetRowAccessPolicy", "ddlTargetTable", "dmlStats", "estimatedBytesProcessed", "exportDataStatistics", "externalServiceCosts", "incrementalResultStats", "loadQueryStatistics", "materializedViewStatistics", "metadataCacheStatistics", "mlStatistics", "modelTraining", "modelTrainingCurrentIteration", "modelTrainingExpectedTotalIteration", "numDmlAffectedRows", "performanceInsights", "queryInfo", "queryPlan", "referencedRoutines", "referencedTables", "reservationUsage", "schema", "searchStatistics", "sparkStatistics", "statementType", "timeline", "totalBytesBilled", "totalBytesProcessed", "totalBytesProcessedAccuracy", "totalPartitionsProcessed", "totalServicesSkuSlotMs", "totalSlotMs", "transferredBytes", "undeclaredQueryParameters", "vectorSearchStatistics"]
#
# biEngineStatistics: $ref: BiEngineStatistics, readOnly
# billingTier: integer, format: int32, readOnly
# cacheHit: boolean, readOnly
# dclTargetDataset: $ref: DatasetReference, readOnly
# dclTargetTable: $ref: TableReference, readOnly
# dclTargetView: $ref: TableReference, readOnly
# ddlAffectedRowAccessPolicyCount: string, format: int64, readOnly
# ddlDestinationTable: $ref: TableReference, readOnly
# ddlOperationPerformed: string, readOnly
# ddlTargetDataset: $ref: DatasetReference, readOnly
# ddlTargetRoutine: $ref: RoutineReference, readOnly
# ddlTargetRowAccessPolicy: $ref: RowAccessPolicyReference, readOnly
# ddlTargetTable: $ref: TableReference, readOnly
# dmlStats: $ref: DmlStatistics, readOnly
# estimatedBytesProcessed: string, format: int64, readOnly
# exportDataStatistics: $ref: ExportDataStatistics, readOnly
# externalServiceCosts: array<ExternalServiceCost>, readOnly
# incrementalResultStats: $ref: IncrementalResultStats, readOnly
# loadQueryStatistics: $ref: LoadQueryStatistics, readOnly
# materializedViewStatistics: $ref: MaterializedViewStatistics, readOnly
# metadataCacheStatistics: $ref: MetadataCacheStatistics, readOnly
# mlStatistics: $ref: MlStatistics, readOnly
# modelTraining: $ref: BigQueryModelTraining
# modelTrainingCurrentIteration: integer, format: int32
# modelTrainingExpectedTotalIteration: string, format: int64
# numDmlAffectedRows: string, format: int64, readOnly
# performanceInsights: $ref: PerformanceInsights, readOnly
# queryInfo: $ref: QueryInfo, readOnly
# queryPlan: array<ExplainQueryStage>, readOnly
# referencedRoutines: array<RoutineReference>, readOnly
# referencedTables: array<TableReference>, readOnly
# reservationUsage: array<object>, readOnly
# schema: $ref: TableSchema, readOnly
# searchStatistics: $ref: SearchStatistics, readOnly
# sparkStatistics: $ref: SparkStatistics, readOnly
# statementType: string, readOnly
# timeline: array<QueryTimelineSample>, readOnly
# totalBytesBilled: string, format: int64, readOnly
# totalBytesProcessed: string, format: int64, readOnly
# totalBytesProcessedAccuracy: string, readOnly
# totalPartitionsProcessed: string, format: int64, readOnly
# totalServicesSkuSlotMs: string, format: int64, readOnly
# totalSlotMs: string, format: int64, readOnly
# transferredBytes: string, format: int64, readOnly
# undeclaredQueryParameters: array<QueryParameter>, readOnly
# vectorSearchStatistics: $ref: VectorSearchStatistics, readOnly
# --- JobStatistics3 (6 fields) ---
# Statistics for a load job.
# [[types]]
# schema = "JobStatistics3"
# include_fields = ["badRecords", "inputFileBytes", "inputFiles", "outputBytes", "outputRows", "timeline"]
#
# badRecords: string, format: int64, readOnly
# inputFileBytes: string, format: int64, readOnly
# inputFiles: string, format: int64, readOnly
# outputBytes: string, format: int64, readOnly
# outputRows: string, format: int64, readOnly
# timeline: array<QueryTimelineSample>, readOnly
# --- JobStatistics4 (3 fields) ---
# Statistics for an extract job.
# [[types]]
# schema = "JobStatistics4"
# include_fields = ["destinationUriFileCounts", "inputBytes", "timeline"]
#
# destinationUriFileCounts: array<string>, readOnly
# inputBytes: string, format: int64, readOnly
# timeline: array<QueryTimelineSample>, readOnly
# --- JobStatistics5 (2 fields) ---
# Statistics for a copy job.
# [[types]]
# schema = "JobStatistics5"
# include_fields = ["copiedLogicalBytes", "copiedRows"]
#
# copiedLogicalBytes: string, format: int64, readOnly
# copiedRows: string, format: int64, readOnly
# --- JobStatus (3 fields) [IN MANIFEST] ---
# [[types]]
# schema = "JobStatus"
# include_fields = ["errorResult", "errors", "state"]
#
# errorResult: $ref: ErrorProto, readOnly
# errors: array<ErrorProto>, readOnly
# state: string, readOnly
# --- JoinRestrictionPolicy (2 fields) ---
# Represents privacy policy associated with "join restrictions". Join restriction gives data providers
# [[types]]
# schema = "JoinRestrictionPolicy"
# include_fields = ["joinAllowedColumns", "joinCondition"]
#
# joinAllowedColumns: array<string>
# joinCondition: string, enum: [JOIN_CONDITION_UNSPECIFIED, JOIN_ANY, JOIN_ALL, JOIN_NOT_REQUIRED, JOIN_BLOCKED]
#
# [types.field_overrides]
# # joinCondition = { enum_type = "JoinRestrictionPolicyJoinCondition" }
# --- JsonObject (0 fields) ---
# Represents a single JSON object.
# [[types]]
# schema = "JsonObject"
# --- JsonOptions (1 fields) ---
# Json Options for load and make external tables.
# [[types]]
# schema = "JsonOptions"
# include_fields = ["encoding"]
#
# encoding: string
# --- JsonValue (0 fields) ---
# [[types]]
# schema = "JsonValue"
# --- LinkedDatasetMetadata (1 fields) ---
# Metadata about the Linked Dataset.
# [[types]]
# schema = "LinkedDatasetMetadata"
# include_fields = ["linkState"]
#
# linkState: string, enum: [LINK_STATE_UNSPECIFIED, LINKED, UNLINKED], readOnly
#
# [types.field_overrides]
# # linkState = { enum_type = "LinkedDatasetMetadataLinkState" }
# --- LinkedDatasetSource (1 fields) ---
# A dataset source type which refers to another BigQuery dataset.
# [[types]]
# schema = "LinkedDatasetSource"
# include_fields = ["sourceDataset"]
#
# sourceDataset: $ref: DatasetReference
# --- ListModelsResponse (2 fields) ---
# Response format for a single page when listing BigQuery ML models.
# [[types]]
# schema = "ListModelsResponse"
# include_fields = ["models", "nextPageToken"]
#
# models: array<Model>
# nextPageToken: string
# --- ListRoutinesResponse (2 fields) ---
# Describes the format of a single result page when listing routines.
# [[types]]
# schema = "ListRoutinesResponse"
# include_fields = ["nextPageToken", "routines"]
#
# nextPageToken: string
# routines: array<Routine>
# --- ListRowAccessPoliciesResponse (2 fields) ---
# Response message for the ListRowAccessPolicies method.
# [[types]]
# schema = "ListRowAccessPoliciesResponse"
# include_fields = ["nextPageToken", "rowAccessPolicies"]
#
# nextPageToken: string
# rowAccessPolicies: array<RowAccessPolicy>
# --- LoadQueryStatistics (6 fields) ---
# Statistics for a LOAD query.
# [[types]]
# schema = "LoadQueryStatistics"
# include_fields = ["badRecords", "bytesTransferred", "inputFileBytes", "inputFiles", "outputBytes", "outputRows"]
#
# badRecords: string, format: int64, readOnly
# bytesTransferred: string, format: int64, readOnly
# inputFileBytes: string, format: int64, readOnly
# inputFiles: string, format: int64, readOnly
# outputBytes: string, format: int64, readOnly
# outputRows: string, format: int64, readOnly
# --- LocationMetadata (1 fields) ---
# BigQuery-specific metadata about a location. This will be set on google.cloud.location.Location.meta
# [[types]]
# schema = "LocationMetadata"
# include_fields = ["legacyLocationId"]
#
# legacyLocationId: string
# --- MaterializedView (4 fields) ---
# A materialized view considered for a query job.
# [[types]]
# schema = "MaterializedView"
# include_fields = ["chosen", "estimatedBytesSaved", "rejectedReason", "tableReference"]
#
# chosen: boolean
# estimatedBytesSaved: string, format: int64
# rejectedReason: string, enum: [REJECTED_REASON_UNSPECIFIED, NO_DATA, COST, BASE_TABLE_TRUNCATED, ... +8]
# tableReference: $ref: TableReference
#
# [types.field_overrides]
# # rejectedReason = { enum_type = "MaterializedViewRejectedReason" }
# --- MaterializedViewDefinition (6 fields) ---
# Definition and configuration of a materialized view.
# WARNING: format:"byte" fields: maxStaleness
# [[types]]
# schema = "MaterializedViewDefinition"
# include_fields = ["allowNonIncrementalDefinition", "enableRefresh", "lastRefreshTime", "maxStaleness", "query", "refreshIntervalMs"]
#
# allowNonIncrementalDefinition: boolean
# enableRefresh: boolean
# lastRefreshTime: string, format: int64, readOnly
# maxStaleness: string, format: byte
# query: string
# refreshIntervalMs: string, format: int64
#
# [types.field_overrides]
# maxStaleness = { format = "bytes" }
# --- MaterializedViewStatistics (1 fields) ---
# Statistics of materialized views considered in a query job.
# [[types]]
# schema = "MaterializedViewStatistics"
# include_fields = ["materializedView"]
#
# materializedView: array<MaterializedView>
# --- MaterializedViewStatus (2 fields) ---
# Status of a materialized view. The last refresh timestamp status is omitted here, but is present in
# [[types]]
# schema = "MaterializedViewStatus"
# include_fields = ["lastRefreshStatus", "refreshWatermark"]
#
# lastRefreshStatus: $ref: ErrorProto, readOnly
# refreshWatermark: string, format: google-datetime, readOnly
# --- MetadataCacheStatistics (1 fields) ---
# Statistics for metadata caching in queried tables.
# [[types]]
# schema = "MetadataCacheStatistics"
# include_fields = ["tableMetadataCacheUsage"]
#
# tableMetadataCacheUsage: array<TableMetadataCacheUsage>
# --- MlStatistics (5 fields) ---
# Job statistics specific to a BigQuery ML training job.
# [[types]]
# schema = "MlStatistics"
# include_fields = ["hparamTrials", "iterationResults", "maxIterations", "modelType", "trainingType"]
#
# hparamTrials: array<HparamTuningTrial>, readOnly
# iterationResults: array<IterationResult>
# maxIterations: string, format: int64, readOnly
# modelType: string, enum: [MODEL_TYPE_UNSPECIFIED, LINEAR_REGRESSION, LOGISTIC_REGRESSION, KMEANS, ... +22], readOnly
# trainingType: string, enum: [TRAINING_TYPE_UNSPECIFIED, SINGLE_TRAINING, HPARAM_TUNING], readOnly
#
# [types.field_overrides]
# # modelType = { enum_type = "MlStatisticsModelType" }
# # trainingType = { enum_type = "MlStatisticsTrainingType" }
# --- Model (21 fields) ---
# [[types]]
# schema = "Model"
# include_fields = ["bestTrialId", "creationTime", "defaultTrialId", "description", "encryptionConfiguration", "etag", "expirationTime", "featureColumns", "friendlyName", "hparamSearchSpaces", "hparamTrials", "labelColumns", "labels", "lastModifiedTime", "location", "modelReference", "modelType", "optimalTrialIds", "remoteModelInfo", "trainingRuns", "transformColumns"]
#
# bestTrialId: string, format: int64
# creationTime: string, format: int64, readOnly
# defaultTrialId: string, format: int64, readOnly
# description: string
# encryptionConfiguration: $ref: EncryptionConfiguration
# etag: string, readOnly
# expirationTime: string, format: int64
# featureColumns: array<StandardSqlField>, readOnly
# friendlyName: string
# hparamSearchSpaces: $ref: HparamSearchSpaces, readOnly
# hparamTrials: array<HparamTuningTrial>, readOnly
# labelColumns: array<StandardSqlField>, readOnly
# labels: map<string, string>
# lastModifiedTime: string, format: int64, readOnly
# location: string, readOnly
# modelReference: $ref: ModelReference
# modelType: string, enum: [MODEL_TYPE_UNSPECIFIED, LINEAR_REGRESSION, LOGISTIC_REGRESSION, KMEANS, ... +22], readOnly
# optimalTrialIds: array<string>, readOnly
# remoteModelInfo: $ref: RemoteModelInfo, readOnly
# trainingRuns: array<TrainingRun>
# transformColumns: array<TransformColumn>, readOnly
#
# [types.field_overrides]
# # modelType = { enum_type = "ModelModelType" }
# --- ModelDefinition (2 fields) ---
# [[types]]
# schema = "ModelDefinition"
# include_fields = ["modelOptions", "trainingRuns"]
#
# modelOptions: object
# trainingRuns: array<BqmlTrainingRun>
# --- ModelExtractOptions (1 fields) ---
# Options related to model extraction.
# [[types]]
# schema = "ModelExtractOptions"
# include_fields = ["trialId"]
#
# trialId: string, format: int64
# --- ModelReference (3 fields) ---
# Id path of a model.
# [[types]]
# schema = "ModelReference"
# include_fields = ["datasetId", "modelId", "projectId"]
#
# datasetId: string
# modelId: string
# projectId: string
# --- MultiClassClassificationMetrics (2 fields) ---
# Evaluation metrics for multi-class classification/classifier models.
# [[types]]
# schema = "MultiClassClassificationMetrics"
# include_fields = ["aggregateClassificationMetrics", "confusionMatrixList"]
#
# aggregateClassificationMetrics: $ref: AggregateClassificationMetrics
# confusionMatrixList: array<ConfusionMatrix>
# --- ParquetOptions (3 fields) ---
# Parquet Options for load and make external tables.
# [[types]]
# schema = "ParquetOptions"
# include_fields = ["enableListInference", "enumAsString", "mapTargetType"]
#
# enableListInference: boolean
# enumAsString: boolean
# mapTargetType: string, enum: [MAP_TARGET_TYPE_UNSPECIFIED, ARRAY_OF_STRUCT]
#
# [types.field_overrides]
# # mapTargetType = { enum_type = "ParquetOptionsMapTargetType" }
# --- PartitionSkew (1 fields) ---
# Partition skew detailed information.
# [[types]]
# schema = "PartitionSkew"
# include_fields = ["skewSources"]
#
# skewSources: array<SkewSource>, readOnly
# --- PartitionedColumn (1 fields) ---
# The partitioning column information.
# [[types]]
# schema = "PartitionedColumn"
# include_fields = ["field"]
#
# field: string
# --- PartitioningDefinition (1 fields) ---
# The partitioning information, which includes managed table, external table and metastore partitioned
# [[types]]
# schema = "PartitioningDefinition"
# include_fields = ["partitionedColumn"]
#
# partitionedColumn: array<PartitionedColumn>
# --- PerformanceInsights (3 fields) ---
# Performance insights for the job.
# [[types]]
# schema = "PerformanceInsights"
# include_fields = ["avgPreviousExecutionMs", "stagePerformanceChangeInsights", "stagePerformanceStandaloneInsights"]
#
# avgPreviousExecutionMs: string, format: int64, readOnly
# stagePerformanceChangeInsights: array<StagePerformanceChangeInsight>, readOnly
# stagePerformanceStandaloneInsights: array<StagePerformanceStandaloneInsight>, readOnly
# --- Policy (4 fields) ---
# An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud res
# WARNING: format:"byte" fields: etag
# [[types]]
# schema = "Policy"
# include_fields = ["auditConfigs", "bindings", "etag", "version"]
#
# auditConfigs: array<AuditConfig>
# bindings: array<Binding>
# etag: string, format: byte
# version: integer, format: int32
#
# [types.field_overrides]
# etag = { format = "bytes" }
# --- PrincipalComponentInfo (4 fields) ---
# Principal component infos, used only for eigen decomposition based models, e.g., PCA. Ordered by exp
# [[types]]
# schema = "PrincipalComponentInfo"
# include_fields = ["cumulativeExplainedVarianceRatio", "explainedVariance", "explainedVarianceRatio", "principalComponentId"]
#
# cumulativeExplainedVarianceRatio: number, format: double
# explainedVariance: number, format: double
# explainedVarianceRatio: number, format: double
# principalComponentId: string, format: int64
# --- PrivacyPolicy (3 fields) ---
# Represents privacy policy that contains the privacy requirements specified by the data owner. Curren
# [[types]]
# schema = "PrivacyPolicy"
# include_fields = ["aggregationThresholdPolicy", "differentialPrivacyPolicy", "joinRestrictionPolicy"]
#
# aggregationThresholdPolicy: $ref: AggregationThresholdPolicy
# differentialPrivacyPolicy: $ref: DifferentialPrivacyPolicy
# joinRestrictionPolicy: $ref: JoinRestrictionPolicy
# --- ProjectList (5 fields) ---
# Response object of ListProjects
# [[types]]
# schema = "ProjectList"
# include_fields = ["etag", "kind", "nextPageToken", "projects", "totalItems"]
#
# etag: string
# kind: string
# nextPageToken: string
# projects: array<object>
# totalItems: integer, format: int32
# --- ProjectReference (1 fields) ---
# A unique reference to a project.
# [[types]]
# schema = "ProjectReference"
# include_fields = ["projectId"]
#
# projectId: string
# --- PruningStats (3 fields) ---
# The column metadata index pruning statistics.
# [[types]]
# schema = "PruningStats"
# include_fields = ["postCmetaPruningParallelInputCount", "postCmetaPruningPartitionCount", "preCmetaPruningParallelInputCount"]
#
# postCmetaPruningParallelInputCount: string, format: int64
# postCmetaPruningPartitionCount: string, format: int64
# preCmetaPruningParallelInputCount: string, format: int64
# --- PythonOptions (2 fields) ---
# Options for a user-defined Python function.
# [[types]]
# schema = "PythonOptions"
# include_fields = ["entryPoint", "packages"]
#
# entryPoint: string
# packages: array<string>
# --- QueryInfo (1 fields) ---
# Query optimization information for a QUERY job.
# [[types]]
# schema = "QueryInfo"
# include_fields = ["optimizationDetails"]
#
# optimizationDetails: map<string, any>, readOnly
# --- QueryParameter (3 fields) ---
# A parameter given to a query.
# [[types]]
# schema = "QueryParameter"
# include_fields = ["name", "parameterType", "parameterValue"]
#
# name: string
# parameterType: $ref: QueryParameterType
# parameterValue: $ref: QueryParameterValue
#
# [types.field_overrides]
# name = { required = true }
# --- QueryParameterType (5 fields) ---
# The type of a query parameter.
# WARNING: reserved words: type
# [[types]]
# schema = "QueryParameterType"
# include_fields = ["arrayType", "rangeElementType", "structTypes", "timestampPrecision", "type"]
#
# arrayType: $ref: QueryParameterType
# rangeElementType: $ref: QueryParameterType
# structTypes: array<object>
# timestampPrecision: string, format: int64
# type: string, RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# --- QueryParameterValue (4 fields) ---
# The value of a query parameter.
# [[types]]
# schema = "QueryParameterValue"
# include_fields = ["arrayValues", "rangeValue", "structValues", "value"]
#
# arrayValues: array<QueryParameterValue>
# rangeValue: $ref: RangeValue
# structValues: map<string, QueryParameterValue>
# value: string
# --- QueryRequest (25 fields) [IN MANIFEST] ---
# Describes the format of the jobs.query request.
# [[types]]
# schema = "QueryRequest"
# include_fields = ["connectionProperties", "continuous", "createSession", "defaultDataset", "destinationEncryptionConfiguration", "dryRun", "formatOptions", "jobCreationMode", "jobTimeoutMs", "kind", "labels", "location", "maxResults", "maxSlots", "maximumBytesBilled", "parameterMode", "preserveNulls", "query", "queryParameters", "requestId", "reservation", "timeoutMs", "useLegacySql", "useQueryCache", "writeIncrementalResults"]
#
# connectionProperties: array<ConnectionProperty>
# continuous: boolean
# createSession: boolean
# defaultDataset: $ref: DatasetReference
# destinationEncryptionConfiguration: $ref: EncryptionConfiguration
# dryRun: boolean
# formatOptions: $ref: DataFormatOptions
# jobCreationMode: string, enum: [JOB_CREATION_MODE_UNSPECIFIED, JOB_CREATION_REQUIRED, JOB_CREATION_OPTIONAL]
# jobTimeoutMs: string, format: int64
# kind: string
# labels: map<string, string>
# location: string
# maxResults: integer, format: uint32
# maxSlots: integer, format: int32
# maximumBytesBilled: string, format: int64
# parameterMode: string
# preserveNulls: boolean
# query: string
# queryParameters: array<QueryParameter>
# requestId: string
# reservation: string
# timeoutMs: integer, format: uint32
# useLegacySql: boolean
# useQueryCache: boolean
# writeIncrementalResults: boolean
#
# [types.field_overrides]
# # jobCreationMode = { enum_type = "QueryRequestJobCreationMode" }
# --- QueryResponse (21 fields) [IN MANIFEST] ---
# [[types]]
# schema = "QueryResponse"
# include_fields = ["cacheHit", "creationTime", "dmlStats", "endTime", "errors", "jobComplete", "jobCreationReason", "jobReference", "kind", "location", "numDmlAffectedRows", "pageToken", "queryId", "rows", "schema", "sessionInfo", "startTime", "totalBytesBilled", "totalBytesProcessed", "totalRows", "totalSlotMs"]
#
# cacheHit: boolean
# creationTime: string, format: int64, readOnly
# dmlStats: $ref: DmlStatistics, readOnly
# endTime: string, format: int64, readOnly
# errors: array<ErrorProto>, readOnly
# jobComplete: boolean
# jobCreationReason: $ref: JobCreationReason
# jobReference: $ref: JobReference
# kind: string
# location: string, readOnly
# numDmlAffectedRows: string, format: int64, readOnly
# pageToken: string
# queryId: string
# rows: array<TableRow>
# schema: $ref: TableSchema
# sessionInfo: $ref: SessionInfo, readOnly
# startTime: string, format: int64, readOnly
# totalBytesBilled: string, format: int64, readOnly
# totalBytesProcessed: string, format: int64
# totalRows: string, format: uint64
# totalSlotMs: string, format: int64, readOnly
# --- QueryTimelineSample (7 fields) ---
# Summary of the state of query execution at a given time.
# [[types]]
# schema = "QueryTimelineSample"
# include_fields = ["activeUnits", "completedUnits", "elapsedMs", "estimatedRunnableUnits", "pendingUnits", "shuffleRamUsageRatio", "totalSlotMs"]
#
# activeUnits: string, format: int64
# completedUnits: string, format: int64
# elapsedMs: string, format: int64
# estimatedRunnableUnits: string, format: int64
# pendingUnits: string, format: int64
# shuffleRamUsageRatio: number, format: double
# totalSlotMs: string, format: int64
# --- RangePartitioning (2 fields) [IN MANIFEST] ---
# [[types]]
# schema = "RangePartitioning"
# include_fields = ["field", "range"]
#
# field: string
# range: object
# --- RangeValue (2 fields) ---
# Represents the value of a range.
# [[types]]
# schema = "RangeValue"
# include_fields = ["end", "start"]
#
# end: $ref: QueryParameterValue
# start: $ref: QueryParameterValue
# --- RankingMetrics (4 fields) ---
# Evaluation metrics used by weighted-ALS models specified by feedback_type=implicit.
# [[types]]
# schema = "RankingMetrics"
# include_fields = ["averageRank", "meanAveragePrecision", "meanSquaredError", "normalizedDiscountedCumulativeGain"]
#
# averageRank: number, format: double
# meanAveragePrecision: number, format: double
# meanSquaredError: number, format: double
# normalizedDiscountedCumulativeGain: number, format: double
# --- RegressionMetrics (5 fields) ---
# Evaluation metrics for regression and explicit feedback type matrix factorization models.
# [[types]]
# schema = "RegressionMetrics"
# include_fields = ["meanAbsoluteError", "meanSquaredError", "meanSquaredLogError", "medianAbsoluteError", "rSquared"]
#
# meanAbsoluteError: number, format: double
# meanSquaredError: number, format: double
# meanSquaredLogError: number, format: double
# medianAbsoluteError: number, format: double
# rSquared: number, format: double
# --- RemoteFunctionOptions (4 fields) ---
# Options for a remote user-defined function.
# [[types]]
# schema = "RemoteFunctionOptions"
# include_fields = ["connection", "endpoint", "maxBatchingRows", "userDefinedContext"]
#
# connection: string
# endpoint: string
# maxBatchingRows: string, format: int64
# userDefinedContext: map<string, string>
# --- RemoteModelInfo (6 fields) ---
# Remote Model Info
# [[types]]
# schema = "RemoteModelInfo"
# include_fields = ["connection", "endpoint", "maxBatchingRows", "remoteModelVersion", "remoteServiceType", "speechRecognizer"]
#
# connection: string, readOnly
# endpoint: string, readOnly
# maxBatchingRows: string, format: int64, readOnly
# remoteModelVersion: string, readOnly
# remoteServiceType: string, enum: [REMOTE_SERVICE_TYPE_UNSPECIFIED, CLOUD_AI_TRANSLATE_V3, CLOUD_AI_VISION_V1, CLOUD_AI_NATURAL_LANGUAGE_V1, CLOUD_AI_SPEECH_TO_TEXT_V2], readOnly
# speechRecognizer: string, readOnly
#
# [types.field_overrides]
# # remoteServiceType = { enum_type = "RemoteModelInfoRemoteServiceType" }
# --- RestrictionConfig (1 fields) ---
# WARNING: reserved words: type
# [[types]]
# schema = "RestrictionConfig"
# include_fields = ["type"]
#
# type: string, enum: [RESTRICTION_TYPE_UNSPECIFIED, RESTRICTED_DATA_EGRESS], readOnly, RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # type = { enum_type = "RestrictionConfigType" }
# --- Routine (20 fields) ---
# A user-defined function or a stored procedure.
# [[types]]
# schema = "Routine"
# include_fields = ["arguments", "creationTime", "dataGovernanceType", "definitionBody", "description", "determinismLevel", "etag", "externalRuntimeOptions", "importedLibraries", "language", "lastModifiedTime", "pythonOptions", "remoteFunctionOptions", "returnTableType", "returnType", "routineReference", "routineType", "securityMode", "sparkOptions", "strictMode"]
#
# arguments: array<Argument>
# creationTime: string, format: int64, readOnly
# dataGovernanceType: string, enum: [DATA_GOVERNANCE_TYPE_UNSPECIFIED, DATA_MASKING]
# definitionBody: string
# description: string
# determinismLevel: string, enum: [DETERMINISM_LEVEL_UNSPECIFIED, DETERMINISTIC, NOT_DETERMINISTIC]
# etag: string, readOnly
# externalRuntimeOptions: $ref: ExternalRuntimeOptions
# importedLibraries: array<string>
# language: string, enum: [LANGUAGE_UNSPECIFIED, SQL, JAVASCRIPT, PYTHON, ... +2]
# lastModifiedTime: string, format: int64, readOnly
# pythonOptions: $ref: PythonOptions
# remoteFunctionOptions: $ref: RemoteFunctionOptions
# returnTableType: $ref: StandardSqlTableType
# returnType: $ref: StandardSqlDataType
# routineReference: $ref: RoutineReference
# routineType: string, enum: [ROUTINE_TYPE_UNSPECIFIED, SCALAR_FUNCTION, PROCEDURE, TABLE_VALUED_FUNCTION, AGGREGATE_FUNCTION]
# securityMode: string, enum: [SECURITY_MODE_UNSPECIFIED, DEFINER, INVOKER]
# sparkOptions: $ref: SparkOptions
# strictMode: boolean
#
# [types.field_overrides]
# # dataGovernanceType = { enum_type = "RoutineDataGovernanceType" }
# # determinismLevel = { enum_type = "RoutineDeterminismLevel" }
# # language = { enum_type = "RoutineLanguage" }
# # routineType = { enum_type = "RoutineRoutineType" }
# # securityMode = { enum_type = "RoutineSecurityMode" }
# --- RoutineReference (3 fields) ---
# Id path of a routine.
# [[types]]
# schema = "RoutineReference"
# include_fields = ["datasetId", "projectId", "routineId"]
#
# datasetId: string
# projectId: string
# routineId: string
# --- Row (2 fields) ---
# A single row in the confusion matrix.
# [[types]]
# schema = "Row"
# include_fields = ["actualLabel", "entries"]
#
# actualLabel: string
# entries: array<Entry>
# --- RowAccessPolicy (6 fields) ---
# Represents access on a subset of rows on the specified table, defined by its filter predicate. Acces
# [[types]]
# schema = "RowAccessPolicy"
# include_fields = ["creationTime", "etag", "filterPredicate", "grantees", "lastModifiedTime", "rowAccessPolicyReference"]
#
# creationTime: string, format: google-datetime, readOnly
# etag: string, readOnly
# filterPredicate: string
# grantees: array<string>
# lastModifiedTime: string, format: google-datetime, readOnly
# rowAccessPolicyReference: $ref: RowAccessPolicyReference
# --- RowAccessPolicyReference (4 fields) ---
# Id path of a row access policy.
# [[types]]
# schema = "RowAccessPolicyReference"
# include_fields = ["datasetId", "policyId", "projectId", "tableId"]
#
# datasetId: string
# policyId: string
# projectId: string
# tableId: string
# --- RowLevelSecurityStatistics (1 fields) ---
# Statistics for row-level security.
# [[types]]
# schema = "RowLevelSecurityStatistics"
# include_fields = ["rowLevelSecurityApplied"]
#
# rowLevelSecurityApplied: boolean
# --- ScriptOptions (3 fields) ---
# Options related to script execution.
# [[types]]
# schema = "ScriptOptions"
# include_fields = ["keyResultStatement", "statementByteBudget", "statementTimeoutMs"]
#
# keyResultStatement: string, enum: [KEY_RESULT_STATEMENT_KIND_UNSPECIFIED, LAST, FIRST_SELECT]
# statementByteBudget: string, format: int64
# statementTimeoutMs: string, format: int64
#
# [types.field_overrides]
# # keyResultStatement = { enum_type = "ScriptOptionsKeyResultStatement" }
# --- ScriptStackFrame (6 fields) ---
# Represents the location of the statement/expression being evaluated. Line and column numbers are def
# [[types]]
# schema = "ScriptStackFrame"
# include_fields = ["endColumn", "endLine", "procedureId", "startColumn", "startLine", "text"]
#
# endColumn: integer, format: int32, readOnly
# endLine: integer, format: int32, readOnly
# procedureId: string, readOnly
# startColumn: integer, format: int32, readOnly
# startLine: integer, format: int32, readOnly
# text: string, readOnly
# --- ScriptStatistics (2 fields) ---
# Job statistics specific to the child job of a script.
# [[types]]
# schema = "ScriptStatistics"
# include_fields = ["evaluationKind", "stackFrames"]
#
# evaluationKind: string, enum: [EVALUATION_KIND_UNSPECIFIED, STATEMENT, EXPRESSION]
# stackFrames: array<ScriptStackFrame>
#
# [types.field_overrides]
# # evaluationKind = { enum_type = "ScriptStatisticsEvaluationKind" }
# --- SearchStatistics (3 fields) ---
# Statistics for a search query. Populated as part of JobStatistics2.
# [[types]]
# schema = "SearchStatistics"
# include_fields = ["indexPruningStats", "indexUnusedReasons", "indexUsageMode"]
#
# indexPruningStats: array<IndexPruningStats>
# indexUnusedReasons: array<IndexUnusedReason>
# indexUsageMode: string, enum: [INDEX_USAGE_MODE_UNSPECIFIED, UNUSED, PARTIALLY_USED, FULLY_USED]
#
# [types.field_overrides]
# # indexUsageMode = { enum_type = "SearchStatisticsIndexUsageMode" }
# --- SerDeInfo (3 fields) ---
# Serializer and deserializer information.
# [[types]]
# schema = "SerDeInfo"
# include_fields = ["name", "parameters", "serializationLibrary"]
#
# name: string
# parameters: map<string, string>
# serializationLibrary: string
#
# [types.field_overrides]
# name = { required = true }
# --- SessionInfo (1 fields) ---
# [Preview] Information related to sessions.
# [[types]]
# schema = "SessionInfo"
# include_fields = ["sessionId"]
#
# sessionId: string, readOnly
# --- SetIamPolicyRequest (2 fields) ---
# Request message for `SetIamPolicy` method.
# [[types]]
# schema = "SetIamPolicyRequest"
# include_fields = ["policy", "updateMask"]
#
# policy: $ref: Policy
# updateMask: string, format: google-fieldmask
# --- SkewSource (1 fields) ---
# Details about source stages which produce skewed data.
# [[types]]
# schema = "SkewSource"
# include_fields = ["stageId"]
#
# stageId: string, format: int64, readOnly
# --- SnapshotDefinition (2 fields) ---
# Information about base table and snapshot time of the snapshot.
# [[types]]
# schema = "SnapshotDefinition"
# include_fields = ["baseTableReference", "snapshotTime"]
#
# baseTableReference: $ref: TableReference
# snapshotTime: string, format: date-time
# --- SparkLoggingInfo (2 fields) ---
# Spark job logs can be filtered by these fields in Cloud Logging.
# [[types]]
# schema = "SparkLoggingInfo"
# include_fields = ["projectId", "resourceType"]
#
# projectId: string, readOnly
# resourceType: string, readOnly
# --- SparkOptions (10 fields) ---
# Options for a user-defined Spark routine.
# [[types]]
# schema = "SparkOptions"
# include_fields = ["archiveUris", "connection", "containerImage", "fileUris", "jarUris", "mainClass", "mainFileUri", "properties", "pyFileUris", "runtimeVersion"]
#
# archiveUris: array<string>
# connection: string
# containerImage: string
# fileUris: array<string>
# jarUris: array<string>
# mainClass: string
# mainFileUri: string
# properties: map<string, string>
# pyFileUris: array<string>
# runtimeVersion: string
# --- SparkStatistics (6 fields) ---
# Statistics for a BigSpark query. Populated as part of JobStatistics2
# [[types]]
# schema = "SparkStatistics"
# include_fields = ["endpoints", "gcsStagingBucket", "kmsKeyName", "loggingInfo", "sparkJobId", "sparkJobLocation"]
#
# endpoints: map<string, string>, readOnly
# gcsStagingBucket: string, readOnly
# kmsKeyName: string, readOnly
# loggingInfo: $ref: SparkLoggingInfo, readOnly
# sparkJobId: string, readOnly
# sparkJobLocation: string, readOnly
# --- StagePerformanceChangeInsight (2 fields) ---
# Performance insights compared to the previous executions for a specific stage.
# [[types]]
# schema = "StagePerformanceChangeInsight"
# include_fields = ["inputDataChange", "stageId"]
#
# inputDataChange: $ref: InputDataChange, readOnly
# stageId: string, format: int64, readOnly
# --- StagePerformanceStandaloneInsight (6 fields) ---
# Standalone performance insights for a specific stage.
# [[types]]
# schema = "StagePerformanceStandaloneInsight"
# include_fields = ["biEngineReasons", "highCardinalityJoins", "insufficientShuffleQuota", "partitionSkew", "slotContention", "stageId"]
#
# biEngineReasons: array<BiEngineReason>, readOnly
# highCardinalityJoins: array<HighCardinalityJoin>, readOnly
# insufficientShuffleQuota: boolean, readOnly
# partitionSkew: $ref: PartitionSkew, readOnly
# slotContention: boolean, readOnly
# stageId: string, format: int64, readOnly
# --- StandardSqlDataType (4 fields) ---
# The data type of a variable such as a function argument. Examples include: * INT64: `{"typeKind": "I
# [[types]]
# schema = "StandardSqlDataType"
# include_fields = ["arrayElementType", "rangeElementType", "structType", "typeKind"]
#
# arrayElementType: $ref: StandardSqlDataType
# rangeElementType: $ref: StandardSqlDataType
# structType: $ref: StandardSqlStructType
# typeKind: string, enum: [TYPE_KIND_UNSPECIFIED, INT64, BOOL, FLOAT64, ... +14]
#
# [types.field_overrides]
# # typeKind = { enum_type = "StandardSqlDataTypeTypeKind" }
# --- StandardSqlField (2 fields) ---
# A field or a column.
# WARNING: reserved words: type
# [[types]]
# schema = "StandardSqlField"
# include_fields = ["name", "type"]
#
# name: string
# type: $ref: StandardSqlDataType, RESERVED_WORD
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# --- StandardSqlStructType (1 fields) ---
# The representation of a SQL STRUCT type.
# [[types]]
# schema = "StandardSqlStructType"
# include_fields = ["fields"]
#
# fields: array<StandardSqlField>
# --- StandardSqlTableType (1 fields) ---
# A table type
# [[types]]
# schema = "StandardSqlTableType"
# include_fields = ["columns"]
#
# columns: array<StandardSqlField>
# --- StorageDescriptor (4 fields) ---
# Contains information about how a table's data is stored and accessed by open source query engines.
# [[types]]
# schema = "StorageDescriptor"
# include_fields = ["inputFormat", "locationUri", "outputFormat", "serdeInfo"]
#
# inputFormat: string
# locationUri: string
# outputFormat: string
# serdeInfo: $ref: SerDeInfo
# --- StoredColumnsUnusedReason (3 fields) ---
# If the stored column was not used, explain why.
# [[types]]
# schema = "StoredColumnsUnusedReason"
# include_fields = ["code", "message", "uncoveredColumns"]
#
# code: string, enum: [CODE_UNSPECIFIED, STORED_COLUMNS_COVER_INSUFFICIENT, BASE_TABLE_HAS_RLS, BASE_TABLE_HAS_CLS, ... +3]
# message: string
# uncoveredColumns: array<string>
#
# [types.field_overrides]
# # code = { enum_type = "StoredColumnsUnusedReasonCode" }
# --- StoredColumnsUsage (3 fields) ---
# Indicates the stored columns usage in the query.
# [[types]]
# schema = "StoredColumnsUsage"
# include_fields = ["baseTable", "isQueryAccelerated", "storedColumnsUnusedReasons"]
#
# baseTable: $ref: TableReference
# isQueryAccelerated: boolean
# storedColumnsUnusedReasons: array<StoredColumnsUnusedReason>
# --- Streamingbuffer (3 fields) ---
# [[types]]
# schema = "Streamingbuffer"
# include_fields = ["estimatedBytes", "estimatedRows", "oldestEntryTime"]
#
# estimatedBytes: string, format: uint64, readOnly
# estimatedRows: string, format: uint64, readOnly
# oldestEntryTime: string, format: uint64, readOnly
# --- StringHparamSearchSpace (1 fields) ---
# Search space for string and enum.
# [[types]]
# schema = "StringHparamSearchSpace"
# include_fields = ["candidates"]
#
# candidates: array<string>
# --- SystemVariables (2 fields) ---
# System variables given to a query.
# [[types]]
# schema = "SystemVariables"
# include_fields = ["types", "values"]
#
# types: map<string, StandardSqlDataType>, readOnly
# values: map<string, any>, readOnly
# --- Table (52 fields) [IN MANIFEST] ---
# WARNING: reserved words: type
# [[types]]
# schema = "Table"
# include_fields = ["biglakeConfiguration", "cloneDefinition", "clustering", "creationTime", "defaultCollation", "defaultRoundingMode", "description", "encryptionConfiguration", "etag", "expirationTime", "externalCatalogTableOptions", "externalDataConfiguration", "friendlyName", "id", "kind", "labels", "lastModifiedTime", "location", "managedTableType", "materializedView", "materializedViewStatus", "maxStaleness", "model", "numActiveLogicalBytes", "numActivePhysicalBytes", "numBytes", "numCurrentPhysicalBytes", "numLongTermBytes", "numLongTermLogicalBytes", "numLongTermPhysicalBytes", "numPartitions", "numPhysicalBytes", "numRows", "numTimeTravelPhysicalBytes", "numTotalLogicalBytes", "numTotalPhysicalBytes", "partitionDefinition", "rangePartitioning", "replicas", "requirePartitionFilter", "resourceTags", "restrictions", "schema", "selfLink", "snapshotDefinition", "streamingBuffer", "tableConstraints", "tableReference", "tableReplicationInfo", "timePartitioning", "type", "view"]
#
# biglakeConfiguration: $ref: BigLakeConfiguration
# cloneDefinition: $ref: CloneDefinition, readOnly
# clustering: $ref: Clustering
# creationTime: string, format: int64, readOnly
# defaultCollation: string
# defaultRoundingMode: string, enum: [ROUNDING_MODE_UNSPECIFIED, ROUND_HALF_AWAY_FROM_ZERO, ROUND_HALF_EVEN]
# description: string
# encryptionConfiguration: $ref: EncryptionConfiguration
# etag: string, readOnly
# expirationTime: string, format: int64
# externalCatalogTableOptions: $ref: ExternalCatalogTableOptions
# externalDataConfiguration: $ref: ExternalDataConfiguration
# friendlyName: string
# id: string, readOnly
# kind: string
# labels: map<string, string>
# lastModifiedTime: string, format: uint64, readOnly
# location: string, readOnly
# managedTableType: string, enum: [MANAGED_TABLE_TYPE_UNSPECIFIED, NATIVE, BIGLAKE]
# materializedView: $ref: MaterializedViewDefinition
# materializedViewStatus: $ref: MaterializedViewStatus, readOnly
# maxStaleness: string
# model: $ref: ModelDefinition
# numActiveLogicalBytes: string, format: int64, readOnly
# numActivePhysicalBytes: string, format: int64, readOnly
# numBytes: string, format: int64, readOnly
# numCurrentPhysicalBytes: string, format: int64, readOnly
# numLongTermBytes: string, format: int64, readOnly
# numLongTermLogicalBytes: string, format: int64, readOnly
# numLongTermPhysicalBytes: string, format: int64, readOnly
# numPartitions: string, format: int64, readOnly
# numPhysicalBytes: string, format: int64, readOnly
# numRows: string, format: uint64, readOnly
# numTimeTravelPhysicalBytes: string, format: int64, readOnly
# numTotalLogicalBytes: string, format: int64, readOnly
# numTotalPhysicalBytes: string, format: int64, readOnly
# partitionDefinition: $ref: PartitioningDefinition
# rangePartitioning: $ref: RangePartitioning
# replicas: array<TableReference>, readOnly
# requirePartitionFilter: boolean
# resourceTags: map<string, string>
# restrictions: $ref: RestrictionConfig, readOnly
# schema: $ref: TableSchema
# selfLink: string, readOnly
# snapshotDefinition: $ref: SnapshotDefinition, readOnly
# streamingBuffer: $ref: Streamingbuffer, readOnly
# tableConstraints: $ref: TableConstraints
# tableReference: $ref: TableReference
# tableReplicationInfo: $ref: TableReplicationInfo
# timePartitioning: $ref: TimePartitioning
# type: string, readOnly, RESERVED_WORD
# view: $ref: ViewDefinition
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# # defaultRoundingMode = { enum_type = "TableDefaultRoundingMode" }
# # managedTableType = { enum_type = "TableManagedTableType" }
# --- TableCell (1 fields) [IN MANIFEST] ---
# [[types]]
# schema = "TableCell"
# include_fields = ["v"]
#
# v: any
# --- TableConstraints (2 fields) ---
# The TableConstraints defines the primary key and foreign key.
# [[types]]
# schema = "TableConstraints"
# include_fields = ["foreignKeys", "primaryKey"]
#
# foreignKeys: array<object>
# primaryKey: object
# --- TableDataInsertAllRequest (6 fields) ---
# Request for sending a single streaming insert.
# [[types]]
# schema = "TableDataInsertAllRequest"
# include_fields = ["ignoreUnknownValues", "kind", "rows", "skipInvalidRows", "templateSuffix", "traceId"]
#
# ignoreUnknownValues: boolean
# kind: string
# rows: array<object>
# skipInvalidRows: boolean
# templateSuffix: string
# traceId: string
# --- TableDataInsertAllResponse (2 fields) ---
# Describes the format of a streaming insert response.
# [[types]]
# schema = "TableDataInsertAllResponse"
# include_fields = ["insertErrors", "kind"]
#
# insertErrors: array<object>
# kind: string
# --- TableDataList (5 fields) ---
# [[types]]
# schema = "TableDataList"
# include_fields = ["etag", "kind", "pageToken", "rows", "totalRows"]
#
# etag: string
# kind: string
# pageToken: string
# rows: array<TableRow>
# totalRows: string, format: int64
# --- TableFieldSchema (17 fields) [IN MANIFEST] ---
# A field in TableSchema
# WARNING: reserved words: type
# [[types]]
# schema = "TableFieldSchema"
# include_fields = ["categories", "collation", "dataPolicies", "defaultValueExpression", "description", "fields", "foreignTypeDefinition", "maxLength", "mode", "name", "policyTags", "precision", "rangeElementType", "roundingMode", "scale", "timestampPrecision", "type"]
#
# categories: object
# collation: string
# dataPolicies: array<DataPolicyOption>
# defaultValueExpression: string
# description: string
# fields: array<TableFieldSchema>
# foreignTypeDefinition: string
# maxLength: string, format: int64
# mode: string
# name: string
# policyTags: object
# precision: string, format: int64
# rangeElementType: object
# roundingMode: string, enum: [ROUNDING_MODE_UNSPECIFIED, ROUND_HALF_AWAY_FROM_ZERO, ROUND_HALF_EVEN]
# scale: string, format: int64
# timestampPrecision: string, format: int64
# type: string, RESERVED_WORD
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# # roundingMode = { enum_type = "TableFieldSchemaRoundingMode" }
# --- TableList (5 fields) [IN MANIFEST] ---
# Partial projection of the metadata for a given table in a list response.
# [[types]]
# schema = "TableList"
# include_fields = ["etag", "kind", "nextPageToken", "tables", "totalItems"]
#
# etag: string
# kind: string
# nextPageToken: string
# tables: array<object>
# totalItems: integer, format: int32
# --- TableMetadataCacheUsage (6 fields) ---
# Table level detail on the usage of metadata caching. Only set for Metadata caching eligible tables r
# [[types]]
# schema = "TableMetadataCacheUsage"
# include_fields = ["explanation", "pruningStats", "staleness", "tableReference", "tableType", "unusedReason"]
#
# explanation: string
# pruningStats: $ref: PruningStats
# staleness: string, format: google-duration
# tableReference: $ref: TableReference
# tableType: string
# unusedReason: string, enum: [UNUSED_REASON_UNSPECIFIED, EXCEEDED_MAX_STALENESS, METADATA_CACHING_NOT_ENABLED, OTHER_REASON]
#
# [types.field_overrides]
# # unusedReason = { enum_type = "TableMetadataCacheUsageUnusedReason" }
# --- TableReference (3 fields) [IN MANIFEST] ---
# [[types]]
# schema = "TableReference"
# include_fields = ["datasetId", "projectId", "tableId"]
#
# datasetId: string
# projectId: string
# tableId: string
# --- TableReplicationInfo (5 fields) ---
# Replication info of a table created using `AS REPLICA` DDL like: `CREATE MATERIALIZED VIEW mv1 AS RE
# [[types]]
# schema = "TableReplicationInfo"
# include_fields = ["replicatedSourceLastRefreshTime", "replicationError", "replicationIntervalMs", "replicationStatus", "sourceTable"]
#
# replicatedSourceLastRefreshTime: string, format: int64, readOnly
# replicationError: $ref: ErrorProto, readOnly
# replicationIntervalMs: string, format: int64
# replicationStatus: string, enum: [REPLICATION_STATUS_UNSPECIFIED, ACTIVE, SOURCE_DELETED, PERMISSION_DENIED, UNSUPPORTED_CONFIGURATION], readOnly
# sourceTable: $ref: TableReference
#
# [types.field_overrides]
# # replicationStatus = { enum_type = "TableReplicationInfoReplicationStatus" }
# --- TableRow (1 fields) [IN MANIFEST] ---
# [[types]]
# schema = "TableRow"
# include_fields = ["f"]
#
# f: array<TableCell>
# --- TableSchema (2 fields) [IN MANIFEST] ---
# Schema of a table
# [[types]]
# schema = "TableSchema"
# include_fields = ["fields", "foreignTypeInfo"]
#
# fields: array<TableFieldSchema>
# foreignTypeInfo: $ref: ForeignTypeInfo
# --- TestIamPermissionsRequest (1 fields) ---
# Request message for `TestIamPermissions` method.
# [[types]]
# schema = "TestIamPermissionsRequest"
# include_fields = ["permissions"]
#
# permissions: array<string>
# --- TestIamPermissionsResponse (1 fields) ---
# Response message for `TestIamPermissions` method.
# [[types]]
# schema = "TestIamPermissionsResponse"
# include_fields = ["permissions"]
#
# permissions: array<string>
# --- TimePartitioning (4 fields) [IN MANIFEST] ---
# WARNING: reserved words: type
# [[types]]
# schema = "TimePartitioning"
# include_fields = ["expirationMs", "field", "requirePartitionFilter", "type"]
#
# expirationMs: string, format: int64
# field: string
# requirePartitionFilter: boolean
# type: string, RESERVED_WORD
#
# [types.field_overrides]
# type = { rust_name = "type_value", serde_rename = "type" }
# --- TrainingOptions (101 fields) ---
# Options used in model training.
# [[types]]
# schema = "TrainingOptions"
# include_fields = ["activationFn", "adjustStepChanges", "approxGlobalFeatureContrib", "autoArima", "autoArimaMaxOrder", "autoArimaMinOrder", "autoClassWeights", "batchSize", "boosterType", "budgetHours", "calculatePValues", "categoryEncodingMethod", "cleanSpikesAndDips", "colorSpace", "colsampleBylevel", "colsampleBynode", "colsampleBytree", "contributionMetric", "dartNormalizeType", "dataFrequency", "dataSplitColumn", "dataSplitEvalFraction", "dataSplitMethod", "decomposeTimeSeries", "dimensionIdColumns", "distanceType", "dropout", "earlyStop", "enableGlobalExplain", "endpointIdleTtl", "feedbackType", "fitIntercept", "forecastLimitLowerBound", "forecastLimitUpperBound", "hiddenUnits", "holidayRegion", "holidayRegions", "horizon", "hparamTuningObjectives", "huggingFaceModelId", "includeDrift", "initialLearnRate", "inputLabelColumns", "instanceWeightColumn", "integratedGradientsNumSteps", "isTestColumn", "itemColumn", "kmeansInitializationColumn", "kmeansInitializationMethod", "l1RegActivation", "l1Regularization", "l2Regularization", "labelClassWeights", "learnRate", "learnRateStrategy", "lossType", "machineType", "maxIterations", "maxParallelTrials", "maxReplicaCount", "maxTimeSeriesLength", "maxTreeDepth", "minAprioriSupport", "minRelativeProgress", "minReplicaCount", "minSplitLoss", "minTimeSeriesLength", "minTreeChildWeight", "modelGardenModelName", "modelRegistry", "modelUri", "nonSeasonalOrder", "numClusters", "numFactors", "numParallelTree", "numPrincipalComponents", "numTrials", "optimizationStrategy", "optimizer", "pcaExplainedVarianceRatio", "pcaSolver", "reservationAffinityKey", "reservationAffinityType", "reservationAffinityValues", "sampledShapleyNumPaths", "scaleFeatures", "standardizeFeatures", "subsample", "tfVersion", "timeSeriesDataColumn", "timeSeriesIdColumn", "timeSeriesIdColumns", "timeSeriesLengthFraction", "timeSeriesTimestampColumn", "treeMethod", "trendSmoothingWindowSize", "userColumn", "vertexAiModelVersionAliases", "walsAlpha", "warmStart", "xgboostVersion"]
#
# activationFn: string
# adjustStepChanges: boolean
# approxGlobalFeatureContrib: boolean
# autoArima: boolean
# autoArimaMaxOrder: string, format: int64
# autoArimaMinOrder: string, format: int64
# autoClassWeights: boolean
# batchSize: string, format: int64
# boosterType: string, enum: [BOOSTER_TYPE_UNSPECIFIED, GBTREE, DART]
# budgetHours: number, format: double
# calculatePValues: boolean
# categoryEncodingMethod: string, enum: [ENCODING_METHOD_UNSPECIFIED, ONE_HOT_ENCODING, LABEL_ENCODING, DUMMY_ENCODING]
# cleanSpikesAndDips: boolean
# colorSpace: string, enum: [COLOR_SPACE_UNSPECIFIED, RGB, HSV, YIQ, ... +2]
# colsampleBylevel: number, format: double
# colsampleBynode: number, format: double
# colsampleBytree: number, format: double
# contributionMetric: string
# dartNormalizeType: string, enum: [DART_NORMALIZE_TYPE_UNSPECIFIED, TREE, FOREST]
# dataFrequency: string, enum: [DATA_FREQUENCY_UNSPECIFIED, AUTO_FREQUENCY, YEARLY, QUARTERLY, ... +5]
# dataSplitColumn: string
# dataSplitEvalFraction: number, format: double
# dataSplitMethod: string, enum: [DATA_SPLIT_METHOD_UNSPECIFIED, RANDOM, CUSTOM, SEQUENTIAL, ... +2]
# decomposeTimeSeries: boolean
# dimensionIdColumns: array<string>
# distanceType: string, enum: [DISTANCE_TYPE_UNSPECIFIED, EUCLIDEAN, COSINE]
# dropout: number, format: double
# earlyStop: boolean
# enableGlobalExplain: boolean
# endpointIdleTtl: string, format: google-duration
# feedbackType: string, enum: [FEEDBACK_TYPE_UNSPECIFIED, IMPLICIT, EXPLICIT]
# fitIntercept: boolean
# forecastLimitLowerBound: number, format: double
# forecastLimitUpperBound: number, format: double
# hiddenUnits: array<string>
# holidayRegion: string, enum: [HOLIDAY_REGION_UNSPECIFIED, GLOBAL, NA, JAPAC, ... +65]
# holidayRegions: array<string>
# horizon: string, format: int64
# hparamTuningObjectives: array<string>
# huggingFaceModelId: string
# includeDrift: boolean
# initialLearnRate: number, format: double
# inputLabelColumns: array<string>
# instanceWeightColumn: string
# integratedGradientsNumSteps: string, format: int64
# isTestColumn: string
# itemColumn: string
# kmeansInitializationColumn: string
# kmeansInitializationMethod: string, enum: [KMEANS_INITIALIZATION_METHOD_UNSPECIFIED, RANDOM, CUSTOM, KMEANS_PLUS_PLUS]
# l1RegActivation: number, format: double
# l1Regularization: number, format: double
# l2Regularization: number, format: double
# labelClassWeights: map<string, number>
# learnRate: number, format: double
# learnRateStrategy: string, enum: [LEARN_RATE_STRATEGY_UNSPECIFIED, LINE_SEARCH, CONSTANT]
# lossType: string, enum: [LOSS_TYPE_UNSPECIFIED, MEAN_SQUARED_LOSS, MEAN_LOG_LOSS]
# machineType: string
# maxIterations: string, format: int64
# maxParallelTrials: string, format: int64
# maxReplicaCount: string, format: int64
# maxTimeSeriesLength: string, format: int64
# maxTreeDepth: string, format: int64
# minAprioriSupport: number, format: double
# minRelativeProgress: number, format: double
# minReplicaCount: string, format: int64
# minSplitLoss: number, format: double
# minTimeSeriesLength: string, format: int64
# minTreeChildWeight: string, format: int64
# modelGardenModelName: string
# modelRegistry: string, enum: [MODEL_REGISTRY_UNSPECIFIED, VERTEX_AI]
# modelUri: string
# nonSeasonalOrder: $ref: ArimaOrder
# numClusters: string, format: int64
# numFactors: string, format: int64
# numParallelTree: string, format: int64
# numPrincipalComponents: string, format: int64
# numTrials: string, format: int64
# optimizationStrategy: string, enum: [OPTIMIZATION_STRATEGY_UNSPECIFIED, BATCH_GRADIENT_DESCENT, NORMAL_EQUATION]
# optimizer: string
# pcaExplainedVarianceRatio: number, format: double
# pcaSolver: string, enum: [UNSPECIFIED, FULL, RANDOMIZED, AUTO]
# reservationAffinityKey: string
# reservationAffinityType: string, enum: [RESERVATION_AFFINITY_TYPE_UNSPECIFIED, NO_RESERVATION, ANY_RESERVATION, SPECIFIC_RESERVATION]
# reservationAffinityValues: array<string>
# sampledShapleyNumPaths: string, format: int64
# scaleFeatures: boolean
# standardizeFeatures: boolean
# subsample: number, format: double
# tfVersion: string
# timeSeriesDataColumn: string
# timeSeriesIdColumn: string
# timeSeriesIdColumns: array<string>
# timeSeriesLengthFraction: number, format: double
# timeSeriesTimestampColumn: string
# treeMethod: string, enum: [TREE_METHOD_UNSPECIFIED, AUTO, EXACT, APPROX, HIST]
# trendSmoothingWindowSize: string, format: int64
# userColumn: string
# vertexAiModelVersionAliases: array<string>
# walsAlpha: number, format: double
# warmStart: boolean
# xgboostVersion: string
#
# [types.field_overrides]
# # boosterType = { enum_type = "TrainingOptionsBoosterType" }
# # categoryEncodingMethod = { enum_type = "TrainingOptionsCategoryEncodingMethod" }
# # colorSpace = { enum_type = "TrainingOptionsColorSpace" }
# # dartNormalizeType = { enum_type = "TrainingOptionsDartNormalizeType" }
# # dataFrequency = { enum_type = "TrainingOptionsDataFrequency" }
# # dataSplitMethod = { enum_type = "TrainingOptionsDataSplitMethod" }
# # distanceType = { enum_type = "TrainingOptionsDistanceType" }
# # feedbackType = { enum_type = "TrainingOptionsFeedbackType" }
# # holidayRegion = { enum_type = "TrainingOptionsHolidayRegion" }
# # kmeansInitializationMethod = { enum_type = "TrainingOptionsKmeansInitializationMethod" }
# # learnRateStrategy = { enum_type = "TrainingOptionsLearnRateStrategy" }
# # lossType = { enum_type = "TrainingOptionsLossType" }
# # modelRegistry = { enum_type = "TrainingOptionsModelRegistry" }
# # optimizationStrategy = { enum_type = "TrainingOptionsOptimizationStrategy" }
# # pcaSolver = { enum_type = "TrainingOptionsPcaSolver" }
# # reservationAffinityType = { enum_type = "TrainingOptionsReservationAffinityType" }
# # treeMethod = { enum_type = "TrainingOptionsTreeMethod" }
# --- TrainingRun (10 fields) ---
# Information about a single training query run for the model.
# [[types]]
# schema = "TrainingRun"
# include_fields = ["classLevelGlobalExplanations", "dataSplitResult", "evaluationMetrics", "modelLevelGlobalExplanation", "results", "startTime", "trainingOptions", "trainingStartTime", "vertexAiModelId", "vertexAiModelVersion"]
#
# classLevelGlobalExplanations: array<GlobalExplanation>, readOnly
# dataSplitResult: $ref: DataSplitResult, readOnly
# evaluationMetrics: $ref: EvaluationMetrics, readOnly
# modelLevelGlobalExplanation: $ref: GlobalExplanation, readOnly
# results: array<IterationResult>, readOnly
# startTime: string, format: google-datetime, readOnly
# trainingOptions: $ref: TrainingOptions, readOnly
# trainingStartTime: string, format: int64, readOnly
# vertexAiModelId: string
# vertexAiModelVersion: string, readOnly
# --- TransactionInfo (1 fields) ---
# [Alpha] Information of a multi-statement transaction.
# [[types]]
# schema = "TransactionInfo"
# include_fields = ["transactionId"]
#
# transactionId: string, readOnly
# --- TransformColumn (3 fields) ---
# Information about a single transform column.
# WARNING: reserved words: type
# [[types]]
# schema = "TransformColumn"
# include_fields = ["name", "transformSql", "type"]
#
# name: string, readOnly
# transformSql: string, readOnly
# type: $ref: StandardSqlDataType, readOnly, RESERVED_WORD
#
# [types.field_overrides]
# name = { required = true }
# type = { rust_name = "type_value", serde_rename = "type" }
# --- UndeleteDatasetRequest (1 fields) ---
# Request format for undeleting a dataset.
# [[types]]
# schema = "UndeleteDatasetRequest"
# include_fields = ["deletionTime"]
#
# deletionTime: string, format: google-datetime
# --- UserDefinedFunctionResource (2 fields) ---
# This is used for defining User Defined Function (UDF) resources only when using legacy SQL. Users of
# [[types]]
# schema = "UserDefinedFunctionResource"
# include_fields = ["inlineCode", "resourceUri"]
#
# inlineCode: string
# resourceUri: string
# --- VectorSearchStatistics (3 fields) ---
# Statistics for a vector search query. Populated as part of JobStatistics2.
# [[types]]
# schema = "VectorSearchStatistics"
# include_fields = ["indexUnusedReasons", "indexUsageMode", "storedColumnsUsages"]
#
# indexUnusedReasons: array<IndexUnusedReason>
# indexUsageMode: string, enum: [INDEX_USAGE_MODE_UNSPECIFIED, UNUSED, PARTIALLY_USED, FULLY_USED]
# storedColumnsUsages: array<StoredColumnsUsage>
#
# [types.field_overrides]
# # indexUsageMode = { enum_type = "VectorSearchStatisticsIndexUsageMode" }
# --- ViewDefinition (6 fields) ---
# Describes the definition of a logical view.
# [[types]]
# schema = "ViewDefinition"
# include_fields = ["foreignDefinitions", "privacyPolicy", "query", "useExplicitColumnNames", "useLegacySql", "userDefinedFunctionResources"]
#
# foreignDefinitions: array<ForeignViewDefinition>
# privacyPolicy: $ref: PrivacyPolicy
# query: string
# useExplicitColumnNames: boolean
# useLegacySql: boolean
# userDefinedFunctionResources: array<UserDefinedFunctionResource>
# ======================================================================
# OPERATIONS (47 total)
# ======================================================================
# --- datasets.delete [IN MANIFEST] ---
# DELETE projects/{+projectId}/datasets/{+datasetId}
# Deletes the dataset specified by the datasetId value. Before you can delete a dataset, you must dele
# Query params: deleteContents
# [[operations]]
# discovery_resource = "datasets"
# discovery_method = "delete"
# rust_name = "delete_dataset"
# query_params = ["deleteContents"]
# --- datasets.get [IN MANIFEST] ---
# GET projects/{+projectId}/datasets/{+datasetId}
# Returns the dataset specified by datasetID.
# Response: Dataset
# Query params: accessPolicyVersion, datasetView
# [[operations]]
# discovery_resource = "datasets"
# discovery_method = "get"
# rust_name = "get_dataset"
# query_params = ["accessPolicyVersion", "datasetView"]
# --- datasets.insert [IN MANIFEST] ---
# POST projects/{+projectId}/datasets
# Creates a new empty dataset.
# Request: Dataset
# Response: Dataset
# Query params: accessPolicyVersion
# [[operations]]
# discovery_resource = "datasets"
# discovery_method = "insert"
# rust_name = "create_dataset"
# query_params = ["accessPolicyVersion"]
# --- datasets.list [IN MANIFEST] ---
# GET projects/{+projectId}/datasets
# Lists all datasets in the specified project to which the user has been granted the READER dataset ro
# Response: DatasetList
# Query params: all, filter, maxResults, pageToken
# [[operations]]
# discovery_resource = "datasets"
# discovery_method = "list"
# rust_name = "list_datasets"
# query_params = ["all", "filter", "maxResults", "pageToken"]
# --- datasets.patch [IN MANIFEST] ---
# PATCH projects/{+projectId}/datasets/{+datasetId}
# Updates information in an existing dataset. The update method replaces the entire dataset resource,
# Request: Dataset
# Response: Dataset
# Query params: accessPolicyVersion, updateMode
# [[operations]]
# discovery_resource = "datasets"
# discovery_method = "patch"
# rust_name = "update_dataset"
# query_params = ["accessPolicyVersion", "updateMode"]
# --- datasets.undelete ---
# POST projects/{+projectId}/datasets/{+datasetId}:undelete
# Undeletes a dataset which is within time travel window based on datasetId. If a time is specified, t
# Request: UndeleteDatasetRequest
# Response: Dataset
# [[operations]]
# discovery_resource = "datasets"
# discovery_method = "undelete"
# rust_name = "undelete_dataset"
# --- datasets.update ---
# PUT projects/{+projectId}/datasets/{+datasetId}
# Updates information in an existing dataset. The update method replaces the entire dataset resource,
# Request: Dataset
# Response: Dataset
# Query params: accessPolicyVersion, updateMode
# [[operations]]
# discovery_resource = "datasets"
# discovery_method = "update"
# rust_name = "update_dataset"
# query_params = ["accessPolicyVersion", "updateMode"]
# --- jobs.cancel [IN MANIFEST] ---
# POST projects/{+projectId}/jobs/{+jobId}/cancel
# Requests that a job be cancelled. This call will return immediately, and the client will need to pol
# Response: JobCancelResponse
# Query params: location
# [[operations]]
# discovery_resource = "jobs"
# discovery_method = "cancel"
# rust_name = "cancel_job"
# query_params = ["location"]
# --- jobs.delete [IN MANIFEST] ---
# DELETE projects/{+projectId}/jobs/{+jobId}/delete
# Requests the deletion of the metadata of a job. This call returns when the job's metadata is deleted
# Query params: location
# [[operations]]
# discovery_resource = "jobs"
# discovery_method = "delete"
# rust_name = "delete_job"
# query_params = ["location"]
# --- jobs.get [IN MANIFEST] ---
# GET projects/{+projectId}/jobs/{+jobId}
# Returns information about a specific job. Job information is available for a six month period after
# Response: Job
# Query params: location
# [[operations]]
# discovery_resource = "jobs"
# discovery_method = "get"
# rust_name = "get_job"
# query_params = ["location"]
# --- jobs.getQueryResults ---
# GET projects/{+projectId}/queries/{+jobId}
# RPC to get the results of a query job.
# Response: GetQueryResultsResponse
# Query params: formatOptions.timestampOutputFormat, formatOptions.useInt64Timestamp, location, maxResults, pageToken, startIndex, timeoutMs
# [[operations]]
# discovery_resource = "jobs"
# discovery_method = "getQueryResults"
# rust_name = "getQueryResults_job"
# query_params = ["formatOptions.timestampOutputFormat", "formatOptions.useInt64Timestamp", "location", "maxResults", "pageToken", "startIndex", "timeoutMs"]
# --- jobs.insert [IN MANIFEST] ---
# POST projects/{+projectId}/jobs
# Starts a new asynchronous job. This API has two different kinds of endpoint URIs, as this method sup
# Request: Job
# Response: Job
# [[operations]]
# discovery_resource = "jobs"
# discovery_method = "insert"
# rust_name = "create_job"
# --- jobs.list [IN MANIFEST] ---
# GET projects/{+projectId}/jobs
# Lists all jobs that you started in the specified project. Job information is available for a six mon
# Response: JobList
# Query params: allUsers, maxCreationTime, maxResults, minCreationTime, pageToken, parentJobId, projection, stateFilter (repeated)
# [[operations]]
# discovery_resource = "jobs"
# discovery_method = "list"
# rust_name = "list_jobs"
# query_params = ["allUsers", "maxCreationTime", "maxResults", "minCreationTime", "pageToken", "parentJobId", "projection", "stateFilter"]
# --- jobs.query [IN MANIFEST] ---
# POST projects/{+projectId}/queries
# Runs a BigQuery SQL query synchronously and returns query results if the query completes within a sp
# Request: QueryRequest
# Response: QueryResponse
# [[operations]]
# discovery_resource = "jobs"
# discovery_method = "query"
# rust_name = "query_job"
# --- models.delete ---
# DELETE projects/{+projectId}/datasets/{+datasetId}/models/{+modelId}
# Deletes the model specified by modelId from the dataset.
# [[operations]]
# discovery_resource = "models"
# discovery_method = "delete"
# rust_name = "delete_model"
# --- models.get ---
# GET projects/{+projectId}/datasets/{+datasetId}/models/{+modelId}
# Gets the specified model resource by model ID.
# Response: Model
# [[operations]]
# discovery_resource = "models"
# discovery_method = "get"
# rust_name = "get_model"
# --- models.list ---
# GET projects/{+projectId}/datasets/{+datasetId}/models
# Lists all models in the specified dataset. Requires the READER dataset role. After retrieving the li
# Response: ListModelsResponse
# Query params: maxResults, pageToken
# [[operations]]
# discovery_resource = "models"
# discovery_method = "list"
# rust_name = "list_models"
# list_response = { type_name = "ListModelsResponse", items_field = "models", item_type = "Model" }
# query_params = ["maxResults", "pageToken"]
# --- models.patch ---
# PATCH projects/{+projectId}/datasets/{+datasetId}/models/{+modelId}
# Patch specific fields in the specified model.
# Request: Model
# Response: Model
# [[operations]]
# discovery_resource = "models"
# discovery_method = "patch"
# rust_name = "update_model"
# --- projects.getServiceAccount ---
# GET projects/{+projectId}/serviceAccount
# RPC to get the service account for a project used for interactions with Google Cloud KMS
# Response: GetServiceAccountResponse
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "getServiceAccount"
# rust_name = "getServiceAccount_project"
# --- projects.list ---
# GET projects
# RPC to list projects to which the user has been granted any project role. Users of this method are e
# Response: ProjectList
# Query params: maxResults, pageToken
# [[operations]]
# discovery_resource = "projects"
# discovery_method = "list"
# rust_name = "list_projects"
# query_params = ["maxResults", "pageToken"]
# --- routines.delete ---
# DELETE projects/{+projectId}/datasets/{+datasetId}/routines/{+routineId}
# Deletes the routine specified by routineId from the dataset.
# [[operations]]
# discovery_resource = "routines"
# discovery_method = "delete"
# rust_name = "delete_routine"
# --- routines.get ---
# GET projects/{+projectId}/datasets/{+datasetId}/routines/{+routineId}
# Gets the specified routine resource by routine ID.
# Response: Routine
# Query params: readMask
# [[operations]]
# discovery_resource = "routines"
# discovery_method = "get"
# rust_name = "get_routine"
# query_params = ["readMask"]
# --- routines.getIamPolicy ---
# POST {+resource}:getIamPolicy
# Gets the access control policy for a resource. Returns an empty policy if the resource exists and do
# Request: GetIamPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "routines"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_routine"
# --- routines.insert ---
# POST projects/{+projectId}/datasets/{+datasetId}/routines
# Creates a new routine in the dataset.
# Request: Routine
# Response: Routine
# [[operations]]
# discovery_resource = "routines"
# discovery_method = "insert"
# rust_name = "create_routine"
# --- routines.list ---
# GET projects/{+projectId}/datasets/{+datasetId}/routines
# Lists all routines in the specified dataset. Requires the READER dataset role.
# Response: ListRoutinesResponse
# Query params: filter, maxResults, pageToken, readMask
# [[operations]]
# discovery_resource = "routines"
# discovery_method = "list"
# rust_name = "list_routines"
# list_response = { type_name = "ListRoutinesResponse", items_field = "routines", item_type = "Routine" }
# query_params = ["filter", "maxResults", "pageToken", "readMask"]
# --- routines.setIamPolicy ---
# POST {+resource}:setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy. Can return `
# Request: SetIamPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "routines"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_routine"
# --- routines.testIamPermissions ---
# POST {+resource}:testIamPermissions
# Returns permissions that a caller has on the specified resource. If the resource does not exist, thi
# Request: TestIamPermissionsRequest
# Response: TestIamPermissionsResponse
# [[operations]]
# discovery_resource = "routines"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_routine"
# --- routines.update ---
# PUT projects/{+projectId}/datasets/{+datasetId}/routines/{+routineId}
# Updates information in an existing routine. The update method replaces the entire Routine resource.
# Request: Routine
# Response: Routine
# [[operations]]
# discovery_resource = "routines"
# discovery_method = "update"
# rust_name = "update_routine"
# --- rowAccessPolicies.batchDelete ---
# POST projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}/rowAccessPolicies:batchDelete
# Deletes provided row access policies.
# Request: BatchDeleteRowAccessPoliciesRequest
# [[operations]]
# discovery_resource = "rowAccessPolicies"
# discovery_method = "batchDelete"
# rust_name = "batchDelete_row_access_policie"
# --- rowAccessPolicies.delete ---
# DELETE projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}/rowAccessPolicies/{+policyId}
# Deletes a row access policy.
# Query params: force
# [[operations]]
# discovery_resource = "rowAccessPolicies"
# discovery_method = "delete"
# rust_name = "delete_row_access_policie"
# query_params = ["force"]
# --- rowAccessPolicies.get ---
# GET projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}/rowAccessPolicies/{+policyId}
# Gets the specified row access policy by policy ID.
# Response: RowAccessPolicy
# [[operations]]
# discovery_resource = "rowAccessPolicies"
# discovery_method = "get"
# rust_name = "get_row_access_policie"
# --- rowAccessPolicies.getIamPolicy ---
# POST {+resource}:getIamPolicy
# Gets the access control policy for a resource. Returns an empty policy if the resource exists and do
# Request: GetIamPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "rowAccessPolicies"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_row_access_policie"
# --- rowAccessPolicies.insert ---
# POST projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}/rowAccessPolicies
# Creates a row access policy.
# Request: RowAccessPolicy
# Response: RowAccessPolicy
# [[operations]]
# discovery_resource = "rowAccessPolicies"
# discovery_method = "insert"
# rust_name = "create_row_access_policie"
# --- rowAccessPolicies.list ---
# GET projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}/rowAccessPolicies
# Lists all row access policies on the specified table.
# Response: ListRowAccessPoliciesResponse
# Query params: pageSize, pageToken
# [[operations]]
# discovery_resource = "rowAccessPolicies"
# discovery_method = "list"
# rust_name = "list_row_access_policies"
# list_response = { type_name = "ListRowAccessPoliciesResponse", items_field = "rowAccessPolicies", item_type = "RowAccessPolicy" }
# query_params = ["pageSize", "pageToken"]
# --- rowAccessPolicies.testIamPermissions ---
# POST {+resource}:testIamPermissions
# Returns permissions that a caller has on the specified resource. If the resource does not exist, thi
# Request: TestIamPermissionsRequest
# Response: TestIamPermissionsResponse
# [[operations]]
# discovery_resource = "rowAccessPolicies"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_row_access_policie"
# --- rowAccessPolicies.update ---
# PUT projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}/rowAccessPolicies/{+policyId}
# Updates a row access policy.
# Request: RowAccessPolicy
# Response: RowAccessPolicy
# [[operations]]
# discovery_resource = "rowAccessPolicies"
# discovery_method = "update"
# rust_name = "update_row_access_policie"
# --- tabledata.insertAll ---
# POST projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}/insertAll
# Streams data into BigQuery one record at a time without needing to run a load job.
# Request: TableDataInsertAllRequest
# Response: TableDataInsertAllResponse
# [[operations]]
# discovery_resource = "tabledata"
# discovery_method = "insertAll"
# rust_name = "insertAll_tabledata"
# --- tabledata.list ---
# GET projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}/data
# List the content of a table in rows.
# Response: TableDataList
# Query params: formatOptions.timestampOutputFormat, formatOptions.useInt64Timestamp, maxResults, pageToken, selectedFields, startIndex
# [[operations]]
# discovery_resource = "tabledata"
# discovery_method = "list"
# rust_name = "list_tabledata"
# query_params = ["formatOptions.timestampOutputFormat", "formatOptions.useInt64Timestamp", "maxResults", "pageToken", "selectedFields", "startIndex"]
# --- tables.delete [IN MANIFEST] ---
# DELETE projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}
# Deletes the table specified by tableId from the dataset. If the table contains data, all the data wi
# [[operations]]
# discovery_resource = "tables"
# discovery_method = "delete"
# rust_name = "delete_table"
# --- tables.get [IN MANIFEST] ---
# GET projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}
# Gets the specified table resource by table ID. This method does not return the data in the table, it
# Response: Table
# Query params: selectedFields, view
# [[operations]]
# discovery_resource = "tables"
# discovery_method = "get"
# rust_name = "get_table"
# query_params = ["selectedFields", "view"]
# --- tables.getIamPolicy ---
# POST {+resource}:getIamPolicy
# Gets the access control policy for a resource. Returns an empty policy if the resource exists and do
# Request: GetIamPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "tables"
# discovery_method = "getIamPolicy"
# rust_name = "getIamPolicy_table"
# --- tables.insert [IN MANIFEST] ---
# POST projects/{+projectId}/datasets/{+datasetId}/tables
# Creates a new, empty table in the dataset.
# Request: Table
# Response: Table
# [[operations]]
# discovery_resource = "tables"
# discovery_method = "insert"
# rust_name = "create_table"
# --- tables.list [IN MANIFEST] ---
# GET projects/{+projectId}/datasets/{+datasetId}/tables
# Lists all tables in the specified dataset. Requires the READER dataset role.
# Response: TableList
# Query params: maxResults, pageToken
# [[operations]]
# discovery_resource = "tables"
# discovery_method = "list"
# rust_name = "list_tables"
# query_params = ["maxResults", "pageToken"]
# --- tables.patch [IN MANIFEST] ---
# PATCH projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}
# Updates information in an existing table. The update method replaces the entire table resource, wher
# Request: Table
# Response: Table
# Query params: autodetect_schema
# [[operations]]
# discovery_resource = "tables"
# discovery_method = "patch"
# rust_name = "update_table"
# query_params = ["autodetect_schema"]
# --- tables.setIamPolicy ---
# POST {+resource}:setIamPolicy
# Sets the access control policy on the specified resource. Replaces any existing policy. Can return `
# Request: SetIamPolicyRequest
# Response: Policy
# [[operations]]
# discovery_resource = "tables"
# discovery_method = "setIamPolicy"
# rust_name = "setIamPolicy_table"
# --- tables.testIamPermissions ---
# POST {+resource}:testIamPermissions
# Returns permissions that a caller has on the specified resource. If the resource does not exist, thi
# Request: TestIamPermissionsRequest
# Response: TestIamPermissionsResponse
# [[operations]]
# discovery_resource = "tables"
# discovery_method = "testIamPermissions"
# rust_name = "testIamPermissions_table"
# --- tables.update ---
# PUT projects/{+projectId}/datasets/{+datasetId}/tables/{+tableId}
# Updates information in an existing table. The update method replaces the entire Table resource, wher
# Request: Table
# Response: Table
# Query params: autodetect_schema
# [[operations]]
# discovery_resource = "tables"
# discovery_method = "update"
# rust_name = "update_table"
# query_params = ["autodetect_schema"]
# ======================================================================
# COVERAGE SUMMARY
# ======================================================================
# Schemas in discovery: 208
# Schemas in manifest: 25
# Coverage: 25/208 (12%)
#
# Operations in discovery: 47
# Operations in manifest: 16
# Coverage: 16/47 (34%)