clusters

type Adlsgen2Info struct {
	// abfss destination, e.g.
	// `abfss://<container-name>@<storage-account-name>.dfs.core.windows.net/<directory-name>`.
	Destination *string
}

type AutoScale struct {
	// The minimum number of workers to which the cluster can scale down when
	// underutilized. It is also the initial number of workers the cluster will have
	// after creation.
	MinWorkers *int `fieldmask:"min_workers"`
	// The maximum number of workers to which the cluster can scale up when
	// overloaded. Note that `max_workers` must be strictly greater than
	// `min_workers`.
	MaxWorkers *int `fieldmask:"max_workers"`
}

type AwsAttributes struct {
	// The first `first_on_demand` nodes of the cluster will be placed on on-demand
	// instances. If this value is greater than 0, the cluster driver node in
	// particular will be placed on an on-demand instance. If this value is greater
	// than or equal to the current cluster size, all nodes will be placed on
	// on-demand instances. If this value is less than the current cluster size,
	// `first_on_demand` nodes will be placed on on-demand instances and the
	// remainder will be placed on `availability` instances. Note that this value
	// does not affect cluster size and cannot currently be mutated over the
	// lifetime of a cluster.
	FirstOnDemand *int            `fieldmask:"first_on_demand"`
	Availability  AwsAvailability `fieldmask:"availability"`
	// Identifier for the availability zone/datacenter in which the cluster resides.
	// This string will be of a form like "us-west-2a". The provided availability
	// zone must be in the same region as the <Databricks> deployment. For example,
	// "us-west-2a" is not a valid zone id if the <Databricks> deployment resides in
	// the "us-east-1" region. This is an optional field at cluster creation, and if
	// not specified, the zone "auto" will be used. If the zone specified is "auto",
	// will try to place cluster in a zone with high availability, and will retry
	// placement in a different AZ if there is not enough capacity. The list of
	// available zones as well as the default value can be found by using the `List
	// Zones` method.
	ZoneId *string `fieldmask:"zone_id"`
	// Nodes for this cluster will only be placed on AWS instances with this
	// instance profile. If ommitted, nodes will be placed on instances without an
	// IAM instance profile. The instance profile must have previously been added to
	// the <Databricks> environment by an account administrator.
	//
	// This feature may only be available to certain customer plans.
	InstanceProfileArn *string `fieldmask:"instance_profile_arn"`
	// The bid price for AWS spot instances, as a percentage of the corresponding
	// instance type's on-demand price. For example, if this field is set to 50, and
	// the cluster needs a new `r3.xlarge` spot instance, then the bid price is half
	// of the price of on-demand `r3.xlarge` instances. Similarly, if this field is
	// set to 200, the bid price is twice the price of on-demand `r3.xlarge`
	// instances. If not specified, the default value is 100. When spot instances
	// are requested for this cluster, only spot instances whose bid price
	// percentage matches this field will be considered. Note that, for safety, we
	// enforce this field to be no more than 10000.
	SpotBidPricePercent *int `fieldmask:"spot_bid_price_percent"`
	// The type of EBS volumes that will be launched with this cluster.
	EbsVolumeType EbsVolumeType `fieldmask:"ebs_volume_type"`
	// The number of volumes launched for each instance. Users can choose up to 10
	// volumes. This feature is only enabled for supported node types. Legacy node
	// types cannot specify custom EBS volumes. For node types with no instance
	// store, at least one EBS volume needs to be specified; otherwise, cluster
	// creation will fail.
	//
	// These EBS volumes will be mounted at `/ebs0`, `/ebs1`, and etc. Instance
	// store volumes will be mounted at `/local_disk0`, `/local_disk1`, and etc.
	//
	// If EBS volumes are attached, <Databricks> will configure Spark to use only
	// the EBS volumes for scratch storage because heterogenously sized scratch
	// devices can lead to inefficient disk utilization. If no EBS volumes are
	// attached, <Databricks> will configure Spark to use instance store volumes.
	//
	// Please note that if EBS volumes are specified, then the Spark configuration
	// `spark.local.dir` will be overridden.
	EbsVolumeCount *int `fieldmask:"ebs_volume_count"`
	// The size of each EBS volume (in GiB) launched for each instance. For general
	// purpose SSD, this value must be within the range 100 - 4096. For throughput
	// optimized HDD, this value must be within the range 500 - 4096.
	EbsVolumeSize *int `fieldmask:"ebs_volume_size"`
	// If using gp3 volumes, what IOPS to use for the disk. If this is not set, the
	// maximum performance of a gp2 volume with the same volume size will be used.
	EbsVolumeIops *int `fieldmask:"ebs_volume_iops"`
	// If using gp3 volumes, what throughput to use for the disk. If this is not
	// set, the maximum performance of a gp2 volume with the same volume size will
	// be used.
	EbsVolumeThroughput *int `fieldmask:"ebs_volume_throughput"`
}

type AwsAvailability string

type AzureAttributes struct {
	// Defines values necessary to configure and run Azure Log Analytics agent
	LogAnalyticsInfo *LogAnalyticsInfo `fieldmask:"log_analytics_info"`
	// The first `first_on_demand` nodes of the cluster will be placed on on-demand
	// instances. This value should be greater than 0, to make sure the cluster
	// driver node is placed on an on-demand instance. If this value is greater than
	// or equal to the current cluster size, all nodes will be placed on on-demand
	// instances. If this value is less than the current cluster size,
	// `first_on_demand` nodes will be placed on on-demand instances and the
	// remainder will be placed on `availability` instances. Note that this value
	// does not affect cluster size and cannot currently be mutated over the
	// lifetime of a cluster.
	FirstOnDemand *int `fieldmask:"first_on_demand"`
	// Availability type used for all subsequent nodes past the `first_on_demand`
	// ones. Note: If `first_on_demand` is zero, this availability type will be used
	// for the entire cluster.
	Availability AzureAvailability `fieldmask:"availability"`
	// The max bid price to be used for Azure spot instances. The Max price for the
	// bid cannot be higher than the on-demand price of the instance. If not
	// specified, the default value is -1, which specifies that the instance cannot
	// be evicted on the basis of price, and only on the basis of availability.
	// Further, the value should > 0 or -1.
	SpotBidMaxPrice *float64 `fieldmask:"spot_bid_max_price"`
	// The Azure capacity reservation group resource ID to use for launching VMs.
	// When specified, VMs will be launched using the provided capacity reservation.
	//
	// Capacity reservations can only be specified when the workspace uses injected
	// vnet (i.e. customer defined vnet not managed by databricks). Ensure the
	// databricks-login-prod Enterprise Application is granted the following four
	// permissions: 1. Microsoft.Compute/capacityReservationGroups/read 2.
	// Microsoft.Compute/capacityReservationGroups/deploy/action 3.
	// Microsoft.Compute/capacityReservationGroups/capacityReservations/read 4.
	// Microsoft.Compute/capacityReservationGroups/capacityReservations/deploy/action
	//
	// Format:
	// `/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/capacityReservationGroups/{capacityReservationGroupName}`
	CapacityReservationGroup *string `fieldmask:"capacity_reservation_group"`
}

type AzureAvailability string

type CancelPendingClusterEnforcementRequest struct {
	// The ID of the cluster to cancel the pending enforcement for.
	ClusterId *string
	// If true and no pending enforcement exists, the request will succeed but no
	// action will be taken.
	AllowMissing *bool
}

type CancelPendingClusterEnforcementResponse struct {
}

type ChangeClusterOwnerRequest struct {
	ClusterId *string
	// New owner of the cluster_id after this RPC.
	OwnerUsername *string
}

type ChangeClusterOwnerResponse struct {
}

type Client struct {
	// contains filtered or unexported fields
}

type CloneCluster struct {
	// The cluster that is being cloned.
	SourceClusterId *string
}

type CloudProviderNodeInfo struct {
	// Status as reported by the cloud provider
	Status []CloudProviderNodeStatus
}

type CloudProviderNodeStatus string

type ClusterAttributes struct {
	// Cluster name requested by the user. This doesn't have to be unique. If not
	// specified at creation, the cluster name will be an empty string. For job
	// clusters, the cluster name is automatically set based on the job and job run
	// IDs.
	ClusterName *string
	// The Spark version of the cluster, e.g. `3.3.x-scala2.11`. A list of available
	// Spark versions can be retrieved by using the [clusters/sparkVersions] API
	// call.
	//
	// [clusters/sparkVersions]: https://docs.databricks.com/api/workspace/clusters/sparkversions
	SparkVersion *string
	// An object containing a set of optional, user-specified Spark configuration
	// key-value pairs. Users can also pass in a string of extra JVM options to the
	// driver and the executors via `spark.driver.extraJavaOptions` and
	// `spark.executor.extraJavaOptions` respectively.
	SparkConf map[string]string
	// Attributes related to clusters running on Amazon Web Services. If not
	// specified at cluster creation, a set of default values will be used.
	AwsAttributes *AwsAttributes
	// Attributes related to clusters running on Microsoft Azure. If not specified
	// at cluster creation, a set of default values will be used.
	AzureAttributes *AzureAttributes
	// Attributes related to clusters running on Google Cloud Platform. If not
	// specified at cluster creation, a set of default values will be used.
	GcpAttributes *GcpAttributes
	// This field encodes, through a single value, the resources available to each
	// of the Spark nodes in this cluster. For example, the Spark nodes can be
	// provisioned and optimized for memory or compute intensive workloads. A list
	// of available node types can be retrieved by using the
	// [clusters/listNodeTypes] API call.
	//
	// [clusters/listNodeTypes]: https://docs.databricks.com/api/workspace/clusters/listnodetypes
	NodeTypeId *string
	// The node type of the Spark driver. Note that this field is optional; if
	// unset, the driver node type will be set as the same value as `node_type_id`
	// defined above.
	//
	// This field, along with node_type_id, should not be set if
	// virtual_cluster_size is set. If both driver_node_type_id, node_type_id, and
	// virtual_cluster_size are specified, driver_node_type_id and node_type_id take
	// precedence.
	DriverNodeTypeId *string
	// Flexible node type configuration for worker nodes.
	WorkerNodeTypeFlexibility *NodeTypeFlexibility
	// Flexible node type configuration for the driver node.
	DriverNodeTypeFlexibility *NodeTypeFlexibility
	// SSH public key contents that will be added to each Spark node in this
	// cluster. The corresponding private keys can be used to login with the user
	// name `ubuntu` on port `2200`. Up to 10 keys can be specified.
	SshPublicKeys []string
	// Additional tags for cluster resources. <Databricks> will tag all cluster
	// resources (e.g., AWS instances and EBS volumes) with these tags in addition
	// to `default_tags`. Notes:
	//
	// - Currently, <Databricks> allows at most 45 custom tags
	//
	// - Clusters can only reuse cloud resources if the resources' tags are a subset
	// of the cluster tags
	CustomTags map[string]string
	// The configuration for delivering spark logs to a long-term storage
	// destination. Three kinds of destinations (DBFS, S3 and Unity Catalog volumes)
	// are supported. Only one destination can be specified for one cluster. If the
	// conf is given, the logs will be delivered to the destination every `5 mins`.
	// The destination of driver logs is `$destination/$clusterId/driver`, while the
	// destination of executor logs is `$destination/$clusterId/executor`.
	ClusterLogConf *ClusterLogConf
	// An object containing a set of optional, user-specified environment variable
	// key-value pairs. Please note that key-value pair of the form (X,Y) will be
	// exported as is (i.e., `export X='Y'`) while launching the driver and workers.
	//
	// In order to specify an additional set of `SPARK_DAEMON_JAVA_OPTS`, we
	// recommend appending them to `$SPARK_DAEMON_JAVA_OPTS` as shown in the example
	// below. This ensures that all default databricks managed environmental
	// variables are included as well.
	//
	// Example Spark environment variables: `{"SPARK_WORKER_MEMORY": "28000m",
	// "SPARK_LOCAL_DIRS": "/local_disk0"}` or `{"SPARK_DAEMON_JAVA_OPTS":
	// "$SPARK_DAEMON_JAVA_OPTS -Dspark.shuffle.service.enabled=true"}`
	SparkEnvVars map[string]string
	// Automatically terminates the cluster after it is inactive for this time in
	// minutes. If not set, this cluster will not be automatically terminated. If
	// specified, the threshold must be between 10 and 10000 minutes. Users can also
	// set this value to 0 to explicitly disable automatic termination.
	AutoterminationMinutes *int
	// Autoscaling Local Storage: when enabled, this cluster will dynamically
	// acquire additional disk space when its Spark workers are running low on disk
	// space.
	EnableElasticDisk *bool
	// The configuration for storing init scripts. Any number of destinations can be
	// specified. The scripts are executed sequentially in the order provided. If
	// `cluster_log_conf` is specified, init script logs are sent to
	// `<destination>/<cluster-ID>/init_scripts`.
	InitScripts []InitScriptInfo
	// Custom docker image BYOC
	DockerImage *DockerImage
	// The optional ID of the instance pool to which the cluster belongs.
	InstancePoolId *string
	// Single user name if data_security_mode is `SINGLE_USER`
	SingleUserName *string
	// The ID of the cluster policy used to create the cluster if applicable.
	PolicyId *string
	// Whether to enable LUKS on cluster VMs' local disks
	EnableLocalDiskEncryption *bool
	// The optional ID of the instance pool for the driver of the cluster belongs.
	// The pool cluster uses the instance pool with id (instance_pool_id) if the
	// driver pool is not assigned.
	DriverInstancePoolId *string
	WorkloadType         *WorkloadType
	DataSecurityMode     DataSecurityMode
	// Determines the cluster's runtime engine, either standard or Photon.
	//
	// This field is not compatible with legacy `spark_version` values that contain
	// `-photon-`. Remove `-photon-` from the `spark_version` and set
	// `runtime_engine` to `PHOTON`.
	//
	// If left unspecified, the runtime engine defaults to standard unless the
	// spark_version contains -photon-, in which case Photon will be used.
	RuntimeEngine RuntimeEngine
	Kind          ComputeKind
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// `effective_spark_version` is determined by `spark_version` (DBR release),
	// this field `use_ml_runtime`, and whether `node_type_id` is gpu node or not.
	UseMlRuntime *bool
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// When set to true, <Databricks> will automatically set single node related
	// `custom_tags`, `spark_conf`, and `num_workers`
	IsSingleNode *bool
	// If set, what the configurable throughput (in Mb/s) for the remote disk is.
	// Currently only supported for GCP HYPERDISK_BALANCED disks.
	RemoteDiskThroughput *int
	// If set, what the total initial volume size (in GB) of the remote disks should
	// be. Supported for GCP.
	TotalInitialRemoteDiskSize *int
	// Controls dependency configuration for the cluster.
	DependencyMode DependencyMode
}

type ClusterCompliance struct {
	// Canonical unique identifier for a cluster.
	ClusterId *string
	// Whether this cluster is in compliance with the latest version of its policy.
	IsCompliant *bool
	// An object containing key-value mappings representing the first 200 policy
	// validation errors. The keys indicate the path where the policy validation
	// error is occurring. The values indicate an error message describing the
	// policy validation error.
	Violations map[string]string
	// Information about the pending enforcement for the cluster. Only present if a
	// pending enforcement is scheduled for the cluster.
	PendingEnforcement *PendingEnforcement
}

type ClusterEvent struct {
	ClusterId *string
	// The timestamp when the event occurred, stored as the number of milliseconds
	// since the Unix epoch. If not provided, this will be assigned by the Timeline
	// service.
	Timestamp             *int64
	Type                  ClusterEventType_ClusterEventType
	Details               *EventDetails
	DataPlaneEventDetails *DataPlaneEventDetails
}

type ClusterEventType struct {
}

type ClusterEventType_ClusterEventType string

type ClusterInfo struct {
	// Canonical identifier for the cluster. This id is retained during cluster
	// restarts and resizes, while each new cluster has a globally unique id.
	ClusterId *string
	// Creator user name. The field won't be included in the response if the user
	// has already been deleted.
	CreatorUserName *string
	// Current state of the cluster.
	State ClusterState_ClusterState
	// A message associated with the most recent state transition (e.g., the reason
	// why the cluster entered a `TERMINATED` state).
	StateMessage *string
	// Total amount of cluster memory, in megabytes
	ClusterMemoryMb *int64
	// Number of CPU cores available for this cluster. Note that this can be
	// fractional, e.g. 7.5 cores, since certain node types are configured to share
	// cores between Spark nodes on the same instance.
	ClusterCores *float32
	// Tags that are added by <Databricks> regardless of any `custom_tags`,
	// including:
	//
	// - Vendor: <Databricks>
	//
	// - Creator: <username_of_creator>
	//
	// - ClusterName: <name_of_cluster>
	//
	// - ClusterId: <id_of_cluster>
	//
	// - Name: <<Databricks> internal use>
	DefaultTags map[string]string
	// Cluster log delivery status.
	ClusterLogStatus *LogSyncStatus
	// Information about why the cluster was terminated. This field only appears
	// when the cluster is in a `TERMINATING` or `TERMINATED` state.
	TerminationReason *TerminationReason
	// The spec contains a snapshot of the latest user specified settings that were
	// used to create/edit the cluster. Note: not included in the response of the
	// ListClusters API.
	Spec *ClusterInfo_ComputeSpec
	// Node on which the Spark driver resides. The driver node contains the Spark
	// master and the <Databricks> application that manages the per-notebook Spark
	// REPLs.
	Driver *SparkInfo_SparkNode
	// Nodes on which the Spark executors reside.
	Executors []SparkInfo_SparkNode
	// A canonical SparkContext identifier. This value *does* change when the Spark
	// driver restarts. The pair `(cluster_id, spark_context_id)` is a globally
	// unique identifier over all Spark contexts.
	SparkContextId *int64
	// Port on which Spark JDBC server is listening, in the driver nod. No service
	// will be listeningon on this port in executor nodes.
	JdbcPort *int
	// Cluster name requested by the user. This doesn't have to be unique. If not
	// specified at creation, the cluster name will be an empty string. For job
	// clusters, the cluster name is automatically set based on the job and job run
	// IDs.
	ClusterName *string
	// The Spark version of the cluster, e.g. `3.3.x-scala2.11`. A list of available
	// Spark versions can be retrieved by using the [clusters/sparkVersions] API
	// call.
	//
	// [clusters/sparkVersions]: https://docs.databricks.com/api/workspace/clusters/sparkversions
	SparkVersion *string
	// An object containing a set of optional, user-specified Spark configuration
	// key-value pairs. Users can also pass in a string of extra JVM options to the
	// driver and the executors via `spark.driver.extraJavaOptions` and
	// `spark.executor.extraJavaOptions` respectively.
	SparkConf map[string]string
	// Attributes related to clusters running on Amazon Web Services. If not
	// specified at cluster creation, a set of default values will be used.
	AwsAttributes *AwsAttributes
	// Attributes related to clusters running on Microsoft Azure. If not specified
	// at cluster creation, a set of default values will be used.
	AzureAttributes *AzureAttributes
	// Attributes related to clusters running on Google Cloud Platform. If not
	// specified at cluster creation, a set of default values will be used.
	GcpAttributes *GcpAttributes
	// This field encodes, through a single value, the resources available to each
	// of the Spark nodes in this cluster. For example, the Spark nodes can be
	// provisioned and optimized for memory or compute intensive workloads. A list
	// of available node types can be retrieved by using the
	// [clusters/listNodeTypes] API call.
	//
	// [clusters/listNodeTypes]: https://docs.databricks.com/api/workspace/clusters/listnodetypes
	NodeTypeId *string
	// The node type of the Spark driver. Note that this field is optional; if
	// unset, the driver node type will be set as the same value as `node_type_id`
	// defined above.
	//
	// This field, along with node_type_id, should not be set if
	// virtual_cluster_size is set. If both driver_node_type_id, node_type_id, and
	// virtual_cluster_size are specified, driver_node_type_id and node_type_id take
	// precedence.
	DriverNodeTypeId *string
	// Flexible node type configuration for worker nodes.
	WorkerNodeTypeFlexibility *NodeTypeFlexibility
	// Flexible node type configuration for the driver node.
	DriverNodeTypeFlexibility *NodeTypeFlexibility
	// SSH public key contents that will be added to each Spark node in this
	// cluster. The corresponding private keys can be used to login with the user
	// name `ubuntu` on port `2200`. Up to 10 keys can be specified.
	SshPublicKeys []string
	// Additional tags for cluster resources. <Databricks> will tag all cluster
	// resources (e.g., AWS instances and EBS volumes) with these tags in addition
	// to `default_tags`. Notes:
	//
	// - Currently, <Databricks> allows at most 45 custom tags
	//
	// - Clusters can only reuse cloud resources if the resources' tags are a subset
	// of the cluster tags
	CustomTags map[string]string
	// The configuration for delivering spark logs to a long-term storage
	// destination. Three kinds of destinations (DBFS, S3 and Unity Catalog volumes)
	// are supported. Only one destination can be specified for one cluster. If the
	// conf is given, the logs will be delivered to the destination every `5 mins`.
	// The destination of driver logs is `$destination/$clusterId/driver`, while the
	// destination of executor logs is `$destination/$clusterId/executor`.
	ClusterLogConf *ClusterLogConf
	// An object containing a set of optional, user-specified environment variable
	// key-value pairs. Please note that key-value pair of the form (X,Y) will be
	// exported as is (i.e., `export X='Y'`) while launching the driver and workers.
	//
	// In order to specify an additional set of `SPARK_DAEMON_JAVA_OPTS`, we
	// recommend appending them to `$SPARK_DAEMON_JAVA_OPTS` as shown in the example
	// below. This ensures that all default databricks managed environmental
	// variables are included as well.
	//
	// Example Spark environment variables: `{"SPARK_WORKER_MEMORY": "28000m",
	// "SPARK_LOCAL_DIRS": "/local_disk0"}` or `{"SPARK_DAEMON_JAVA_OPTS":
	// "$SPARK_DAEMON_JAVA_OPTS -Dspark.shuffle.service.enabled=true"}`
	SparkEnvVars map[string]string
	// Automatically terminates the cluster after it is inactive for this time in
	// minutes. If not set, this cluster will not be automatically terminated. If
	// specified, the threshold must be between 10 and 10000 minutes. Users can also
	// set this value to 0 to explicitly disable automatic termination.
	AutoterminationMinutes *int
	// Autoscaling Local Storage: when enabled, this cluster will dynamically
	// acquire additional disk space when its Spark workers are running low on disk
	// space.
	EnableElasticDisk *bool
	// The configuration for storing init scripts. Any number of destinations can be
	// specified. The scripts are executed sequentially in the order provided. If
	// `cluster_log_conf` is specified, init script logs are sent to
	// `<destination>/<cluster-ID>/init_scripts`.
	InitScripts []InitScriptInfo
	// Custom docker image BYOC
	DockerImage *DockerImage
	// The optional ID of the instance pool to which the cluster belongs.
	InstancePoolId *string
	// Single user name if data_security_mode is `SINGLE_USER`
	SingleUserName *string
	// The ID of the cluster policy used to create the cluster if applicable.
	PolicyId *string
	// Whether to enable LUKS on cluster VMs' local disks
	EnableLocalDiskEncryption *bool
	// The optional ID of the instance pool for the driver of the cluster belongs.
	// The pool cluster uses the instance pool with id (instance_pool_id) if the
	// driver pool is not assigned.
	DriverInstancePoolId *string
	WorkloadType         *WorkloadType
	DataSecurityMode     DataSecurityMode
	// Determines the cluster's runtime engine, either standard or Photon.
	//
	// This field is not compatible with legacy `spark_version` values that contain
	// `-photon-`. Remove `-photon-` from the `spark_version` and set
	// `runtime_engine` to `PHOTON`.
	//
	// If left unspecified, the runtime engine defaults to standard unless the
	// spark_version contains -photon-, in which case Photon will be used.
	RuntimeEngine RuntimeEngine
	Kind          ComputeKind
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// `effective_spark_version` is determined by `spark_version` (DBR release),
	// this field `use_ml_runtime`, and whether `node_type_id` is gpu node or not.
	UseMlRuntime *bool
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// When set to true, <Databricks> will automatically set single node related
	// `custom_tags`, `spark_conf`, and `num_workers`
	IsSingleNode *bool
	// If set, what the configurable throughput (in Mb/s) for the remote disk is.
	// Currently only supported for GCP HYPERDISK_BALANCED disks.
	RemoteDiskThroughput *int
	// If set, what the total initial volume size (in GB) of the remote disks should
	// be. Supported for GCP.
	TotalInitialRemoteDiskSize *int
	// Controls dependency configuration for the cluster.
	DependencyMode DependencyMode
	// Time (in epoch milliseconds) when the cluster creation request was received
	// (when the cluster entered a `PENDING` state).
	StartTime *int64
	// Time (in epoch milliseconds) when the cluster was terminated, if applicable.
	TerminatedTime *int64
	// Time when the cluster driver last lost its state (due to a restart or driver
	// failure).
	LastStateLossTime *int64
	// the timestamp that the cluster was started/restarted
	LastRestartedTime *int64
	Size              isClusterInfo_Size
}

type ClusterInfo_ComputeSpec struct {
	// When set to true, fixed and default values from the policy will be used for
	// fields that are omitted. When set to false, only fixed values from the policy
	// will be applied.
	ApplyPolicyDefaultValues *bool
	// Cluster name requested by the user. This doesn't have to be unique. If not
	// specified at creation, the cluster name will be an empty string. For job
	// clusters, the cluster name is automatically set based on the job and job run
	// IDs.
	ClusterName *string
	// The Spark version of the cluster, e.g. `3.3.x-scala2.11`. A list of available
	// Spark versions can be retrieved by using the [clusters/sparkVersions] API
	// call.
	//
	// [clusters/sparkVersions]: https://docs.databricks.com/api/workspace/clusters/sparkversions
	SparkVersion *string
	// An object containing a set of optional, user-specified Spark configuration
	// key-value pairs. Users can also pass in a string of extra JVM options to the
	// driver and the executors via `spark.driver.extraJavaOptions` and
	// `spark.executor.extraJavaOptions` respectively.
	SparkConf map[string]string
	// Attributes related to clusters running on Amazon Web Services. If not
	// specified at cluster creation, a set of default values will be used.
	AwsAttributes *AwsAttributes
	// Attributes related to clusters running on Microsoft Azure. If not specified
	// at cluster creation, a set of default values will be used.
	AzureAttributes *AzureAttributes
	// Attributes related to clusters running on Google Cloud Platform. If not
	// specified at cluster creation, a set of default values will be used.
	GcpAttributes *GcpAttributes
	// This field encodes, through a single value, the resources available to each
	// of the Spark nodes in this cluster. For example, the Spark nodes can be
	// provisioned and optimized for memory or compute intensive workloads. A list
	// of available node types can be retrieved by using the
	// [clusters/listNodeTypes] API call.
	//
	// [clusters/listNodeTypes]: https://docs.databricks.com/api/workspace/clusters/listnodetypes
	NodeTypeId *string
	// The node type of the Spark driver. Note that this field is optional; if
	// unset, the driver node type will be set as the same value as `node_type_id`
	// defined above.
	//
	// This field, along with node_type_id, should not be set if
	// virtual_cluster_size is set. If both driver_node_type_id, node_type_id, and
	// virtual_cluster_size are specified, driver_node_type_id and node_type_id take
	// precedence.
	DriverNodeTypeId *string
	// Flexible node type configuration for worker nodes.
	WorkerNodeTypeFlexibility *NodeTypeFlexibility
	// Flexible node type configuration for the driver node.
	DriverNodeTypeFlexibility *NodeTypeFlexibility
	// SSH public key contents that will be added to each Spark node in this
	// cluster. The corresponding private keys can be used to login with the user
	// name `ubuntu` on port `2200`. Up to 10 keys can be specified.
	SshPublicKeys []string
	// Additional tags for cluster resources. <Databricks> will tag all cluster
	// resources (e.g., AWS instances and EBS volumes) with these tags in addition
	// to `default_tags`. Notes:
	//
	// - Currently, <Databricks> allows at most 45 custom tags
	//
	// - Clusters can only reuse cloud resources if the resources' tags are a subset
	// of the cluster tags
	CustomTags map[string]string
	// The configuration for delivering spark logs to a long-term storage
	// destination. Three kinds of destinations (DBFS, S3 and Unity Catalog volumes)
	// are supported. Only one destination can be specified for one cluster. If the
	// conf is given, the logs will be delivered to the destination every `5 mins`.
	// The destination of driver logs is `$destination/$clusterId/driver`, while the
	// destination of executor logs is `$destination/$clusterId/executor`.
	ClusterLogConf *ClusterLogConf
	// An object containing a set of optional, user-specified environment variable
	// key-value pairs. Please note that key-value pair of the form (X,Y) will be
	// exported as is (i.e., `export X='Y'`) while launching the driver and workers.
	//
	// In order to specify an additional set of `SPARK_DAEMON_JAVA_OPTS`, we
	// recommend appending them to `$SPARK_DAEMON_JAVA_OPTS` as shown in the example
	// below. This ensures that all default databricks managed environmental
	// variables are included as well.
	//
	// Example Spark environment variables: `{"SPARK_WORKER_MEMORY": "28000m",
	// "SPARK_LOCAL_DIRS": "/local_disk0"}` or `{"SPARK_DAEMON_JAVA_OPTS":
	// "$SPARK_DAEMON_JAVA_OPTS -Dspark.shuffle.service.enabled=true"}`
	SparkEnvVars map[string]string
	// Automatically terminates the cluster after it is inactive for this time in
	// minutes. If not set, this cluster will not be automatically terminated. If
	// specified, the threshold must be between 10 and 10000 minutes. Users can also
	// set this value to 0 to explicitly disable automatic termination.
	AutoterminationMinutes *int
	// Autoscaling Local Storage: when enabled, this cluster will dynamically
	// acquire additional disk space when its Spark workers are running low on disk
	// space.
	EnableElasticDisk *bool
	// The configuration for storing init scripts. Any number of destinations can be
	// specified. The scripts are executed sequentially in the order provided. If
	// `cluster_log_conf` is specified, init script logs are sent to
	// `<destination>/<cluster-ID>/init_scripts`.
	InitScripts []InitScriptInfo
	// Custom docker image BYOC
	DockerImage *DockerImage
	// The optional ID of the instance pool to which the cluster belongs.
	InstancePoolId *string
	// Single user name if data_security_mode is `SINGLE_USER`
	SingleUserName *string
	// The ID of the cluster policy used to create the cluster if applicable.
	PolicyId *string
	// Whether to enable LUKS on cluster VMs' local disks
	EnableLocalDiskEncryption *bool
	// The optional ID of the instance pool for the driver of the cluster belongs.
	// The pool cluster uses the instance pool with id (instance_pool_id) if the
	// driver pool is not assigned.
	DriverInstancePoolId *string
	WorkloadType         *WorkloadType
	DataSecurityMode     DataSecurityMode
	// Determines the cluster's runtime engine, either standard or Photon.
	//
	// This field is not compatible with legacy `spark_version` values that contain
	// `-photon-`. Remove `-photon-` from the `spark_version` and set
	// `runtime_engine` to `PHOTON`.
	//
	// If left unspecified, the runtime engine defaults to standard unless the
	// spark_version contains -photon-, in which case Photon will be used.
	RuntimeEngine RuntimeEngine
	Kind          ComputeKind
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// `effective_spark_version` is determined by `spark_version` (DBR release),
	// this field `use_ml_runtime`, and whether `node_type_id` is gpu node or not.
	UseMlRuntime *bool
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// When set to true, <Databricks> will automatically set single node related
	// `custom_tags`, `spark_conf`, and `num_workers`
	IsSingleNode *bool
	// If set, what the configurable throughput (in Mb/s) for the remote disk is.
	// Currently only supported for GCP HYPERDISK_BALANCED disks.
	RemoteDiskThroughput *int
	// If set, what the total initial volume size (in GB) of the remote disks should
	// be. Supported for GCP.
	TotalInitialRemoteDiskSize *int
	// Controls dependency configuration for the cluster.
	DependencyMode DependencyMode
	Size           isClusterInfo_ComputeSpec_Size
}

type ClusterInfo_ComputeSpec_Size_Autoscale struct {
	Autoscale AutoScale
}

type ClusterInfo_ComputeSpec_Size_NumWorkers struct {
	NumWorkers int
}

type ClusterInfo_Size_Autoscale struct {
	Autoscale AutoScale
}

type ClusterInfo_Size_NumWorkers struct {
	NumWorkers int
}

type ClusterLogConf struct {
	StorageInfo isClusterLogConf_StorageInfo
	// contains filtered or unexported fields
}

type ClusterLogConf_StorageInfo_Dbfs struct {
	Dbfs DbfsStorageInfo `fieldmask:"dbfs"`
}

type ClusterLogConf_StorageInfo_S3 struct {
	S3 S3StorageInfo `fieldmask:"s3"`
}

type ClusterLogConf_StorageInfo_Volumes struct {
	Volumes VolumesStorageInfo `fieldmask:"volumes"`
}

type ClusterSize struct {
	Size isClusterSize_Size
}

type ClusterSize_Size_Autoscale struct {
	Autoscale AutoScale
}

type ClusterSize_Size_NumWorkers struct {
	NumWorkers int
}

type ClusterState struct {
}

type ClusterState_ClusterState string

type ComputeKind string

type ConfidentialComputeType string

type CreateClusterRequest struct {
	// When set to true, fixed and default values from the policy will be used for
	// fields that are omitted. When set to false, only fixed values from the policy
	// will be applied.
	ApplyPolicyDefaultValues *bool
	// When specified, this clones libraries from a source cluster during the
	// creation of a new cluster.
	CloneFrom *CloneCluster
	Size      isCreateClusterRequest_Size
	// Cluster name requested by the user. This doesn't have to be unique. If not
	// specified at creation, the cluster name will be an empty string. For job
	// clusters, the cluster name is automatically set based on the job and job run
	// IDs.
	ClusterName *string
	// The Spark version of the cluster, e.g. `3.3.x-scala2.11`. A list of available
	// Spark versions can be retrieved by using the [clusters/sparkVersions] API
	// call.
	//
	// [clusters/sparkVersions]: https://docs.databricks.com/api/workspace/clusters/sparkversions
	SparkVersion *string
	// An object containing a set of optional, user-specified Spark configuration
	// key-value pairs. Users can also pass in a string of extra JVM options to the
	// driver and the executors via `spark.driver.extraJavaOptions` and
	// `spark.executor.extraJavaOptions` respectively.
	SparkConf map[string]string
	// Attributes related to clusters running on Amazon Web Services. If not
	// specified at cluster creation, a set of default values will be used.
	AwsAttributes *AwsAttributes
	// Attributes related to clusters running on Microsoft Azure. If not specified
	// at cluster creation, a set of default values will be used.
	AzureAttributes *AzureAttributes
	// Attributes related to clusters running on Google Cloud Platform. If not
	// specified at cluster creation, a set of default values will be used.
	GcpAttributes *GcpAttributes
	// This field encodes, through a single value, the resources available to each
	// of the Spark nodes in this cluster. For example, the Spark nodes can be
	// provisioned and optimized for memory or compute intensive workloads. A list
	// of available node types can be retrieved by using the
	// [clusters/listNodeTypes] API call.
	//
	// [clusters/listNodeTypes]: https://docs.databricks.com/api/workspace/clusters/listnodetypes
	NodeTypeId *string
	// The node type of the Spark driver. Note that this field is optional; if
	// unset, the driver node type will be set as the same value as `node_type_id`
	// defined above.
	//
	// This field, along with node_type_id, should not be set if
	// virtual_cluster_size is set. If both driver_node_type_id, node_type_id, and
	// virtual_cluster_size are specified, driver_node_type_id and node_type_id take
	// precedence.
	DriverNodeTypeId *string
	// Flexible node type configuration for worker nodes.
	WorkerNodeTypeFlexibility *NodeTypeFlexibility
	// Flexible node type configuration for the driver node.
	DriverNodeTypeFlexibility *NodeTypeFlexibility
	// SSH public key contents that will be added to each Spark node in this
	// cluster. The corresponding private keys can be used to login with the user
	// name `ubuntu` on port `2200`. Up to 10 keys can be specified.
	SshPublicKeys []string
	// Additional tags for cluster resources. <Databricks> will tag all cluster
	// resources (e.g., AWS instances and EBS volumes) with these tags in addition
	// to `default_tags`. Notes:
	//
	// - Currently, <Databricks> allows at most 45 custom tags
	//
	// - Clusters can only reuse cloud resources if the resources' tags are a subset
	// of the cluster tags
	CustomTags map[string]string
	// The configuration for delivering spark logs to a long-term storage
	// destination. Three kinds of destinations (DBFS, S3 and Unity Catalog volumes)
	// are supported. Only one destination can be specified for one cluster. If the
	// conf is given, the logs will be delivered to the destination every `5 mins`.
	// The destination of driver logs is `$destination/$clusterId/driver`, while the
	// destination of executor logs is `$destination/$clusterId/executor`.
	ClusterLogConf *ClusterLogConf
	// An object containing a set of optional, user-specified environment variable
	// key-value pairs. Please note that key-value pair of the form (X,Y) will be
	// exported as is (i.e., `export X='Y'`) while launching the driver and workers.
	//
	// In order to specify an additional set of `SPARK_DAEMON_JAVA_OPTS`, we
	// recommend appending them to `$SPARK_DAEMON_JAVA_OPTS` as shown in the example
	// below. This ensures that all default databricks managed environmental
	// variables are included as well.
	//
	// Example Spark environment variables: `{"SPARK_WORKER_MEMORY": "28000m",
	// "SPARK_LOCAL_DIRS": "/local_disk0"}` or `{"SPARK_DAEMON_JAVA_OPTS":
	// "$SPARK_DAEMON_JAVA_OPTS -Dspark.shuffle.service.enabled=true"}`
	SparkEnvVars map[string]string
	// Automatically terminates the cluster after it is inactive for this time in
	// minutes. If not set, this cluster will not be automatically terminated. If
	// specified, the threshold must be between 10 and 10000 minutes. Users can also
	// set this value to 0 to explicitly disable automatic termination.
	AutoterminationMinutes *int
	// Autoscaling Local Storage: when enabled, this cluster will dynamically
	// acquire additional disk space when its Spark workers are running low on disk
	// space.
	EnableElasticDisk *bool
	// The configuration for storing init scripts. Any number of destinations can be
	// specified. The scripts are executed sequentially in the order provided. If
	// `cluster_log_conf` is specified, init script logs are sent to
	// `<destination>/<cluster-ID>/init_scripts`.
	InitScripts []InitScriptInfo
	// Custom docker image BYOC
	DockerImage *DockerImage
	// The optional ID of the instance pool to which the cluster belongs.
	InstancePoolId *string
	// Single user name if data_security_mode is `SINGLE_USER`
	SingleUserName *string
	// The ID of the cluster policy used to create the cluster if applicable.
	PolicyId *string
	// Whether to enable LUKS on cluster VMs' local disks
	EnableLocalDiskEncryption *bool
	// The optional ID of the instance pool for the driver of the cluster belongs.
	// The pool cluster uses the instance pool with id (instance_pool_id) if the
	// driver pool is not assigned.
	DriverInstancePoolId *string
	WorkloadType         *WorkloadType
	DataSecurityMode     DataSecurityMode
	// Determines the cluster's runtime engine, either standard or Photon.
	//
	// This field is not compatible with legacy `spark_version` values that contain
	// `-photon-`. Remove `-photon-` from the `spark_version` and set
	// `runtime_engine` to `PHOTON`.
	//
	// If left unspecified, the runtime engine defaults to standard unless the
	// spark_version contains -photon-, in which case Photon will be used.
	RuntimeEngine RuntimeEngine
	Kind          ComputeKind
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// `effective_spark_version` is determined by `spark_version` (DBR release),
	// this field `use_ml_runtime`, and whether `node_type_id` is gpu node or not.
	UseMlRuntime *bool
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// When set to true, <Databricks> will automatically set single node related
	// `custom_tags`, `spark_conf`, and `num_workers`
	IsSingleNode *bool
	// If set, what the configurable throughput (in Mb/s) for the remote disk is.
	// Currently only supported for GCP HYPERDISK_BALANCED disks.
	RemoteDiskThroughput *int
	// If set, what the total initial volume size (in GB) of the remote disks should
	// be. Supported for GCP.
	TotalInitialRemoteDiskSize *int
	// Controls dependency configuration for the cluster.
	DependencyMode DependencyMode
}

type CreateClusterRequest_Size_Autoscale struct {
	Autoscale AutoScale
}

type CreateClusterRequest_Size_NumWorkers struct {
	NumWorkers int
}

type CreateClusterResponse struct {
	ClusterId *string
}

type CreateClusterWaiter struct {
	// contains filtered or unexported fields
}

type DataPlaneClusterEventType string

type DataPlaneEventDetails struct {
	EventType        DataPlaneClusterEventType
	Timestamp        *int64
	HostId           *string
	ExecutorFailures *int
}

type DataSecurityMode string

type DbfsStorageInfo struct {
	// dbfs destination, e.g. `dbfs:/my/path`
	Destination *string `fieldmask:"destination"`
}

type DeleteClusterRequest struct {
	// The cluster to be terminated.
	ClusterId *string
}

type DeleteClusterResponse struct {
}

type DeleteClusterWaiter struct {
	// contains filtered or unexported fields
}

type DependencyMode string

type DockerBasicAuth struct {
	// Name of the user
	Username *string `fieldmask:"username"`
	// Password of the user
	Password *string `fieldmask:"password"`
}

type DockerImage struct {
	// URL of the docker image.
	Url        *string `fieldmask:"url"`
	CredsOneof isDockerImage_CredsOneof
	// contains filtered or unexported fields
}

type DockerImage_CredsOneof_BasicAuth struct {
	BasicAuth DockerBasicAuth `fieldmask:"basic_auth"`
}

type EbsVolumeType string

type EditClusterRequest struct {
	// ID of the cluster
	ClusterId *string
	// When set to true, fixed and default values from the policy will be used for
	// fields that are omitted. When set to false, only fixed values from the policy
	// will be applied.
	ApplyPolicyDefaultValues *bool
	Size                     isEditClusterRequest_Size
	// Cluster name requested by the user. This doesn't have to be unique. If not
	// specified at creation, the cluster name will be an empty string. For job
	// clusters, the cluster name is automatically set based on the job and job run
	// IDs.
	ClusterName *string
	// The Spark version of the cluster, e.g. `3.3.x-scala2.11`. A list of available
	// Spark versions can be retrieved by using the [clusters/sparkVersions] API
	// call.
	//
	// [clusters/sparkVersions]: https://docs.databricks.com/api/workspace/clusters/sparkversions
	SparkVersion *string
	// An object containing a set of optional, user-specified Spark configuration
	// key-value pairs. Users can also pass in a string of extra JVM options to the
	// driver and the executors via `spark.driver.extraJavaOptions` and
	// `spark.executor.extraJavaOptions` respectively.
	SparkConf map[string]string
	// Attributes related to clusters running on Amazon Web Services. If not
	// specified at cluster creation, a set of default values will be used.
	AwsAttributes *AwsAttributes
	// Attributes related to clusters running on Microsoft Azure. If not specified
	// at cluster creation, a set of default values will be used.
	AzureAttributes *AzureAttributes
	// Attributes related to clusters running on Google Cloud Platform. If not
	// specified at cluster creation, a set of default values will be used.
	GcpAttributes *GcpAttributes
	// This field encodes, through a single value, the resources available to each
	// of the Spark nodes in this cluster. For example, the Spark nodes can be
	// provisioned and optimized for memory or compute intensive workloads. A list
	// of available node types can be retrieved by using the
	// [clusters/listNodeTypes] API call.
	//
	// [clusters/listNodeTypes]: https://docs.databricks.com/api/workspace/clusters/listnodetypes
	NodeTypeId *string
	// The node type of the Spark driver. Note that this field is optional; if
	// unset, the driver node type will be set as the same value as `node_type_id`
	// defined above.
	//
	// This field, along with node_type_id, should not be set if
	// virtual_cluster_size is set. If both driver_node_type_id, node_type_id, and
	// virtual_cluster_size are specified, driver_node_type_id and node_type_id take
	// precedence.
	DriverNodeTypeId *string
	// Flexible node type configuration for worker nodes.
	WorkerNodeTypeFlexibility *NodeTypeFlexibility
	// Flexible node type configuration for the driver node.
	DriverNodeTypeFlexibility *NodeTypeFlexibility
	// SSH public key contents that will be added to each Spark node in this
	// cluster. The corresponding private keys can be used to login with the user
	// name `ubuntu` on port `2200`. Up to 10 keys can be specified.
	SshPublicKeys []string
	// Additional tags for cluster resources. <Databricks> will tag all cluster
	// resources (e.g., AWS instances and EBS volumes) with these tags in addition
	// to `default_tags`. Notes:
	//
	// - Currently, <Databricks> allows at most 45 custom tags
	//
	// - Clusters can only reuse cloud resources if the resources' tags are a subset
	// of the cluster tags
	CustomTags map[string]string
	// The configuration for delivering spark logs to a long-term storage
	// destination. Three kinds of destinations (DBFS, S3 and Unity Catalog volumes)
	// are supported. Only one destination can be specified for one cluster. If the
	// conf is given, the logs will be delivered to the destination every `5 mins`.
	// The destination of driver logs is `$destination/$clusterId/driver`, while the
	// destination of executor logs is `$destination/$clusterId/executor`.
	ClusterLogConf *ClusterLogConf
	// An object containing a set of optional, user-specified environment variable
	// key-value pairs. Please note that key-value pair of the form (X,Y) will be
	// exported as is (i.e., `export X='Y'`) while launching the driver and workers.
	//
	// In order to specify an additional set of `SPARK_DAEMON_JAVA_OPTS`, we
	// recommend appending them to `$SPARK_DAEMON_JAVA_OPTS` as shown in the example
	// below. This ensures that all default databricks managed environmental
	// variables are included as well.
	//
	// Example Spark environment variables: `{"SPARK_WORKER_MEMORY": "28000m",
	// "SPARK_LOCAL_DIRS": "/local_disk0"}` or `{"SPARK_DAEMON_JAVA_OPTS":
	// "$SPARK_DAEMON_JAVA_OPTS -Dspark.shuffle.service.enabled=true"}`
	SparkEnvVars map[string]string
	// Automatically terminates the cluster after it is inactive for this time in
	// minutes. If not set, this cluster will not be automatically terminated. If
	// specified, the threshold must be between 10 and 10000 minutes. Users can also
	// set this value to 0 to explicitly disable automatic termination.
	AutoterminationMinutes *int
	// Autoscaling Local Storage: when enabled, this cluster will dynamically
	// acquire additional disk space when its Spark workers are running low on disk
	// space.
	EnableElasticDisk *bool
	// The configuration for storing init scripts. Any number of destinations can be
	// specified. The scripts are executed sequentially in the order provided. If
	// `cluster_log_conf` is specified, init script logs are sent to
	// `<destination>/<cluster-ID>/init_scripts`.
	InitScripts []InitScriptInfo
	// Custom docker image BYOC
	DockerImage *DockerImage
	// The optional ID of the instance pool to which the cluster belongs.
	InstancePoolId *string
	// Single user name if data_security_mode is `SINGLE_USER`
	SingleUserName *string
	// The ID of the cluster policy used to create the cluster if applicable.
	PolicyId *string
	// Whether to enable LUKS on cluster VMs' local disks
	EnableLocalDiskEncryption *bool
	// The optional ID of the instance pool for the driver of the cluster belongs.
	// The pool cluster uses the instance pool with id (instance_pool_id) if the
	// driver pool is not assigned.
	DriverInstancePoolId *string
	WorkloadType         *WorkloadType
	DataSecurityMode     DataSecurityMode
	// Determines the cluster's runtime engine, either standard or Photon.
	//
	// This field is not compatible with legacy `spark_version` values that contain
	// `-photon-`. Remove `-photon-` from the `spark_version` and set
	// `runtime_engine` to `PHOTON`.
	//
	// If left unspecified, the runtime engine defaults to standard unless the
	// spark_version contains -photon-, in which case Photon will be used.
	RuntimeEngine RuntimeEngine
	Kind          ComputeKind
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// `effective_spark_version` is determined by `spark_version` (DBR release),
	// this field `use_ml_runtime`, and whether `node_type_id` is gpu node or not.
	UseMlRuntime *bool
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// When set to true, <Databricks> will automatically set single node related
	// `custom_tags`, `spark_conf`, and `num_workers`
	IsSingleNode *bool
	// If set, what the configurable throughput (in Mb/s) for the remote disk is.
	// Currently only supported for GCP HYPERDISK_BALANCED disks.
	RemoteDiskThroughput *int
	// If set, what the total initial volume size (in GB) of the remote disks should
	// be. Supported for GCP.
	TotalInitialRemoteDiskSize *int
	// Controls dependency configuration for the cluster.
	DependencyMode DependencyMode
}

type EditClusterRequest_Size_Autoscale struct {
	Autoscale AutoScale
}

type EditClusterRequest_Size_NumWorkers struct {
	NumWorkers int
}

type EditClusterResponse struct {
}

type EditClusterWaiter struct {
	// contains filtered or unexported fields
}

type EnforcePolicyComplianceForClusterRequest struct {
	// The ID of the cluster you want to enforce policy compliance on.
	ClusterId *string
	// If set, previews the changes that would be made to a cluster to enforce
	// compliance but does not update the cluster.
	ValidateOnly *bool
	// Determines how changes should be made to clusters that are not in
	// `TERMINATED` state.
	//
	// - `ENFORCE_IMMEDIATELY`: If the cluster is in a `RUNNING` state, it will be
	// restarted so that the new attributes can take effect. For other states aside
	// from `TERMINATED` state, the request will be rejected. -
	// `WAIT_FOR_TERMINATION`: The cluster is not immediately edited. Instead, a
	// pending enforcement is scheduled to update the cluster when it terminates or
	// restarts. When this occurs, `enforce_result` will contain `DEFERRED`. Only
	// workspace admins can use this mode.
	//
	// Regardless of the enforce mode, clusters in `TERMINATED` state are
	// immediately edited.
	EnforceMode EnforcePolicyComplianceForClusterRequest_EnforceMode
}

type EnforcePolicyComplianceForClusterRequest_EnforceMode string

type EnforcePolicyComplianceForClusterResponse struct {
	// Whether any changes have been made to the cluster settings for the cluster to
	// become compliant with its policy.
	HasChanges *bool
	// A list of changes that have been made to the cluster settings for the cluster
	// to become compliant with its policy.
	Changes []EnforcePolicyComplianceForClusterResponse_ClusterSettingsChange
	// Describes whether changes have been applied to the cluster.
	EnforceResult EnforcePolicyComplianceForClusterResponse_EnforceResult
}

type EnforcePolicyComplianceForClusterResponse_ClusterSettings struct {
	// Cluster name requested by the user. This doesn't have to be unique. If not
	// specified at creation, the cluster name will be an empty string. For job
	// clusters, the cluster name is automatically set based on the job and job run
	// IDs.
	ClusterName *string
	// The Spark version of the cluster, e.g. `3.3.x-scala2.11`. A list of available
	// Spark versions can be retrieved by using the [clusters/sparkVersions] API
	// call.
	//
	// [clusters/sparkVersions]: https://docs.databricks.com/api/workspace/clusters/sparkversions
	SparkVersion *string
	// An object containing a set of optional, user-specified Spark configuration
	// key-value pairs. Users can also pass in a string of extra JVM options to the
	// driver and the executors via `spark.driver.extraJavaOptions` and
	// `spark.executor.extraJavaOptions` respectively.
	SparkConf map[string]string
	// Attributes related to clusters running on Amazon Web Services. If not
	// specified at cluster creation, a set of default values will be used.
	AwsAttributes *AwsAttributes
	// Attributes related to clusters running on Microsoft Azure. If not specified
	// at cluster creation, a set of default values will be used.
	AzureAttributes *AzureAttributes
	// Attributes related to clusters running on Google Cloud Platform. If not
	// specified at cluster creation, a set of default values will be used.
	GcpAttributes *GcpAttributes
	// This field encodes, through a single value, the resources available to each
	// of the Spark nodes in this cluster. For example, the Spark nodes can be
	// provisioned and optimized for memory or compute intensive workloads. A list
	// of available node types can be retrieved by using the
	// [clusters/listNodeTypes] API call.
	//
	// [clusters/listNodeTypes]: https://docs.databricks.com/api/workspace/clusters/listnodetypes
	NodeTypeId *string
	// The node type of the Spark driver. Note that this field is optional; if
	// unset, the driver node type will be set as the same value as `node_type_id`
	// defined above.
	//
	// This field, along with node_type_id, should not be set if
	// virtual_cluster_size is set. If both driver_node_type_id, node_type_id, and
	// virtual_cluster_size are specified, driver_node_type_id and node_type_id take
	// precedence.
	DriverNodeTypeId *string
	// Flexible node type configuration for worker nodes.
	WorkerNodeTypeFlexibility *NodeTypeFlexibility
	// Flexible node type configuration for the driver node.
	DriverNodeTypeFlexibility *NodeTypeFlexibility
	// SSH public key contents that will be added to each Spark node in this
	// cluster. The corresponding private keys can be used to login with the user
	// name `ubuntu` on port `2200`. Up to 10 keys can be specified.
	SshPublicKeys []string
	// Additional tags for cluster resources. <Databricks> will tag all cluster
	// resources (e.g., AWS instances and EBS volumes) with these tags in addition
	// to `default_tags`. Notes:
	//
	// - Currently, <Databricks> allows at most 45 custom tags
	//
	// - Clusters can only reuse cloud resources if the resources' tags are a subset
	// of the cluster tags
	CustomTags map[string]string
	// The configuration for delivering spark logs to a long-term storage
	// destination. Three kinds of destinations (DBFS, S3 and Unity Catalog volumes)
	// are supported. Only one destination can be specified for one cluster. If the
	// conf is given, the logs will be delivered to the destination every `5 mins`.
	// The destination of driver logs is `$destination/$clusterId/driver`, while the
	// destination of executor logs is `$destination/$clusterId/executor`.
	ClusterLogConf *ClusterLogConf
	// An object containing a set of optional, user-specified environment variable
	// key-value pairs. Please note that key-value pair of the form (X,Y) will be
	// exported as is (i.e., `export X='Y'`) while launching the driver and workers.
	//
	// In order to specify an additional set of `SPARK_DAEMON_JAVA_OPTS`, we
	// recommend appending them to `$SPARK_DAEMON_JAVA_OPTS` as shown in the example
	// below. This ensures that all default databricks managed environmental
	// variables are included as well.
	//
	// Example Spark environment variables: `{"SPARK_WORKER_MEMORY": "28000m",
	// "SPARK_LOCAL_DIRS": "/local_disk0"}` or `{"SPARK_DAEMON_JAVA_OPTS":
	// "$SPARK_DAEMON_JAVA_OPTS -Dspark.shuffle.service.enabled=true"}`
	SparkEnvVars map[string]string
	// Automatically terminates the cluster after it is inactive for this time in
	// minutes. If not set, this cluster will not be automatically terminated. If
	// specified, the threshold must be between 10 and 10000 minutes. Users can also
	// set this value to 0 to explicitly disable automatic termination.
	AutoterminationMinutes *int
	// Autoscaling Local Storage: when enabled, this cluster will dynamically
	// acquire additional disk space when its Spark workers are running low on disk
	// space.
	EnableElasticDisk *bool
	// The configuration for storing init scripts. Any number of destinations can be
	// specified. The scripts are executed sequentially in the order provided. If
	// `cluster_log_conf` is specified, init script logs are sent to
	// `<destination>/<cluster-ID>/init_scripts`.
	InitScripts []InitScriptInfo
	// Custom docker image BYOC
	DockerImage *DockerImage
	// The optional ID of the instance pool to which the cluster belongs.
	InstancePoolId *string
	// Single user name if data_security_mode is `SINGLE_USER`
	SingleUserName *string
	// The ID of the cluster policy used to create the cluster if applicable.
	PolicyId *string
	// Whether to enable LUKS on cluster VMs' local disks
	EnableLocalDiskEncryption *bool
	// The optional ID of the instance pool for the driver of the cluster belongs.
	// The pool cluster uses the instance pool with id (instance_pool_id) if the
	// driver pool is not assigned.
	DriverInstancePoolId *string
	WorkloadType         *WorkloadType
	DataSecurityMode     DataSecurityMode
	// Determines the cluster's runtime engine, either standard or Photon.
	//
	// This field is not compatible with legacy `spark_version` values that contain
	// `-photon-`. Remove `-photon-` from the `spark_version` and set
	// `runtime_engine` to `PHOTON`.
	//
	// If left unspecified, the runtime engine defaults to standard unless the
	// spark_version contains -photon-, in which case Photon will be used.
	RuntimeEngine RuntimeEngine
	Kind          ComputeKind
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// `effective_spark_version` is determined by `spark_version` (DBR release),
	// this field `use_ml_runtime`, and whether `node_type_id` is gpu node or not.
	UseMlRuntime *bool
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// When set to true, <Databricks> will automatically set single node related
	// `custom_tags`, `spark_conf`, and `num_workers`
	IsSingleNode *bool
	// If set, what the configurable throughput (in Mb/s) for the remote disk is.
	// Currently only supported for GCP HYPERDISK_BALANCED disks.
	RemoteDiskThroughput *int
	// If set, what the total initial volume size (in GB) of the remote disks should
	// be. Supported for GCP.
	TotalInitialRemoteDiskSize *int
	// Controls dependency configuration for the cluster.
	DependencyMode DependencyMode
	Size           isEnforcePolicyComplianceForClusterResponse_ClusterSettings_Size
}

type EnforcePolicyComplianceForClusterResponse_ClusterSettingsChange struct {
	// The field where this change would be made.
	Field *string
	// The previous value of this field before enforcing policy compliance (either a
	// number, a boolean, or a string) converted to a string. This is intended to be
	// read by a human. The type of the field can be retrieved by reading the
	// settings field in the API response.
	PreviousValue *string
	// The new value of this field after enforcing policy compliance (either a
	// number, a boolean, or a string) converted to a string. This is intended to be
	// read by a human. The typed new value of this field can be retrieved by
	// reading the settings field in the API response.
	NewValue *string
}

type EnforcePolicyComplianceForClusterResponse_ClusterSettings_Size_Autoscale struct {
	Autoscale AutoScale
}

type EnforcePolicyComplianceForClusterResponse_ClusterSettings_Size_NumWorkers struct {
	NumWorkers int
}

type EnforcePolicyComplianceForClusterResponse_EnforceResult string

type EventDetails struct {
	// The current number of nodes in the cluster.
	CurrentNumWorkers *int
	// The targeted number of nodes in the cluster.
	TargetNumWorkers *int
	// The cluster attributes before a cluster was edited.
	PreviousAttributes *ClusterAttributes
	// * For created clusters, the attributes of the cluster. * For edited clusters,
	// the new attributes of the cluster.
	Attributes *ClusterAttributes
	// The size of the cluster before an edit or resize.
	PreviousClusterSize *ClusterSize
	// The actual cluster size that was set in the cluster creation or edit.
	ClusterSize *ClusterSize
	// The cause of a change in target size.
	Cause ResizeCause_ResizeCause
	// A termination reason: * On a TERMINATED event, this is the reason of the
	// termination. * On a RESIZE_COMPLETE event, this indicates the reason that we
	// failed to acquire some nodes.
	Reason *TerminationReason
	// The user that caused the event to occur. (Empty if it was done by the control
	// plane.)
	User *string
	// Previous disk size in bytes
	PreviousDiskSize *int64
	// Current disk size in bytes
	DiskSize  *int64
	FreeSpace *int64
	// Instance Id where the event originated from
	InstanceId         *string
	DidNotExpandReason *string
	// More details about the change in driver's state
	DriverStateMessage *string
	// Unique identifier of the specific job run associated with this cluster event
	// * For clusters created for jobs, this will be the same as the cluster name
	JobRunName *string
	// List of global and cluster init scripts associated with this cluster event.
	InitScripts *InitScriptEventDetails
	// Whether or not a blocklisted node should be terminated. For ClusterEventType
	// NODE_BLACKLISTED.
	EnableTerminationForNodeBlocklisted *bool
	// The current number of vCPUs in the cluster.
	CurrentNumVcpus *int
	// The targeted number of vCPUs in the cluster.
	TargetNumVcpus *int
}

type GcpAttributes struct {
	// This field determines whether the spark executors will be scheduled to run on
	// preemptible VMs (when set to true) versus standard compute engine VMs (when
	// set to false; default). Note: Soon to be deprecated, use the 'availability'
	// field instead.
	UsePreemptibleExecutors *bool `fieldmask:"use_preemptible_executors"`
	// If provided, the cluster will impersonate the google service account when
	// accessing gcloud services (like GCS). The google service account must have
	// previously been added to the <Databricks> environment by an account
	// administrator.
	GoogleServiceAccount *string `fieldmask:"google_service_account"`
	// Boot disk size in GB
	BootDiskSize *int `fieldmask:"boot_disk_size"`
	// This field determines whether the spark executors will be scheduled to run on
	// preemptible VMs, on-demand VMs, or preemptible VMs with a fallback to
	// on-demand VMs if the former is unavailable.
	Availability GcpAvailability `fieldmask:"availability"`
	// Identifier for the availability zone in which the cluster resides. This can
	// be one of the following: - "HA" => High availability, spread nodes across
	// availability zones for a <Databricks> deployment region [default]. - "AUTO"
	// => <Databricks> picks an availability zone to schedule the cluster on. - A
	// GCP availability zone => Pick One of the available zones for (machine type +
	// region) from https://cloud.google.com/compute/docs/regions-zones.
	ZoneId *string `fieldmask:"zone_id"`
	// If provided, each node (workers and driver) in the cluster will have this
	// number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP
	// documentation] for the supported number of local SSDs for each instance type.
	//
	// [GCP documentation]: https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds
	LocalSsdCount *int `fieldmask:"local_ssd_count"`
	// The first `first_on_demand` nodes of the cluster will be placed on on-demand
	// instances. This value should be greater than 0, to make sure the cluster
	// driver node is placed on an on-demand instance. If this value is greater than
	// or equal to the current cluster size, all nodes will be placed on on-demand
	// instances. If this value is less than the current cluster size,
	// `first_on_demand` nodes will be placed on on-demand instances and the
	// remainder will be placed on `availability` instances. Note that this value
	// does not affect cluster size and cannot currently be mutated over the
	// lifetime of a cluster.
	FirstOnDemand *int `fieldmask:"first_on_demand"`
	// The confidential computing technology for this cluster's instances. Currently
	// only SEV_SNP is supported, and only on N2D instance types. When not set, no
	// confidential computing is applied.
	ConfidentialComputeType ConfidentialComputeType `fieldmask:"confidential_compute_type"`
}

type GcpAvailability string

type GcsStorageInfo struct {
	// GCS destination/URI, e.g. `gs://my-bucket/some-prefix`
	Destination *string
}

type GetClusterRequest struct {
	// The cluster about which to retrieve information.
	ClusterId *string
}

type GetEventsOrder string

type GetEventsResponse struct {
	Events []ClusterEvent
	// Deprecated: use next_page_token or prev_page_token instead.
	//
	// The parameters required to retrieve the next page of events. Omitted if there
	// are no more events to read.
	NextPage *ListEventsRequest
	// Deprecated: Returns 0 when request uses page_token. Will start returning zero
	// when request uses offset/limit soon.
	//
	// The total number of events filtered by the start_time, end_time, and
	// event_types.
	TotalCount *int64
	// This field represents the pagination token to retrieve the next page of
	// results. If the value is "", it means no further results for the request.
	NextPageToken *string
	// This field represents the pagination token to retrieve the previous page of
	// results. If the value is "", it means no further results for the request.
	PrevPageToken *string
}

type GetPolicyComplianceForClusterRequest struct {
	// The ID of the cluster to get the compliance status
	ClusterId *string
}

type GetPolicyComplianceForClusterResponse struct {
	// Whether the cluster is compliant with its policy or not. Clusters could be
	// out of compliance if the policy was updated after the cluster was last
	// edited.
	IsCompliant *bool
	// An object containing key-value mappings representing the first 200 policy
	// validation errors. The keys indicate the path where the policy validation
	// error is occurring. The values indicate an error message describing the
	// policy validation error.
	Violations map[string]string
	// Information about the pending enforcement for the cluster. Only present if a
	// pending enforcement is scheduled for the cluster.
	PendingEnforcement *PendingEnforcement
}

type GetSparkVersionsRequest struct {
}

type GetSparkVersionsResponse struct {
	// All the available Spark versions.
	Versions []SparkVersion
}

type InitScriptEventDetails struct {
	// The private ip of the node we are reporting init script execution details for
	// (we will select the execution details from only one node rather than
	// reporting the execution details from every node to keep these event details
	// small)
	//
	// This should only be defined for the INIT_SCRIPTS_FINISHED event
	ReportedForNode *string
	// The global init scripts associated with this cluster event.
	Global []InitScriptEventDetails_InitScriptInfoAndExecutionDetails
	// The cluster scoped init scripts associated with this cluster event.
	Cluster []InitScriptEventDetails_InitScriptInfoAndExecutionDetails
}

type InitScriptEventDetails_InitScriptInfoAndExecutionDetails struct {
	StorageInfo isInitScriptEventDetails_InitScriptInfoAndExecutionDetails_StorageInfo
	// The current status of the script
	Status InitScriptExecutionDetails_InitScriptExecutionStatus
	// The number duration of the script execution in seconds
	ExecutionDurationSeconds *int
	// Additional details regarding errors (such as a file not found message if the
	// status is FAILED_FETCH). This field should only be used to provide
	// *additional* information to the status field, not duplicate it.
	ErrorMessage *string
	// The stderr output from the init script execution. Only populated when init
	// scripts debug is enabled and script execution fails.
	Stderr *string
}

type InitScriptEventDetails_InitScriptInfoAndExecutionDetails_StorageInfo_Abfss struct {
	Abfss Adlsgen2Info
}

type InitScriptEventDetails_InitScriptInfoAndExecutionDetails_StorageInfo_Dbfs struct {
	Dbfs DbfsStorageInfo
}

type InitScriptEventDetails_InitScriptInfoAndExecutionDetails_StorageInfo_File struct {
	File LocalFileInfo
}

type InitScriptEventDetails_InitScriptInfoAndExecutionDetails_StorageInfo_Gcs struct {
	Gcs GcsStorageInfo
}

type InitScriptEventDetails_InitScriptInfoAndExecutionDetails_StorageInfo_S3 struct {
	S3 S3StorageInfo
}

type InitScriptEventDetails_InitScriptInfoAndExecutionDetails_StorageInfo_Volumes struct {
	Volumes VolumesStorageInfo
}

type InitScriptEventDetails_InitScriptInfoAndExecutionDetails_StorageInfo_Workspace struct {
	Workspace WorkspaceStorageInfo
}

type InitScriptExecutionDetails struct {
}

type InitScriptExecutionDetails_InitScriptExecutionStatus string

type InitScriptInfo struct {
	StorageInfo isInitScriptInfo_StorageInfo
}

type InitScriptInfo_StorageInfo_Abfss struct {
	Abfss Adlsgen2Info
}

type InitScriptInfo_StorageInfo_Dbfs struct {
	Dbfs DbfsStorageInfo
}

type InitScriptInfo_StorageInfo_File struct {
	File LocalFileInfo
}

type InitScriptInfo_StorageInfo_Gcs struct {
	Gcs GcsStorageInfo
}

type InitScriptInfo_StorageInfo_S3 struct {
	S3 S3StorageInfo
}

type InitScriptInfo_StorageInfo_Volumes struct {
	Volumes VolumesStorageInfo
}

type InitScriptInfo_StorageInfo_Workspace struct {
	Workspace WorkspaceStorageInfo
}

type ListAvailableZonesRequest struct {
}

type ListAvailableZonesResponse struct {
	// The list of available zones (e.g., ['us-west-2c', 'us-east-2']).
	Zones []string
	// The availability zone if no “zone_id“ is provided in the cluster creation
	// request.
	DefaultZone *string
}

type ListClusterComplianceForPolicyRequest struct {
	// Canonical unique identifier for the cluster policy.
	PolicyId *string
	// A page token that can be used to navigate to the next page or previous page
	// as returned by `next_page_token` or `prev_page_token`.
	PageToken *string
	// Use this field to specify the maximum number of results to be returned by the
	// server. The server may further constrain the maximum number of results
	// returned in a single page.
	PageSize *int
}

type ListClusterComplianceForPolicyResponse struct {
	// A list of clusters and their policy compliance statuses.
	Clusters []ClusterCompliance
	// This field represents the pagination token to retrieve the next page of
	// results. If the value is "", it means no further results for the request.
	NextPageToken *string
	// This field represents the pagination token to retrieve the previous page of
	// results. If the value is "", it means no further results for the request.
	PrevPageToken *string
}

type ListClustersRequest struct {
	// Use next_page_token or prev_page_token returned from the previous request to
	// list the next or previous page of clusters respectively.
	PageToken *string
	// Use this field to specify the maximum number of results to be returned by the
	// server. The server may further constrain the maximum number of results
	// returned in a single page.
	PageSize *int
}

type ListClustersResponse struct {
	Clusters []ClusterInfo
	// This field represents the pagination token to retrieve the next page of
	// results. If the value is "", it means no further results for the request.
	NextPageToken *string
	// This field represents the pagination token to retrieve the previous page of
	// results. If the value is "", it means no further results for the request.
	PrevPageToken *string
}

type ListEventsRequest struct {
	// The ID of the cluster to retrieve events about.
	ClusterId *string
	// The start time in epoch milliseconds. If empty, returns events starting from
	// the beginning of time.
	StartTime *int64
	// The end time in epoch milliseconds. If empty, returns events up to the
	// current time.
	EndTime *int64
	// The order to list events in; either "ASC" or "DESC". Defaults to "DESC".
	Order GetEventsOrder
	// An optional set of event types to filter on. If empty, all event types are
	// returned.
	EventTypes []ClusterEventType_ClusterEventType
	// Deprecated: use page_token in combination with page_size instead.
	//
	// The offset in the result set. Defaults to 0 (no offset). When an offset is
	// specified and the results are requested in descending order, the end_time
	// field is required.
	Offset *int64
	// Deprecated: use page_token in combination with page_size instead.
	//
	// The maximum number of events to include in a page of events. Defaults to 50,
	// and maximum allowed value is 500.
	Limit *int64
	// Use next_page_token or prev_page_token returned from the previous request to
	// list the next or previous page of events respectively. If page_token is
	// empty, the first page is returned.
	PageToken *string
	// The maximum number of events to include in a page of events. The server may
	// further constrain the maximum number of results returned in a single page. If
	// the page_size is empty or 0, the server will decide the number of results to
	// be returned. The field has to be in the range [0,500]. If the value is
	// outside the range, the server enforces 0 or 500.
	PageSize *int
}

type ListNodeTypesRequest struct {
}

type ListNodeTypesResponse struct {
	// The list of available Spark node types.
	NodeTypes []NodeType
}

type LocalFileInfo struct {
	// local file destination, e.g. `file:/my/local/file.sh`
	Destination *string
}

type LogAnalyticsInfo struct {
	LogAnalyticsWorkspaceId *string `fieldmask:"log_analytics_workspace_id"`
	LogAnalyticsPrimaryKey  *string `fieldmask:"log_analytics_primary_key"`
}

type LogSyncStatus struct {
	// The timestamp of last attempt. If the last attempt fails, `last_exception`
	// will contain the exception in the last attempt.
	LastAttempted *int64
	// The exception thrown in the last attempt, it would be null (omitted in the
	// response) if there is no exception in last attempted.
	LastException *string
}

type NodeInstanceType struct {
	// Unique identifier across instance types
	InstanceTypeId *string
	// Number of local disks that are present on this instance.
	LocalDisks *int
	// Size of the individual local disks attached to this instance (i.e. per local
	// disk).
	LocalDiskSizeGb *int
	// Size of the individual local nvme disks attached to this instance (i.e. per
	// local disk).
	LocalNvmeDiskSizeGb *int
	// Number of local nvme disks that are present on this instance.
	LocalNvmeDisks *int
}

type NodeType struct {
	// Unique identifier for this node type.
	NodeTypeId *string
	// Memory (in MB) available for this node type.
	MemoryMb *int
	// Number of CPU cores available for this node type. Note that this can be
	// fractional, e.g., 2.5 cores, if the number of cores on a machine instance is
	// not divisible by the number of Spark nodes on that machine.
	NumCores *float32
	// A string description associated with this node type, e.g., "r3.xlarge".
	Description *string
	// An identifier for the type of hardware that this node runs on, e.g.,
	// "r3.2xlarge" in AWS.
	InstanceTypeId *string
	// Whether the node type is deprecated. Non-deprecated node types offer greater
	// performance.
	IsDeprecated *bool
	// A descriptive category for this node type. Examples include "Memory
	// Optimized" and "Compute Optimized".
	Category *string
	// Whether this node type support EBS volumes. EBS volumes is disabled for node
	// types that we could place multiple corresponding containers on the same
	// hosting instance.
	SupportEbsVolumes *bool
	// Whether this node type support cluster tags.
	SupportClusterTags *bool
	// Number of GPUs available for this node type.
	NumGpus *int
	// The NodeInstanceType object corresponding to instance_type_id
	NodeInstanceType *NodeInstanceType
	// Whether this node is hidden from presentation in the UI.
	IsHidden *bool
	// Whether this node type supports port forwarding.
	SupportPortForwarding *bool
	// An optional hint at the display order of node types in the UI. Within a node
	// type category, lowest numbers come first.
	DisplayOrder *int
	// Whether this node comes with IO cache enabled by default.
	IsIoCacheEnabled *bool
	// A collection of node type info reported by the cloud provider
	NodeInfo            *CloudProviderNodeInfo
	PhotonWorkerCapable *bool
	PhotonDriverCapable *bool
	// AWS specific, whether this instance supports encryption in transit, used for
	// hipaa and pci workloads.
	IsEncryptedInTransit *bool
	// Whether this is an Arm-based instance.
	IsGraviton *bool
}

type NodeTypeFlexibility struct {
	// A list of node type IDs to use as fallbacks when the primary node type is
	// unavailable.
	AlternateNodeTypeIds []string `fieldmask:"alternate_node_type_ids"`
	// The AWS Context ID for EC2 Fleet. When set (non-empty), the value is passed
	// to AWS CreateFleet API to create the EC2 Fleet.
	AwsContextId *string `fieldmask:"aws_context_id"`
}

type PendingEnforcement struct {
	// The new configuration to apply upon cluster termination or restart.
	TargetSpec *EnforcePolicyComplianceForClusterResponse_ClusterSettings
	// The time the pending enforcement was initiated.
	InitiateTime *types.Time
	// Whether the pending enforcement will be applied. A pending enforcement begins
	// in `ACTIVE` state. If the enforcement fails to apply too many times, the
	// state transitions to `INACTIVE`. Afterwards, the enforcement must be
	// re-scheduled to become `ACTIVE` again.
	EnforcementStatus PendingEnforcement_EnforcementStatus
	// A list of changes that will be made to the cluster configuration when the
	// pending enforcement is applied.
	TargetChanges []EnforcePolicyComplianceForClusterResponse_ClusterSettingsChange
	// The user who initiated the pending enforcement.
	InitiatorUser *string
}

type PendingEnforcement_EnforcementStatus string

type PermanentDeleteClusterRequest struct {
	// The cluster to be deleted.
	ClusterId *string
}

type PermanentDeleteClusterResponse struct {
}

type PinClusterRequest struct {
	ClusterId *string
}

type PinClusterResponse struct {
}

type ResizeCause struct {
}

type ResizeCause_ResizeCause string

type ResizeClusterRequest struct {
	// The cluster to be resized.
	ClusterId *string
	Size      isResizeClusterRequest_Size
}

type ResizeClusterRequest_Size_Autoscale struct {
	Autoscale AutoScale
}

type ResizeClusterRequest_Size_NumWorkers struct {
	NumWorkers int
}

type ResizeClusterResponse struct {
}

type ResizeClusterWaiter struct {
	// contains filtered or unexported fields
}

type RestartClusterRequest struct {
	// The cluster to be started.
	ClusterId   *string
	RestartUser *string
}

type RestartClusterResponse struct {
}

type RestartClusterWaiter struct {
	// contains filtered or unexported fields
}

type RuntimeEngine string

type S3StorageInfo struct {
	// S3 destination, e.g. `s3://my-bucket/some-prefix` Note that logs will be
	// delivered using cluster iam role, please make sure you set cluster iam role
	// and the role has write access to the destination. Please also note that you
	// cannot use AWS keys to deliver logs.
	Destination *string `fieldmask:"destination"`
	// S3 region, e.g. `us-west-2`. Either region or endpoint needs to be set. If
	// both are set, endpoint will be used.
	Region *string `fieldmask:"region"`
	// S3 endpoint, e.g. `https://s3-us-west-2.amazonaws.com`. Either region or
	// endpoint needs to be set. If both are set, endpoint will be used.
	Endpoint *string `fieldmask:"endpoint"`
	// (Optional) Flag to enable server side encryption, `false` by default.
	EnableEncryption *bool `fieldmask:"enable_encryption"`
	// (Optional) The encryption type, it could be `sse-s3` or `sse-kms`. It will be
	// used only when encryption is enabled and the default type is `sse-s3`.
	EncryptionType *string `fieldmask:"encryption_type"`
	// (Optional) Kms key which will be used if encryption is enabled and encryption
	// type is set to `sse-kms`.
	KmsKey *string `fieldmask:"kms_key"`
	// (Optional) Set canned access control list for the logs, e.g.
	// `bucket-owner-full-control`. If `canned_cal` is set, please make sure the
	// cluster iam role has `s3:PutObjectAcl` permission on the destination bucket
	// and prefix. The full list of possible canned acl can be found at
	// http://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl.
	// Please also note that by default only the object owner gets full controls. If
	// you are using cross account role for writing data, you may want to set
	// `bucket-owner-full-control` to make bucket owner able to read the logs.
	CannedAcl *string `fieldmask:"canned_acl"`
}

type SparkInfo struct {
}

type SparkInfo_SparkNode struct {
	// Private IP address (typically a 10.x.x.x address) of the Spark node. Note
	// that this is different from the private IP address of the host instance.
	PrivateIp *string
	// Public DNS address of this node. This address can be used to access the Spark
	// JDBC server on the driver node. To communicate with the JDBC server, traffic
	// must be manually authorized by adding security group rules to the
	// "worker-unmanaged" security group via the AWS console.
	PublicDns *string
	// Globally unique identifier for this node.
	NodeId *string
	// Globally unique identifier for the host instance from the cloud provider.
	InstanceId *string
	// The timestamp (in millisecond) when the Spark node is launched.
	StartTimestamp *int64
	// Attributes specific to AWS for a Spark node.
	NodeAwsAttributes *SparkInfo_SparkNode_SparkNodeAwsAttributes
	// The private IP address of the host instance.
	HostPrivateIp *string
}

type SparkInfo_SparkNode_SparkNodeAwsAttributes struct {
	// Whether this node is on an Amazon spot instance.
	IsSpot *bool
}

type SparkVersion struct {
	// Spark version key, for example "2.1.x-scala2.11". This is the value which
	// should be provided as the "spark_version" when creating a new cluster. Note
	// that the exact Spark version may change over time for a "wildcard" version
	// (i.e., "2.1.x-scala2.11" is a "wildcard" version) with minor bug fixes.
	Key *string
	// A descriptive name for this Spark version, for example "Spark 2.1".
	Name *string
}

type StartClusterRequest struct {
	// The cluster to be started.
	ClusterId *string
}

type StartClusterResponse struct {
}

type StartClusterWaiter struct {
	// contains filtered or unexported fields
}

type TerminationCode string

type TerminationReason struct {
	// status code indicating why the cluster was terminated
	Code TerminationCode
	// type of the termination
	Type TerminationType
	// list of parameters that provide additional information about why the cluster
	// was terminated
	Parameters map[string]string
}

type TerminationType string

type UnpinClusterRequest struct {
	ClusterId *string
}

type UnpinClusterResponse struct {
}

type UpdateClusterRequest struct {
	// ID of the cluster.
	ClusterId *string
	// The cluster to be updated.
	Cluster *UpdateClusterRequest_UpdateClusterResource
	// Used to specify which cluster attributes and size fields to update. See
	// https://google.aip.dev/161 for more details.
	UpdateMask *types.FieldMask[UpdateClusterRequest_UpdateClusterResource]
}

type UpdateClusterRequest_UpdateClusterResource struct {
	Size isUpdateClusterRequest_UpdateClusterResource_Size
	// Cluster name requested by the user. This doesn't have to be unique. If not
	// specified at creation, the cluster name will be an empty string. For job
	// clusters, the cluster name is automatically set based on the job and job run
	// IDs.
	ClusterName *string `fieldmask:"cluster_name"`
	// The Spark version of the cluster, e.g. `3.3.x-scala2.11`. A list of available
	// Spark versions can be retrieved by using the [clusters/sparkVersions] API
	// call.
	//
	// [clusters/sparkVersions]: https://docs.databricks.com/api/workspace/clusters/sparkversions
	SparkVersion *string `fieldmask:"spark_version"`
	// An object containing a set of optional, user-specified Spark configuration
	// key-value pairs. Users can also pass in a string of extra JVM options to the
	// driver and the executors via `spark.driver.extraJavaOptions` and
	// `spark.executor.extraJavaOptions` respectively.
	SparkConf map[string]string `fieldmask:"spark_conf"`
	// Attributes related to clusters running on Amazon Web Services. If not
	// specified at cluster creation, a set of default values will be used.
	AwsAttributes *AwsAttributes `fieldmask:"aws_attributes"`
	// Attributes related to clusters running on Microsoft Azure. If not specified
	// at cluster creation, a set of default values will be used.
	AzureAttributes *AzureAttributes `fieldmask:"azure_attributes"`
	// Attributes related to clusters running on Google Cloud Platform. If not
	// specified at cluster creation, a set of default values will be used.
	GcpAttributes *GcpAttributes `fieldmask:"gcp_attributes"`
	// This field encodes, through a single value, the resources available to each
	// of the Spark nodes in this cluster. For example, the Spark nodes can be
	// provisioned and optimized for memory or compute intensive workloads. A list
	// of available node types can be retrieved by using the
	// [clusters/listNodeTypes] API call.
	//
	// [clusters/listNodeTypes]: https://docs.databricks.com/api/workspace/clusters/listnodetypes
	NodeTypeId *string `fieldmask:"node_type_id"`
	// The node type of the Spark driver. Note that this field is optional; if
	// unset, the driver node type will be set as the same value as `node_type_id`
	// defined above.
	//
	// This field, along with node_type_id, should not be set if
	// virtual_cluster_size is set. If both driver_node_type_id, node_type_id, and
	// virtual_cluster_size are specified, driver_node_type_id and node_type_id take
	// precedence.
	DriverNodeTypeId *string `fieldmask:"driver_node_type_id"`
	// Flexible node type configuration for worker nodes.
	WorkerNodeTypeFlexibility *NodeTypeFlexibility `fieldmask:"worker_node_type_flexibility"`
	// Flexible node type configuration for the driver node.
	DriverNodeTypeFlexibility *NodeTypeFlexibility `fieldmask:"driver_node_type_flexibility"`
	// SSH public key contents that will be added to each Spark node in this
	// cluster. The corresponding private keys can be used to login with the user
	// name `ubuntu` on port `2200`. Up to 10 keys can be specified.
	SshPublicKeys []string `fieldmask:"ssh_public_keys"`
	// Additional tags for cluster resources. <Databricks> will tag all cluster
	// resources (e.g., AWS instances and EBS volumes) with these tags in addition
	// to `default_tags`. Notes:
	//
	// - Currently, <Databricks> allows at most 45 custom tags
	//
	// - Clusters can only reuse cloud resources if the resources' tags are a subset
	// of the cluster tags
	CustomTags map[string]string `fieldmask:"custom_tags"`
	// The configuration for delivering spark logs to a long-term storage
	// destination. Three kinds of destinations (DBFS, S3 and Unity Catalog volumes)
	// are supported. Only one destination can be specified for one cluster. If the
	// conf is given, the logs will be delivered to the destination every `5 mins`.
	// The destination of driver logs is `$destination/$clusterId/driver`, while the
	// destination of executor logs is `$destination/$clusterId/executor`.
	ClusterLogConf *ClusterLogConf `fieldmask:"cluster_log_conf"`
	// An object containing a set of optional, user-specified environment variable
	// key-value pairs. Please note that key-value pair of the form (X,Y) will be
	// exported as is (i.e., `export X='Y'`) while launching the driver and workers.
	//
	// In order to specify an additional set of `SPARK_DAEMON_JAVA_OPTS`, we
	// recommend appending them to `$SPARK_DAEMON_JAVA_OPTS` as shown in the example
	// below. This ensures that all default databricks managed environmental
	// variables are included as well.
	//
	// Example Spark environment variables: `{"SPARK_WORKER_MEMORY": "28000m",
	// "SPARK_LOCAL_DIRS": "/local_disk0"}` or `{"SPARK_DAEMON_JAVA_OPTS":
	// "$SPARK_DAEMON_JAVA_OPTS -Dspark.shuffle.service.enabled=true"}`
	SparkEnvVars map[string]string `fieldmask:"spark_env_vars"`
	// Automatically terminates the cluster after it is inactive for this time in
	// minutes. If not set, this cluster will not be automatically terminated. If
	// specified, the threshold must be between 10 and 10000 minutes. Users can also
	// set this value to 0 to explicitly disable automatic termination.
	AutoterminationMinutes *int `fieldmask:"autotermination_minutes"`
	// Autoscaling Local Storage: when enabled, this cluster will dynamically
	// acquire additional disk space when its Spark workers are running low on disk
	// space.
	EnableElasticDisk *bool `fieldmask:"enable_elastic_disk"`
	// The configuration for storing init scripts. Any number of destinations can be
	// specified. The scripts are executed sequentially in the order provided. If
	// `cluster_log_conf` is specified, init script logs are sent to
	// `<destination>/<cluster-ID>/init_scripts`.
	InitScripts []InitScriptInfo `fieldmask:"init_scripts"`
	// Custom docker image BYOC
	DockerImage *DockerImage `fieldmask:"docker_image"`
	// The optional ID of the instance pool to which the cluster belongs.
	InstancePoolId *string `fieldmask:"instance_pool_id"`
	// Single user name if data_security_mode is `SINGLE_USER`
	SingleUserName *string `fieldmask:"single_user_name"`
	// The ID of the cluster policy used to create the cluster if applicable.
	PolicyId *string `fieldmask:"policy_id"`
	// Whether to enable LUKS on cluster VMs' local disks
	EnableLocalDiskEncryption *bool `fieldmask:"enable_local_disk_encryption"`
	// The optional ID of the instance pool for the driver of the cluster belongs.
	// The pool cluster uses the instance pool with id (instance_pool_id) if the
	// driver pool is not assigned.
	DriverInstancePoolId *string          `fieldmask:"driver_instance_pool_id"`
	WorkloadType         *WorkloadType    `fieldmask:"workload_type"`
	DataSecurityMode     DataSecurityMode `fieldmask:"data_security_mode"`
	// Determines the cluster's runtime engine, either standard or Photon.
	//
	// This field is not compatible with legacy `spark_version` values that contain
	// `-photon-`. Remove `-photon-` from the `spark_version` and set
	// `runtime_engine` to `PHOTON`.
	//
	// If left unspecified, the runtime engine defaults to standard unless the
	// spark_version contains -photon-, in which case Photon will be used.
	RuntimeEngine RuntimeEngine `fieldmask:"runtime_engine"`
	Kind          ComputeKind   `fieldmask:"kind"`
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// `effective_spark_version` is determined by `spark_version` (DBR release),
	// this field `use_ml_runtime`, and whether `node_type_id` is gpu node or not.
	UseMlRuntime *bool `fieldmask:"use_ml_runtime"`
	// This field can only be used when `kind = CLASSIC_PREVIEW`.
	//
	// When set to true, <Databricks> will automatically set single node related
	// `custom_tags`, `spark_conf`, and `num_workers`
	IsSingleNode *bool `fieldmask:"is_single_node"`
	// If set, what the configurable throughput (in Mb/s) for the remote disk is.
	// Currently only supported for GCP HYPERDISK_BALANCED disks.
	RemoteDiskThroughput *int `fieldmask:"remote_disk_throughput"`
	// If set, what the total initial volume size (in GB) of the remote disks should
	// be. Supported for GCP.
	TotalInitialRemoteDiskSize *int `fieldmask:"total_initial_remote_disk_size"`
	// Controls dependency configuration for the cluster.
	DependencyMode DependencyMode `fieldmask:"dependency_mode"`
	// contains filtered or unexported fields
}

type UpdateClusterRequest_UpdateClusterResource_Size_Autoscale struct {
	Autoscale AutoScale `fieldmask:"autoscale"`
}

type UpdateClusterRequest_UpdateClusterResource_Size_NumWorkers struct {
	NumWorkers int `fieldmask:"num_workers"`
}

type UpdateClusterResponse struct {
}

type UpdateClusterWaiter struct {
	// contains filtered or unexported fields
}

type VolumesStorageInfo struct {
	// UC Volumes destination, e.g.
	// `/Volumes/catalog/schema/vol1/init-scripts/setup-datadog.sh` or
	// `dbfs:/Volumes/catalog/schema/vol1/init-scripts/setup-datadog.sh`
	Destination *string `fieldmask:"destination"`
}

type WorkloadType struct {
	// defined what type of clients can use the cluster. E.g. Notebooks, Jobs
	Clients *WorkloadType_ClientsTypes `fieldmask:"clients"`
}

type WorkloadType_ClientsTypes struct {
	// With notebooks set, this cluster can be used for notebooks
	Notebooks *bool `fieldmask:"notebooks"`
	// With jobs set, the cluster can be used for jobs
	Jobs *bool `fieldmask:"jobs"`
}

type WorkspaceStorageInfo struct {
	// wsfs destination, e.g. `workspace:/cluster-init-scripts/setup-datadog.sh`
	Destination *string
}