v1beta1

type BigQueryDataset struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   BigQueryDatasetSpec   `json:"spec,omitempty"`
	Status BigQueryDatasetStatus `json:"status,omitempty"`
}

type BigQueryDatasetList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []BigQueryDataset `json:"items"`
}

type BigQueryDatasetSpec struct {
	/* An array of objects that define dataset access for one or more entities. */
	// +optional
	Access []DatasetAccess `json:"access,omitempty"`

	/* Defines the default collation specification of future tables created
	in the dataset. If a table is created in this dataset without table-level
	default collation, then the table inherits the dataset default collation,
	which is applied to the string fields that do not have explicit collation
	specified. A change to this field affects only tables created afterwards,
	and does not alter the existing tables.

	The following values are supported:
	- 'und:ci': undetermined locale, case insensitive.
	- ”: empty string. Default to case-sensitive behavior. */
	// +optional
	DefaultCollation *string `json:"defaultCollation,omitempty"`

	/* The default encryption key for all tables in the dataset. Once this property is set,
	all newly-created partitioned tables in the dataset will have encryption key set to
	this value, unless table creation request (or query) overrides the key. */
	// +optional
	DefaultEncryptionConfiguration *DatasetDefaultEncryptionConfiguration `json:"defaultEncryptionConfiguration,omitempty"`

	/* The default partition expiration for all partitioned tables in
	the dataset, in milliseconds.


	Once this property is set, all newly-created partitioned tables in
	the dataset will have an 'expirationMs' property in the 'timePartitioning'
	settings set to this value, and changing the value will only
	affect new tables, not existing ones. The storage in a partition will
	have an expiration time of its partition time plus this value.
	Setting this property overrides the use of 'defaultTableExpirationMs'
	for partitioned tables: only one of 'defaultTableExpirationMs' and
	'defaultPartitionExpirationMs' will be used for any new partitioned
	table. If you provide an explicit 'timePartitioning.expirationMs' when
	creating or updating a partitioned table, that value takes precedence
	over the default partition expiration time indicated by this property. */
	// +optional
	DefaultPartitionExpirationMs *int `json:"defaultPartitionExpirationMs,omitempty"`

	/* The default lifetime of all tables in the dataset, in milliseconds.
	The minimum value is 3600000 milliseconds (one hour).


	Once this property is set, all newly-created tables in the dataset
	will have an 'expirationTime' property set to the creation time plus
	the value in this property, and changing the value will only affect
	new tables, not existing ones. When the 'expirationTime' for a given
	table is reached, that table will be deleted automatically.
	If a table's 'expirationTime' is modified or removed before the
	table expires, or if you provide an explicit 'expirationTime' when
	creating a table, that value takes precedence over the default
	expiration time indicated by this property. */
	// +optional
	DefaultTableExpirationMs *int `json:"defaultTableExpirationMs,omitempty"`

	/* A user-friendly description of the dataset. */
	// +optional
	Description *string `json:"description,omitempty"`

	/* A descriptive name for the dataset. */
	// +optional
	FriendlyName *string `json:"friendlyName,omitempty"`

	/* TRUE if the dataset and its table names are case-insensitive, otherwise FALSE.
	By default, this is FALSE, which means the dataset and its table names are
	case-sensitive. This field does not affect routine references. */
	// +optional
	IsCaseInsensitive *bool `json:"isCaseInsensitive,omitempty"`

	/* Immutable. The geographic location where the dataset should reside.
	See [official docs](https://cloud.google.com/bigquery/docs/dataset-locations).


	There are two types of locations, regional or multi-regional. A regional
	location is a specific geographic place, such as Tokyo, and a multi-regional
	location is a large geographic area, such as the United States, that
	contains at least two geographic places.


	The default value is multi-regional location 'US'.
	Changing this forces a new resource to be created. */
	// +optional
	Location *string `json:"location,omitempty"`

	/* Defines the time travel window in hours. The value can be from 48 to 168 hours (2 to 7 days). */
	// +optional
	MaxTimeTravelHours *string `json:"maxTimeTravelHours,omitempty"`

	/* The project that this resource belongs to. */
	// +optional
	ProjectRef *v1alpha1.ResourceRef `json:"projectRef,omitempty"`

	/* Immutable. Optional. The datasetId of the resource. Used for creation and acquisition. When unset, the value of `metadata.name` is used as the default. */
	// +optional
	ResourceID *string `json:"resourceID,omitempty"`

	/* Specifies the storage billing model for the dataset.
	Set this flag value to LOGICAL to use logical bytes for storage billing,
	or to PHYSICAL to use physical bytes instead.

	LOGICAL is the default if this flag isn't specified. */
	// +optional
	StorageBillingModel *string `json:"storageBillingModel,omitempty"`
}

type BigQueryDatasetStatus struct {
	/* Conditions represent the latest available observations of the
	   BigQueryDataset's current state. */
	Conditions []v1alpha1.Condition `json:"conditions,omitempty"`
	/* The time when this dataset was created, in milliseconds since the
	epoch. */
	// +optional
	CreationTime *int `json:"creationTime,omitempty"`

	/* A hash of the resource. */
	// +optional
	Etag *string `json:"etag,omitempty"`

	/* The date when this dataset or any of its tables was last modified, in
	milliseconds since the epoch. */
	// +optional
	LastModifiedTime *int `json:"lastModifiedTime,omitempty"`

	/* ObservedGeneration is the generation of the resource that was most recently observed by the Config Connector controller. If this is equal to metadata.generation, then that means that the current reported status reflects the most recent desired state of the resource. */
	// +optional
	ObservedGeneration *int `json:"observedGeneration,omitempty"`

	// +optional
	SelfLink *string `json:"selfLink,omitempty"`
}

type BigQueryJob struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   BigQueryJobSpec   `json:"spec,omitempty"`
	Status BigQueryJobStatus `json:"status,omitempty"`
}

type BigQueryJobList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []BigQueryJob `json:"items"`
}

type BigQueryJobSpec struct {
	/* Immutable. Copies a table. */
	// +optional
	Copy *JobCopy `json:"copy,omitempty"`

	/* Immutable. Configures an extract job. */
	// +optional
	Extract *JobExtract `json:"extract,omitempty"`

	/* Immutable. Job timeout in milliseconds. If this time limit is exceeded, BigQuery may attempt to terminate the job. */
	// +optional
	JobTimeoutMs *string `json:"jobTimeoutMs,omitempty"`

	/* Immutable. Configures a load job. */
	// +optional
	Load *JobLoad `json:"load,omitempty"`

	/* Immutable. The geographic location of the job. The default value is US. */
	// +optional
	Location *string `json:"location,omitempty"`

	/* Immutable. Configures a query job. */
	// +optional
	Query *JobQuery `json:"query,omitempty"`

	/* Immutable. Optional. The jobId of the resource. Used for creation and acquisition. When unset, the value of `metadata.name` is used as the default. */
	// +optional
	ResourceID *string `json:"resourceID,omitempty"`
}

type BigQueryJobStatus struct {
	/* Conditions represent the latest available observations of the
	   BigQueryJob's current state. */
	Conditions []v1alpha1.Condition `json:"conditions,omitempty"`
	/* The type of the job. */
	// +optional
	JobType *string `json:"jobType,omitempty"`

	/* ObservedGeneration is the generation of the resource that was most recently observed by the Config Connector controller. If this is equal to metadata.generation, then that means that the current reported status reflects the most recent desired state of the resource. */
	// +optional
	ObservedGeneration *int `json:"observedGeneration,omitempty"`

	/* The status of this job. Examine this value when polling an asynchronous job to see if the job is complete. */
	// +optional
	Status []JobStatusStatus `json:"status,omitempty"`

	/* Email address of the user who ran the job. */
	// +optional
	UserEmail *string `json:"userEmail,omitempty"`
}

type BigQueryRoutine struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   BigQueryRoutineSpec   `json:"spec,omitempty"`
	Status BigQueryRoutineStatus `json:"status,omitempty"`
}

type BigQueryRoutineList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []BigQueryRoutine `json:"items"`
}

type BigQueryRoutineSpec struct {
	/* Input/output argument of a function or a stored procedure. */
	// +optional
	Arguments []RoutineArguments `json:"arguments,omitempty"`

	/* The ID of the dataset containing this routine. */
	DatasetRef v1alpha1.ResourceRef `json:"datasetRef"`

	/* The body of the routine. For functions, this is the expression in the AS clause.
	If language=SQL, it is the substring inside (but excluding) the parentheses. */
	DefinitionBody string `json:"definitionBody"`

	/* The description of the routine if defined. */
	// +optional
	Description *string `json:"description,omitempty"`

	/* The determinism level of the JavaScript UDF if defined. Possible values: ["DETERMINISM_LEVEL_UNSPECIFIED", "DETERMINISTIC", "NOT_DETERMINISTIC"]. */
	// +optional
	DeterminismLevel *string `json:"determinismLevel,omitempty"`

	/* Optional. If language = "JAVASCRIPT", this field stores the path of the
	imported JAVASCRIPT libraries. */
	// +optional
	ImportedLibraries []string `json:"importedLibraries,omitempty"`

	/* The language of the routine. Possible values: ["SQL", "JAVASCRIPT"]. */
	// +optional
	Language *string `json:"language,omitempty"`

	/* The project that this resource belongs to. */
	ProjectRef v1alpha1.ResourceRef `json:"projectRef"`

	/* Immutable. Optional. The routineId of the resource. Used for creation and acquisition. When unset, the value of `metadata.name` is used as the default. */
	// +optional
	ResourceID *string `json:"resourceID,omitempty"`

	/* Optional. Can be set only if routineType = "TABLE_VALUED_FUNCTION".

	If absent, the return table type is inferred from definitionBody at query time in each query
	that references this routine. If present, then the columns in the evaluated table result will
	be cast to match the column types specificed in return table type, at query time. */
	// +optional
	ReturnTableType *string `json:"returnTableType,omitempty"`

	/* A JSON schema for the return type. Optional if language = "SQL"; required otherwise.
	If absent, the return type is inferred from definitionBody at query time in each query
	that references this routine. If present, then the evaluated result will be cast to
	the specified returned type at query time. ~>**NOTE**: Because this field expects a JSON
	string, any changes to the string will create a diff, even if the JSON itself hasn't
	changed. If the API returns a different value for the same schema, e.g. it switche
	d the order of values or replaced STRUCT field type with RECORD field type, we currently
	cannot suppress the recurring diff this causes. As a workaround, we recommend using
	the schema as returned by the API. */
	// +optional
	ReturnType *string `json:"returnType,omitempty"`

	/* Immutable. The type of routine. Possible values: ["SCALAR_FUNCTION", "PROCEDURE", "TABLE_VALUED_FUNCTION"]. */
	// +optional
	RoutineType *string `json:"routineType,omitempty"`
}

type BigQueryRoutineStatus struct {
	/* Conditions represent the latest available observations of the
	   BigQueryRoutine's current state. */
	Conditions []v1alpha1.Condition `json:"conditions,omitempty"`
	/* The time when this routine was created, in milliseconds since the
	epoch. */
	// +optional
	CreationTime *int `json:"creationTime,omitempty"`

	/* The time when this routine was modified, in milliseconds since the
	epoch. */
	// +optional
	LastModifiedTime *int `json:"lastModifiedTime,omitempty"`

	/* ObservedGeneration is the generation of the resource that was most recently observed by the Config Connector controller. If this is equal to metadata.generation, then that means that the current reported status reflects the most recent desired state of the resource. */
	// +optional
	ObservedGeneration *int `json:"observedGeneration,omitempty"`
}

type BigQueryTable struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   BigQueryTableSpec   `json:"spec,omitempty"`
	Status BigQueryTableStatus `json:"status,omitempty"`
}

type BigQueryTableList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []BigQueryTable `json:"items"`
}

type BigQueryTableSpec struct {
	/* Specifies column names to use for data clustering. Up to four top-level columns are allowed, and should be specified in descending priority order. */
	// +optional
	Clustering []string `json:"clustering,omitempty"`

	DatasetRef v1alpha1.ResourceRef `json:"datasetRef"`

	/* The field description. */
	// +optional
	Description *string `json:"description,omitempty"`

	/* Immutable. Specifies how the table should be encrypted. If left blank, the table will be encrypted with a Google-managed key; that process is transparent to the user. */
	// +optional
	EncryptionConfiguration *TableEncryptionConfiguration `json:"encryptionConfiguration,omitempty"`

	/* The time when this table expires, in milliseconds since the epoch. If not present, the table will persist indefinitely. Expired tables will be deleted and their storage reclaimed. */
	// +optional
	ExpirationTime *int `json:"expirationTime,omitempty"`

	/* Describes the data format, location, and other properties of a table stored outside of BigQuery. By defining these properties, the data source can then be queried as if it were a standard BigQuery table. */
	// +optional
	ExternalDataConfiguration *TableExternalDataConfiguration `json:"externalDataConfiguration,omitempty"`

	/* A descriptive name for the table. */
	// +optional
	FriendlyName *string `json:"friendlyName,omitempty"`

	/* If specified, configures this table as a materialized view. */
	// +optional
	MaterializedView *TableMaterializedView `json:"materializedView,omitempty"`

	/* The maximum staleness of data that could be returned when the table (or stale MV) is queried. Staleness encoded as a string encoding of sql IntervalValue type. */
	// +optional
	MaxStaleness *string `json:"maxStaleness,omitempty"`

	/* If specified, configures range-based partitioning for this table. */
	// +optional
	RangePartitioning *TableRangePartitioning `json:"rangePartitioning,omitempty"`

	/* Immutable. Optional. The tableId of the resource. Used for creation and acquisition. When unset, the value of `metadata.name` is used as the default. */
	// +optional
	ResourceID *string `json:"resourceID,omitempty"`

	/* A JSON schema for the table. */
	// +optional
	Schema *string `json:"schema,omitempty"`

	/* Defines the primary key and foreign keys. */
	// +optional
	TableConstraints *TableTableConstraints `json:"tableConstraints,omitempty"`

	/* If specified, configures time-based partitioning for this table. */
	// +optional
	TimePartitioning *TableTimePartitioning `json:"timePartitioning,omitempty"`

	/* If specified, configures this table as a view. */
	// +optional
	View *TableView `json:"view,omitempty"`
}

type BigQueryTableStatus struct {
	/* Conditions represent the latest available observations of the
	   BigQueryTable's current state. */
	Conditions []v1alpha1.Condition `json:"conditions,omitempty"`
	/* The time when this table was created, in milliseconds since the epoch. */
	// +optional
	CreationTime *int `json:"creationTime,omitempty"`

	/* A hash of the resource. */
	// +optional
	Etag *string `json:"etag,omitempty"`

	/* The time when this table was last modified, in milliseconds since the epoch. */
	// +optional
	LastModifiedTime *int `json:"lastModifiedTime,omitempty"`

	/* The geographic location where the table resides. This value is inherited from the dataset. */
	// +optional
	Location *string `json:"location,omitempty"`

	/* The geographic location where the table resides. This value is inherited from the dataset. */
	// +optional
	NumBytes *int `json:"numBytes,omitempty"`

	/* The number of bytes in the table that are considered "long-term storage". */
	// +optional
	NumLongTermBytes *int `json:"numLongTermBytes,omitempty"`

	/* The number of rows of data in this table, excluding any data in the streaming buffer. */
	// +optional
	NumRows *int `json:"numRows,omitempty"`

	/* ObservedGeneration is the generation of the resource that was most recently observed by the Config Connector controller. If this is equal to metadata.generation, then that means that the current reported status reflects the most recent desired state of the resource. */
	// +optional
	ObservedGeneration *int `json:"observedGeneration,omitempty"`

	/* The URI of the created resource. */
	// +optional
	SelfLink *string `json:"selfLink,omitempty"`

	/* Describes the table type. */
	// +optional
	Type *string `json:"type,omitempty"`
}

type DatasetAccess struct {
	/* Grants all resources of particular types in a particular dataset read access to the current dataset. */
	// +optional
	Dataset *DatasetDataset `json:"dataset,omitempty"`

	/* A domain to grant access to. Any users signed in with the
	domain specified will be granted the specified access. */
	// +optional
	Domain *string `json:"domain,omitempty"`

	/* An email address of a Google Group to grant access to. */
	// +optional
	GroupByEmail *string `json:"groupByEmail,omitempty"`

	/* Some other type of member that appears in the IAM Policy but isn't a user,
	group, domain, or special group. For example: 'allUsers'. */
	// +optional
	IamMember *string `json:"iamMember,omitempty"`

	/* Describes the rights granted to the user specified by the other
	member of the access object. Basic, predefined, and custom roles
	are supported. Predefined roles that have equivalent basic roles
	are swapped by the API to their basic counterparts. See
	[official docs](https://cloud.google.com/bigquery/docs/access-control). */
	// +optional
	Role *string `json:"role,omitempty"`

	/* A routine from a different dataset to grant access to. Queries
	executed against that routine will have read access to tables in
	this dataset. The role field is not required when this field is
	set. If that routine is updated by any user, access to the routine
	needs to be granted again via an update operation. */
	// +optional
	Routine *DatasetRoutine `json:"routine,omitempty"`

	/* A special group to grant access to. Possible values include:


	* 'projectOwners': Owners of the enclosing project.


	* 'projectReaders': Readers of the enclosing project.


	* 'projectWriters': Writers of the enclosing project.


	* 'allAuthenticatedUsers': All authenticated BigQuery users. */
	// +optional
	SpecialGroup *string `json:"specialGroup,omitempty"`

	/* An email address of a user to grant access to. For example:
	fred@example.com. */
	// +optional
	UserByEmail *string `json:"userByEmail,omitempty"`

	/* A view from a different dataset to grant access to. Queries
	executed against that view will have read access to tables in
	this dataset. The role field is not required when this field is
	set. If that view is updated by any user, access to the view
	needs to be granted again via an update operation. */
	// +optional
	View *DatasetView `json:"view,omitempty"`
}

type DatasetDataset struct {
	/* The ID of the dataset containing this table. */
	DatasetId string `json:"datasetId"`

	/* The ID of the project containing this table. */
	ProjectId string `json:"projectId"`
}

type DatasetDefaultEncryptionConfiguration struct {
	/* Describes the Cloud KMS encryption key that will be used to protect destination
	BigQuery table. The BigQuery Service Account associated with your project requires
	access to this encryption key. */
	KmsKeyRef v1alpha1.ResourceRef `json:"kmsKeyRef"`
}

type DatasetRoutine struct {
	/* The ID of the dataset containing this table. */
	DatasetId string `json:"datasetId"`

	/* The ID of the project containing this table. */
	ProjectId string `json:"projectId"`

	/* The ID of the routine. The ID must contain only letters (a-z,
	A-Z), numbers (0-9), or underscores (_). The maximum length
	is 256 characters. */
	RoutineId string `json:"routineId"`
}

type DatasetView struct {
	/* The ID of the dataset containing this table. */
	DatasetId string `json:"datasetId"`

	/* The ID of the project containing this table. */
	ProjectId string `json:"projectId"`

	/* The ID of the table. The ID must contain only letters (a-z,
	A-Z), numbers (0-9), or underscores (_). The maximum length
	is 1,024 characters. */
	TableId string `json:"tableId"`
}

type JobCopy struct {
	/* Immutable. Specifies whether the job is allowed to create new tables. The following values are supported:
	CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table.
	CREATE_NEVER: The table must already exist. If it does not, a 'notFound' error is returned in the job result.
	Creation, truncation and append actions occur as one atomic update upon job completion Default value: "CREATE_NEVER" Possible values: ["CREATE_IF_NEEDED", "CREATE_NEVER"]. */
	// +optional
	CreateDisposition *string `json:"createDisposition,omitempty"`

	/* Immutable. Custom encryption configuration (e.g., Cloud KMS keys). */
	// +optional
	DestinationEncryptionConfiguration *JobDestinationEncryptionConfiguration `json:"destinationEncryptionConfiguration,omitempty"`

	/* Immutable. The destination table. */
	// +optional
	DestinationTable *JobDestinationTable `json:"destinationTable,omitempty"`

	/* Immutable. Source tables to copy. */
	SourceTables []JobSourceTables `json:"sourceTables"`

	/* Immutable. Specifies the action that occurs if the destination table already exists. The following values are supported:
	WRITE_TRUNCATE: If the table already exists, BigQuery overwrites the table data and uses the schema from the query result.
	WRITE_APPEND: If the table already exists, BigQuery appends the data to the table.
	WRITE_EMPTY: If the table already exists and contains data, a 'duplicate' error is returned in the job result.
	Each action is atomic and only occurs if BigQuery is able to complete the job successfully.
	Creation, truncation and append actions occur as one atomic update upon job completion. Default value: "WRITE_EMPTY" Possible values: ["WRITE_TRUNCATE", "WRITE_APPEND", "WRITE_EMPTY"]. */
	// +optional
	WriteDisposition *string `json:"writeDisposition,omitempty"`
}

type JobDefaultDataset struct {
	/* A reference to the dataset. */
	DatasetRef v1alpha1.ResourceRef `json:"datasetRef"`
}

type JobDestinationEncryptionConfiguration struct {
	/* Describes the Cloud KMS encryption key that will be used to protect
	destination BigQuery table. The BigQuery Service Account associated
	with your project requires access to this encryption key. */
	KmsKeyRef v1alpha1.ResourceRef `json:"kmsKeyRef"`

	/* Describes the Cloud KMS encryption key version used to protect destination BigQuery table. */
	// +optional
	KmsKeyVersion *string `json:"kmsKeyVersion,omitempty"`
}

type JobDestinationTable struct {
	/* A reference to the table. */
	TableRef v1alpha1.ResourceRef `json:"tableRef"`
}

type JobErrorResultStatus struct {
	/* Specifies where the error occurred, if present. */
	// +optional
	Location *string `json:"location,omitempty"`

	/* A human-readable description of the error. */
	// +optional
	Message *string `json:"message,omitempty"`

	/* A short error code that summarizes the error. */
	// +optional
	Reason *string `json:"reason,omitempty"`
}

type JobErrorsStatus struct {
	/* Specifies where the error occurred, if present. */
	// +optional
	Location *string `json:"location,omitempty"`

	/* A human-readable description of the error. */
	// +optional
	Message *string `json:"message,omitempty"`

	/* A short error code that summarizes the error. */
	// +optional
	Reason *string `json:"reason,omitempty"`
}

type JobExtract struct {
	/* Immutable. The compression type to use for exported files. Possible values include GZIP, DEFLATE, SNAPPY, and NONE.
	The default value is NONE. DEFLATE and SNAPPY are only supported for Avro. */
	// +optional
	Compression *string `json:"compression,omitempty"`

	/* Immutable. The exported file format. Possible values include CSV, NEWLINE_DELIMITED_JSON and AVRO for tables and SAVED_MODEL for models.
	The default value for tables is CSV. Tables with nested or repeated fields cannot be exported as CSV.
	The default value for models is SAVED_MODEL. */
	// +optional
	DestinationFormat *string `json:"destinationFormat,omitempty"`

	/* Immutable. A list of fully-qualified Google Cloud Storage URIs where the extracted table should be written. */
	DestinationUris []string `json:"destinationUris"`

	/* Immutable. When extracting data in CSV format, this defines the delimiter to use between fields in the exported data.
	Default is ','. */
	// +optional
	FieldDelimiter *string `json:"fieldDelimiter,omitempty"`

	/* Immutable. Whether to print out a header row in the results. Default is true. */
	// +optional
	PrintHeader *bool `json:"printHeader,omitempty"`

	/* Immutable. A reference to the table being exported. */
	// +optional
	SourceTable *JobSourceTable `json:"sourceTable,omitempty"`

	/* Immutable. Whether to use logical types when extracting to AVRO format. */
	// +optional
	UseAvroLogicalTypes *bool `json:"useAvroLogicalTypes,omitempty"`
}

type JobLoad struct {
	/* Immutable. Accept rows that are missing trailing optional columns. The missing values are treated as nulls.
	If false, records with missing trailing columns are treated as bad records, and if there are too many bad records,
	an invalid error is returned in the job result. The default value is false. Only applicable to CSV, ignored for other formats. */
	// +optional
	AllowJaggedRows *bool `json:"allowJaggedRows,omitempty"`

	/* Immutable. Indicates if BigQuery should allow quoted data sections that contain newline characters in a CSV file.
	The default value is false. */
	// +optional
	AllowQuotedNewlines *bool `json:"allowQuotedNewlines,omitempty"`

	/* Immutable. Indicates if we should automatically infer the options and schema for CSV and JSON sources. */
	// +optional
	Autodetect *bool `json:"autodetect,omitempty"`

	/* Immutable. Specifies whether the job is allowed to create new tables. The following values are supported:
	CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table.
	CREATE_NEVER: The table must already exist. If it does not, a 'notFound' error is returned in the job result.
	Creation, truncation and append actions occur as one atomic update upon job completion Default value: "CREATE_NEVER" Possible values: ["CREATE_IF_NEEDED", "CREATE_NEVER"]. */
	// +optional
	CreateDisposition *string `json:"createDisposition,omitempty"`

	/* Immutable. Custom encryption configuration (e.g., Cloud KMS keys). */
	// +optional
	DestinationEncryptionConfiguration *JobDestinationEncryptionConfiguration `json:"destinationEncryptionConfiguration,omitempty"`

	/* Immutable. The destination table to load the data into. */
	DestinationTable JobDestinationTable `json:"destinationTable"`

	/* Immutable. The character encoding of the data. The supported values are UTF-8 or ISO-8859-1.
	The default value is UTF-8. BigQuery decodes the data after the raw, binary data
	has been split using the values of the quote and fieldDelimiter properties. */
	// +optional
	Encoding *string `json:"encoding,omitempty"`

	/* Immutable. The separator for fields in a CSV file. The separator can be any ISO-8859-1 single-byte character.
	To use a character in the range 128-255, you must encode the character as UTF8. BigQuery converts
	the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the
	data in its raw, binary state. BigQuery also supports the escape sequence "\t" to specify a tab separator.
	The default value is a comma (','). */
	// +optional
	FieldDelimiter *string `json:"fieldDelimiter,omitempty"`

	/* Immutable. Indicates if BigQuery should allow extra values that are not represented in the table schema.
	If true, the extra values are ignored. If false, records with extra columns are treated as bad records,
	and if there are too many bad records, an invalid error is returned in the job result.
	The default value is false. The sourceFormat property determines what BigQuery treats as an extra value:
	CSV: Trailing columns
	JSON: Named values that don't match any column names. */
	// +optional
	IgnoreUnknownValues *bool `json:"ignoreUnknownValues,omitempty"`

	/* Immutable. If sourceFormat is set to newline-delimited JSON, indicates whether it should be processed as a JSON variant such as GeoJSON.
	For a sourceFormat other than JSON, omit this field. If the sourceFormat is newline-delimited JSON: - for newline-delimited
	GeoJSON: set to GEOJSON. */
	// +optional
	JsonExtension *string `json:"jsonExtension,omitempty"`

	/* Immutable. The maximum number of bad records that BigQuery can ignore when running the job. If the number of bad records exceeds this value,
	an invalid error is returned in the job result. The default value is 0, which requires that all records are valid. */
	// +optional
	MaxBadRecords *int `json:"maxBadRecords,omitempty"`

	/* Immutable. Specifies a string that represents a null value in a CSV file. For example, if you specify "\N", BigQuery interprets "\N" as a null value
	when loading a CSV file. The default value is the empty string. If you set this property to a custom value, BigQuery throws an error if an
	empty string is present for all data types except for STRING and BYTE. For STRING and BYTE columns, BigQuery interprets the empty string as
	an empty value. */
	// +optional
	NullMarker *string `json:"nullMarker,omitempty"`

	/* Immutable. Parquet Options for load and make external tables. */
	// +optional
	ParquetOptions *JobParquetOptions `json:"parquetOptions,omitempty"`

	/* Immutable. If sourceFormat is set to "DATASTORE_BACKUP", indicates which entity properties to load into BigQuery from a Cloud Datastore backup.
	Property names are case sensitive and must be top-level properties. If no properties are specified, BigQuery loads all properties.
	If any named property isn't found in the Cloud Datastore backup, an invalid error is returned in the job result. */
	// +optional
	ProjectionFields []string `json:"projectionFields,omitempty"`

	/* Immutable. The value that is used to quote data sections in a CSV file. BigQuery converts the string to ISO-8859-1 encoding,
	and then uses the first byte of the encoded string to split the data in its raw, binary state.
	The default value is a double-quote ('"'). If your data does not contain quoted sections, set the property value to an empty string.
	If your data contains quoted newline characters, you must also set the allowQuotedNewlines property to true. */
	// +optional
	Quote *string `json:"quote,omitempty"`

	/* Immutable. Allows the schema of the destination table to be updated as a side effect of the load job if a schema is autodetected or
	supplied in the job configuration. Schema update options are supported in two cases: when writeDisposition is WRITE_APPEND;
	when writeDisposition is WRITE_TRUNCATE and the destination table is a partition of a table, specified by partition decorators.
	For normal tables, WRITE_TRUNCATE will always overwrite the schema. One or more of the following values are specified:
	ALLOW_FIELD_ADDITION: allow adding a nullable field to the schema.
	ALLOW_FIELD_RELAXATION: allow relaxing a required field in the original schema to nullable. */
	// +optional
	SchemaUpdateOptions []string `json:"schemaUpdateOptions,omitempty"`

	/* Immutable. The number of rows at the top of a CSV file that BigQuery will skip when loading the data.
	The default value is 0. This property is useful if you have header rows in the file that should be skipped.
	When autodetect is on, the behavior is the following:
	skipLeadingRows unspecified - Autodetect tries to detect headers in the first row. If they are not detected,
	the row is read as data. Otherwise data is read starting from the second row.
	skipLeadingRows is 0 - Instructs autodetect that there are no headers and data should be read starting from the first row.
	skipLeadingRows = N > 0 - Autodetect skips N-1 rows and tries to detect headers in row N. If headers are not detected,
	row N is just skipped. Otherwise row N is used to extract column names for the detected schema. */
	// +optional
	SkipLeadingRows *int `json:"skipLeadingRows,omitempty"`

	/* Immutable. The format of the data files. For CSV files, specify "CSV". For datastore backups, specify "DATASTORE_BACKUP".
	For newline-delimited JSON, specify "NEWLINE_DELIMITED_JSON". For Avro, specify "AVRO". For parquet, specify "PARQUET".
	For orc, specify "ORC". [Beta] For Bigtable, specify "BIGTABLE".
	The default value is CSV. */
	// +optional
	SourceFormat *string `json:"sourceFormat,omitempty"`

	/* Immutable. The fully-qualified URIs that point to your data in Google Cloud.
	For Google Cloud Storage URIs: Each URI can contain one '\*' wildcard character
	and it must come after the 'bucket' name. Size limits related to load jobs apply
	to external data sources. For Google Cloud Bigtable URIs: Exactly one URI can be
	specified and it has be a fully specified and valid HTTPS URL for a Google Cloud Bigtable table.
	For Google Cloud Datastore backups: Exactly one URI can be specified. Also, the '\*' wildcard character is not allowed. */
	SourceUris []string `json:"sourceUris"`

	/* Immutable. Time-based partitioning specification for the destination table. */
	// +optional
	TimePartitioning *JobTimePartitioning `json:"timePartitioning,omitempty"`

	/* Immutable. Specifies the action that occurs if the destination table already exists. The following values are supported:
	WRITE_TRUNCATE: If the table already exists, BigQuery overwrites the table data and uses the schema from the query result.
	WRITE_APPEND: If the table already exists, BigQuery appends the data to the table.
	WRITE_EMPTY: If the table already exists and contains data, a 'duplicate' error is returned in the job result.
	Each action is atomic and only occurs if BigQuery is able to complete the job successfully.
	Creation, truncation and append actions occur as one atomic update upon job completion. Default value: "WRITE_EMPTY" Possible values: ["WRITE_TRUNCATE", "WRITE_APPEND", "WRITE_EMPTY"]. */
	// +optional
	WriteDisposition *string `json:"writeDisposition,omitempty"`
}

type JobParquetOptions struct {
	/* Immutable. If sourceFormat is set to PARQUET, indicates whether to use schema inference specifically for Parquet LIST logical type. */
	// +optional
	EnableListInference *bool `json:"enableListInference,omitempty"`

	/* Immutable. If sourceFormat is set to PARQUET, indicates whether to infer Parquet ENUM logical type as STRING instead of BYTES by default. */
	// +optional
	EnumAsString *bool `json:"enumAsString,omitempty"`
}

type JobQuery struct {
	/* Immutable. If true and query uses legacy SQL dialect, allows the query to produce arbitrarily large result tables at a slight cost in performance.
	Requires destinationTable to be set. For standard SQL queries, this flag is ignored and large results are always allowed.
	However, you must still set destinationTable when result size exceeds the allowed maximum response size. */
	// +optional
	AllowLargeResults *bool `json:"allowLargeResults,omitempty"`

	/* Immutable. Specifies whether the job is allowed to create new tables. The following values are supported:
	CREATE_IF_NEEDED: If the table does not exist, BigQuery creates the table.
	CREATE_NEVER: The table must already exist. If it does not, a 'notFound' error is returned in the job result.
	Creation, truncation and append actions occur as one atomic update upon job completion Default value: "CREATE_NEVER" Possible values: ["CREATE_IF_NEEDED", "CREATE_NEVER"]. */
	// +optional
	CreateDisposition *string `json:"createDisposition,omitempty"`

	/* Immutable. Specifies the default dataset to use for unqualified table names in the query. Note that this does not alter behavior of unqualified dataset names. */
	// +optional
	DefaultDataset *JobDefaultDataset `json:"defaultDataset,omitempty"`

	/* Immutable. Custom encryption configuration (e.g., Cloud KMS keys). */
	// +optional
	DestinationEncryptionConfiguration *JobDestinationEncryptionConfiguration `json:"destinationEncryptionConfiguration,omitempty"`

	/* Immutable. Describes the table where the query results should be stored.
	This property must be set for large results that exceed the maximum response size.
	For queries that produce anonymous (cached) results, this field will be populated by BigQuery. */
	// +optional
	DestinationTable *JobDestinationTable `json:"destinationTable,omitempty"`

	/* Immutable. If true and query uses legacy SQL dialect, flattens all nested and repeated fields in the query results.
	allowLargeResults must be true if this is set to false. For standard SQL queries, this flag is ignored and results are never flattened. */
	// +optional
	FlattenResults *bool `json:"flattenResults,omitempty"`

	/* Immutable. Limits the billing tier for this job. Queries that have resource usage beyond this tier will fail (without incurring a charge).
	If unspecified, this will be set to your project default. */
	// +optional
	MaximumBillingTier *int `json:"maximumBillingTier,omitempty"`

	/* Immutable. Limits the bytes billed for this job. Queries that will have bytes billed beyond this limit will fail (without incurring a charge).
	If unspecified, this will be set to your project default. */
	// +optional
	MaximumBytesBilled *string `json:"maximumBytesBilled,omitempty"`

	/* Immutable. Standard SQL only. Set to POSITIONAL to use positional (?) query parameters or to NAMED to use named (@myparam) query parameters in this query. */
	// +optional
	ParameterMode *string `json:"parameterMode,omitempty"`

	/* Immutable. Specifies a priority for the query. Default value: "INTERACTIVE" Possible values: ["INTERACTIVE", "BATCH"]. */
	// +optional
	Priority *string `json:"priority,omitempty"`

	/* Immutable. SQL query text to execute. The useLegacySql field can be used to indicate whether the query uses legacy SQL or standard SQL.
	*NOTE*: queries containing [DML language](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-manipulation-language)
	('DELETE', 'UPDATE', 'MERGE', 'INSERT') must specify 'create_disposition = ""' and 'write_disposition = ""'. */
	Query string `json:"query"`

	/* Immutable. Allows the schema of the destination table to be updated as a side effect of the query job.
	Schema update options are supported in two cases: when writeDisposition is WRITE_APPEND;
	when writeDisposition is WRITE_TRUNCATE and the destination table is a partition of a table,
	specified by partition decorators. For normal tables, WRITE_TRUNCATE will always overwrite the schema.
	One or more of the following values are specified:
	ALLOW_FIELD_ADDITION: allow adding a nullable field to the schema.
	ALLOW_FIELD_RELAXATION: allow relaxing a required field in the original schema to nullable. */
	// +optional
	SchemaUpdateOptions []string `json:"schemaUpdateOptions,omitempty"`

	/* Immutable. Options controlling the execution of scripts. */
	// +optional
	ScriptOptions *JobScriptOptions `json:"scriptOptions,omitempty"`

	/* Immutable. Specifies whether to use BigQuery's legacy SQL dialect for this query. The default value is true.
	If set to false, the query will use BigQuery's standard SQL. */
	// +optional
	UseLegacySql *bool `json:"useLegacySql,omitempty"`

	/* Immutable. Whether to look for the result in the query cache. The query cache is a best-effort cache that will be flushed whenever
	tables in the query are modified. Moreover, the query cache is only available when a query does not have a destination table specified.
	The default value is true. */
	// +optional
	UseQueryCache *bool `json:"useQueryCache,omitempty"`

	/* Immutable. Describes user-defined function resources used in the query. */
	// +optional
	UserDefinedFunctionResources []JobUserDefinedFunctionResources `json:"userDefinedFunctionResources,omitempty"`

	/* Immutable. Specifies the action that occurs if the destination table already exists. The following values are supported:
	WRITE_TRUNCATE: If the table already exists, BigQuery overwrites the table data and uses the schema from the query result.
	WRITE_APPEND: If the table already exists, BigQuery appends the data to the table.
	WRITE_EMPTY: If the table already exists and contains data, a 'duplicate' error is returned in the job result.
	Each action is atomic and only occurs if BigQuery is able to complete the job successfully.
	Creation, truncation and append actions occur as one atomic update upon job completion. Default value: "WRITE_EMPTY" Possible values: ["WRITE_TRUNCATE", "WRITE_APPEND", "WRITE_EMPTY"]. */
	// +optional
	WriteDisposition *string `json:"writeDisposition,omitempty"`
}

type JobScriptOptions struct {
	/* Immutable. Determines which statement in the script represents the "key result",
	used to populate the schema and query results of the script job. Possible values: ["LAST", "FIRST_SELECT"]. */
	// +optional
	KeyResultStatement *string `json:"keyResultStatement,omitempty"`

	/* Immutable. Limit on the number of bytes billed per statement. Exceeding this budget results in an error. */
	// +optional
	StatementByteBudget *string `json:"statementByteBudget,omitempty"`

	/* Immutable. Timeout period for each statement in a script. */
	// +optional
	StatementTimeoutMs *string `json:"statementTimeoutMs,omitempty"`
}

type JobSourceTable struct {
	/* A reference to the table. */
	TableRef v1alpha1.ResourceRef `json:"tableRef"`
}

type JobSourceTables struct {
	/* A reference to the table. */
	TableRef v1alpha1.ResourceRef `json:"tableRef"`
}

type JobStatusStatus struct {
	/* Final error result of the job. If present, indicates that the job has completed and was unsuccessful. */
	// +optional
	ErrorResult []JobErrorResultStatus `json:"errorResult,omitempty"`

	/* The first errors encountered during the running of the job. The final message
	includes the number of errors that caused the process to stop. Errors here do
	not necessarily mean that the job has not completed or was unsuccessful. */
	// +optional
	Errors []JobErrorsStatus `json:"errors,omitempty"`

	/* Running state of the job. Valid states include 'PENDING', 'RUNNING', and 'DONE'. */
	// +optional
	State *string `json:"state,omitempty"`
}

type JobTimePartitioning struct {
	/* Immutable. Number of milliseconds for which to keep the storage for a partition. A wrapper is used here because 0 is an invalid value. */
	// +optional
	ExpirationMs *string `json:"expirationMs,omitempty"`

	/* Immutable. If not set, the table is partitioned by pseudo column '_PARTITIONTIME'; if set, the table is partitioned by this field.
	The field must be a top-level TIMESTAMP or DATE field. Its mode must be NULLABLE or REQUIRED.
	A wrapper is used here because an empty string is an invalid value. */
	// +optional
	Field *string `json:"field,omitempty"`

	/* Immutable. The only type supported is DAY, which will generate one partition per day. Providing an empty string used to cause an error,
	but in OnePlatform the field will be treated as unset. */
	Type string `json:"type"`
}

type JobUserDefinedFunctionResources struct {
	/* Immutable. An inline resource that contains code for a user-defined function (UDF).
	Providing a inline code resource is equivalent to providing a URI for a file containing the same code. */
	// +optional
	InlineCode *string `json:"inlineCode,omitempty"`

	/* Immutable. A code resource to load from a Google Cloud Storage URI (gs://bucket/path). */
	// +optional
	ResourceUri *string `json:"resourceUri,omitempty"`
}

type RoutineArguments struct {
	/* Defaults to FIXED_TYPE. Default value: "FIXED_TYPE" Possible values: ["FIXED_TYPE", "ANY_TYPE"]. */
	// +optional
	ArgumentKind *string `json:"argumentKind,omitempty"`

	/* A JSON schema for the data type. Required unless argumentKind = ANY_TYPE.
	~>**NOTE**: Because this field expects a JSON string, any changes to the string
	will create a diff, even if the JSON itself hasn't changed. If the API returns
	a different value for the same schema, e.g. it switched the order of values
	or replaced STRUCT field type with RECORD field type, we currently cannot
	suppress the recurring diff this causes. As a workaround, we recommend using
	the schema as returned by the API. */
	// +optional
	DataType *string `json:"dataType,omitempty"`

	/* Specifies whether the argument is input or output. Can be set for procedures only. Possible values: ["IN", "OUT", "INOUT"]. */
	// +optional
	Mode *string `json:"mode,omitempty"`

	/* The name of this argument. Can be absent for function return argument. */
	// +optional
	Name *string `json:"name,omitempty"`
}

type TableAvroOptions struct {
	/* If sourceFormat is set to "AVRO", indicates whether to interpret logical types as the corresponding BigQuery data type (for example, TIMESTAMP), instead of using the raw type (for example, INTEGER). */
	UseAvroLogicalTypes bool `json:"useAvroLogicalTypes"`
}

type TableColumnReferences struct {
	/* The column in the primary key that are referenced by the referencingColumn. */
	ReferencedColumn string `json:"referencedColumn"`

	/* The column that composes the foreign key. */
	ReferencingColumn string `json:"referencingColumn"`
}

type TableCsvOptions struct {
	/* Indicates if BigQuery should accept rows that are missing trailing optional columns. */
	// +optional
	AllowJaggedRows *bool `json:"allowJaggedRows,omitempty"`

	/* Indicates if BigQuery should allow quoted data sections that contain newline characters in a CSV file. The default value is false. */
	// +optional
	AllowQuotedNewlines *bool `json:"allowQuotedNewlines,omitempty"`

	/* The character encoding of the data. The supported values are UTF-8 or ISO-8859-1. */
	// +optional
	Encoding *string `json:"encoding,omitempty"`

	/* The separator for fields in a CSV file. */
	// +optional
	FieldDelimiter *string `json:"fieldDelimiter,omitempty"`

	Quote string `json:"quote"`

	/* The number of rows at the top of a CSV file that BigQuery will skip when reading the data. */
	// +optional
	SkipLeadingRows *int `json:"skipLeadingRows,omitempty"`
}

type TableEncryptionConfiguration struct {
	KmsKeyRef v1alpha1.ResourceRef `json:"kmsKeyRef"`

	/* The self link or full name of the kms key version used to encrypt this table. */
	// +optional
	KmsKeyVersion *string `json:"kmsKeyVersion,omitempty"`
}

type TableExternalDataConfiguration struct {
	/* Let BigQuery try to autodetect the schema and format of the table. */
	Autodetect bool `json:"autodetect"`

	/* Additional options if source_format is set to "AVRO". */
	// +optional
	AvroOptions *TableAvroOptions `json:"avroOptions,omitempty"`

	/* The compression type of the data source. Valid values are "NONE" or "GZIP". */
	// +optional
	Compression *string `json:"compression,omitempty"`

	/* The connection specifying the credentials to be used to read external storage, such as Azure Blob, Cloud Storage, or S3. The connectionId can have the form "{{project}}.{{location}}.{{connection_id}}" or "projects/{{project}}/locations/{{location}}/connections/{{connection_id}}". */
	// +optional
	ConnectionId *string `json:"connectionId,omitempty"`

	/* Additional properties to set if source_format is set to "CSV". */
	// +optional
	CsvOptions *TableCsvOptions `json:"csvOptions,omitempty"`

	/* Specifies how source URIs are interpreted for constructing the file set to load.  By default source URIs are expanded against the underlying storage.  Other options include specifying manifest files. Only applicable to object storage systems. */
	// +optional
	FileSetSpecType *string `json:"fileSetSpecType,omitempty"`

	/* Additional options if source_format is set to "GOOGLE_SHEETS". */
	// +optional
	GoogleSheetsOptions *TableGoogleSheetsOptions `json:"googleSheetsOptions,omitempty"`

	/* When set, configures hive partitioning support. Not all storage formats support hive partitioning -- requesting hive partitioning on an unsupported format will lead to an error, as will providing an invalid specification. */
	// +optional
	HivePartitioningOptions *TableHivePartitioningOptions `json:"hivePartitioningOptions,omitempty"`

	/* Indicates if BigQuery should allow extra values that are not represented in the table schema. If true, the extra values are ignored. If false, records with extra columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false. */
	// +optional
	IgnoreUnknownValues *bool `json:"ignoreUnknownValues,omitempty"`

	/* Additional properties to set if sourceFormat is set to JSON.". */
	// +optional
	JsonOptions *TableJsonOptions `json:"jsonOptions,omitempty"`

	/* The maximum number of bad records that BigQuery can ignore when reading data. */
	// +optional
	MaxBadRecords *int `json:"maxBadRecords,omitempty"`

	/* Metadata Cache Mode for the table. Set this to enable caching of metadata from external data source. */
	// +optional
	MetadataCacheMode *string `json:"metadataCacheMode,omitempty"`

	/* Object Metadata is used to create Object Tables. Object Tables contain a listing of objects (with their metadata) found at the sourceUris. If ObjectMetadata is set, sourceFormat should be omitted. */
	// +optional
	ObjectMetadata *string `json:"objectMetadata,omitempty"`

	/* Additional properties to set if sourceFormat is set to PARQUET.". */
	// +optional
	ParquetOptions *TableParquetOptions `json:"parquetOptions,omitempty"`

	/* When creating an external table, the user can provide a reference file with the table schema. This is enabled for the following formats: AVRO, PARQUET, ORC. */
	// +optional
	ReferenceFileSchemaUri *string `json:"referenceFileSchemaUri,omitempty"`

	/* Immutable. A JSON schema for the external table. Schema is required for CSV and JSON formats and is disallowed for Google Cloud Bigtable, Cloud Datastore backups, and Avro formats when using external tables. */
	// +optional
	Schema *string `json:"schema,omitempty"`

	/* Please see sourceFormat under ExternalDataConfiguration in Bigquery's public API documentation (https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#externaldataconfiguration) for supported formats. To use "GOOGLE_SHEETS" the scopes must include "googleapis.com/auth/drive.readonly". */
	// +optional
	SourceFormat *string `json:"sourceFormat,omitempty"`

	/* A list of the fully-qualified URIs that point to your data in Google Cloud. */
	SourceUris []string `json:"sourceUris"`
}

type TableForeignKeys struct {
	/* The pair of the foreign key column and primary key column. */
	ColumnReferences TableColumnReferences `json:"columnReferences"`

	/* Set only if the foreign key constraint is named. */
	// +optional
	Name *string `json:"name,omitempty"`

	/* The table that holds the primary key and is referenced by this foreign key. */
	ReferencedTable TableReferencedTable `json:"referencedTable"`
}

type TableGoogleSheetsOptions struct {
	/* Range of a sheet to query from. Only used when non-empty. At least one of range or skip_leading_rows must be set. Typical format: "sheet_name!top_left_cell_id:bottom_right_cell_id" For example: "sheet1!A1:B20". */
	// +optional
	Range *string `json:"range,omitempty"`

	/* The number of rows at the top of the sheet that BigQuery will skip when reading the data. At least one of range or skip_leading_rows must be set. */
	// +optional
	SkipLeadingRows *int `json:"skipLeadingRows,omitempty"`
}

type TableHivePartitioningOptions struct {
	/* When set, what mode of hive partitioning to use when reading data. */
	// +optional
	Mode *string `json:"mode,omitempty"`

	/* If set to true, queries over this table require a partition filter that can be used for partition elimination to be specified. */
	// +optional
	RequirePartitionFilter *bool `json:"requirePartitionFilter,omitempty"`

	/* When hive partition detection is requested, a common for all source uris must be required. The prefix must end immediately before the partition key encoding begins. */
	// +optional
	SourceUriPrefix *string `json:"sourceUriPrefix,omitempty"`
}

type TableJsonOptions struct {
	/* The character encoding of the data. The supported values are UTF-8, UTF-16BE, UTF-16LE, UTF-32BE, and UTF-32LE. The default value is UTF-8. */
	// +optional
	Encoding *string `json:"encoding,omitempty"`
}

type TableMaterializedView struct {
	/* Immutable. Allow non incremental materialized view definition. The default value is false. */
	// +optional
	AllowNonIncrementalDefinition *bool `json:"allowNonIncrementalDefinition,omitempty"`

	/* Specifies if BigQuery should automatically refresh materialized view when the base table is updated. The default is true. */
	// +optional
	EnableRefresh *bool `json:"enableRefresh,omitempty"`

	/* Immutable. A query whose result is persisted. */
	Query string `json:"query"`

	/* Specifies maximum frequency at which this materialized view will be refreshed. The default is 1800000. */
	// +optional
	RefreshIntervalMs *int `json:"refreshIntervalMs,omitempty"`
}

type TableParquetOptions struct {
	/* Indicates whether to use schema inference specifically for Parquet LIST logical type. */
	// +optional
	EnableListInference *bool `json:"enableListInference,omitempty"`

	/* Indicates whether to infer Parquet ENUM logical type as STRING instead of BYTES by default. */
	// +optional
	EnumAsString *bool `json:"enumAsString,omitempty"`
}

type TablePrimaryKey struct {
	/* The columns that are composed of the primary key constraint. */
	Columns []string `json:"columns"`
}

type TableRange struct {
	/* End of the range partitioning, exclusive. */
	End int `json:"end"`

	/* The width of each range within the partition. */
	Interval int `json:"interval"`

	/* Start of the range partitioning, inclusive. */
	Start int `json:"start"`
}

type TableRangePartitioning struct {
	/* Immutable. The field used to determine how to create a range-based partition. */
	Field string `json:"field"`

	/* Information required to partition based on ranges. Structure is documented below. */
	Range TableRange `json:"range"`
}

type TableReferencedTable struct {
	/* The ID of the dataset containing this table. */
	DatasetId string `json:"datasetId"`

	/* The ID of the project containing this table. */
	ProjectId string `json:"projectId"`

	/* The ID of the table. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 1,024 characters. Certain operations allow suffixing of the table ID with a partition decorator, such as sample_table$20190123. */
	TableId string `json:"tableId"`
}

type TableTableConstraints struct {
	/* Present only if the table has a foreign key. The foreign key is not enforced. */
	// +optional
	ForeignKeys []TableForeignKeys `json:"foreignKeys,omitempty"`

	/* Represents a primary key constraint on a table's columns. Present only if the table has a primary key. The primary key is not enforced. */
	// +optional
	PrimaryKey *TablePrimaryKey `json:"primaryKey,omitempty"`
}

type TableTimePartitioning struct {
	/* Number of milliseconds for which to keep the storage for a partition. */
	// +optional
	ExpirationMs *int `json:"expirationMs,omitempty"`

	/* Immutable. The field used to determine how to create a time-based partition. If time-based partitioning is enabled without this value, the table is partitioned based on the load time. */
	// +optional
	Field *string `json:"field,omitempty"`

	/* If set to true, queries over this table require a partition filter that can be used for partition elimination to be specified. */
	// +optional
	RequirePartitionFilter *bool `json:"requirePartitionFilter,omitempty"`

	/* The supported types are DAY, HOUR, MONTH, and YEAR, which will generate one partition per day, hour, month, and year, respectively. */
	Type string `json:"type"`
}

type TableView struct {
	/* A query that BigQuery executes when the view is referenced. */
	Query string `json:"query"`

	/* Specifies whether to use BigQuery's legacy SQL for this view. The default value is true. If set to false, the view will use BigQuery's standard SQL. */
	// +optional
	UseLegacySql *bool `json:"useLegacySql,omitempty"`
}