networking

type AccountIpAccessList struct {
	// Universally unique identifier (UUID) of the IP access list.
	ListId *string
	// Label for the IP access list. This **cannot** be empty.
	Label       *string
	IpAddresses []string
	// Total number of IP or CIDR values.
	AddressCount *int
	ListType     AccountIpAccessListType_IpAccessListType
	// Creation timestamp in milliseconds.
	CreatedAt *int64
	// The ID of the user that created this list.
	CreatedBy *int64
	// Update timestamp in milliseconds.
	UpdatedAt *int64
	// The ID of the user that last updated this list.
	UpdatedBy *int64
	// Specifies whether this IP access list is enabled.
	Enabled *bool
}

type AccountIpAccessListType struct {
}

type AccountIpAccessListType_IpAccessListType string

type AccountNetworkPolicy struct {
	// The unique identifier for the network policy.
	NetworkPolicyId *string
	// The associated account ID for this Network Policy object.
	AccountId *string
	// The network policies applying for egress traffic.
	Egress *EgressNetworkPolicy
	// The network policies applying for ingress traffic.
	Ingress *IngressNetworkPolicy
	// The ingress policy for dry run mode. Dry run will always run even if the
	// request is allowed by the ingress policy. When this field is set, the policy
	// will be evaluated and emit logs only without blocking requests.
	IngressDryRun *IngressNetworkPolicy
}

type AwsVpcEndpointInfo struct {
	// The ID of the underlying VPC endpoint in AWS. Provided by the customer when
	// registering an existing AWS VPC endpoint.
	AwsVpcEndpointId *string
	// The ID of the Databricks VPC endpoint service that this endpoint connects to.
	AwsEndpointServiceId *string
	// The AWS account ID in which this VPC endpoint lives.
	AwsAccountId *string
}

type AzurePrivateEndpointInfo struct {
	// The name of the Private Endpoint in the Azure subscription.
	PrivateEndpointName *string
	// The GUID of the Private Endpoint resource in the Azure subscription. This is
	// assigned by Azure when the user sets up the Private Endpoint.
	PrivateEndpointResourceGuid *string
	// The full resource ID of the Private Endpoint.
	PrivateEndpointResourceId *string
	// The resource ID of the Databricks Private Link Service that this Private
	// Endpoint connects to.
	PrivateLinkServiceId *string
}

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

type CreateAccountIpAccessListRequest struct {
	AccountId   *string
	Label       *string
	ListType    AccountIpAccessListType_IpAccessListType
	IpAddresses []string
}

type CreateAccountIpAccessListResponse struct {
	IpAccessList *AccountIpAccessList
}

type CreateEndpointRequest struct {
	// The parent resource name of the account under which the endpoint is created.
	// Format: `accounts/{account_id}`.
	Parent   *string
	Endpoint *Endpoint
}

type CreateIpAccessListRequest struct {
	// Label for the IP access list. This **cannot** be empty.
	Label       *string
	ListType    IpAccessListType
	IpAddresses []string
}

type CreateIpAccessListResponse struct {
	IpAccessList *IpAccessList
}

type CreateNccPrivateEndpointRuleRequest struct {
	// Your Network Connectivity Configuration ID.
	NetworkConnectivityConfigId *string
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId           *string
	PrivateEndpointRule *CreatePrivateEndpointRule
}

type CreateNetworkConnectivityConfigRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId                 *string
	NetworkConnectivityConfig *CreateNetworkConnectivityConfiguration
}

type CreateNetworkConnectivityConfiguration struct {
	// <Databricks> network connectivity configuration ID.
	NetworkConnectivityConfigId *string
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// The name of the network connectivity configuration. The name can contain
	// alphanumeric characters, hyphens, and underscores. The length must be between
	// 3 and 30 characters. The name must match the regular expression
	// ^[0-9a-zA-Z-_]{3,30}$
	Name *string
	// The region for the network connectivity configuration. Only workspaces in the
	// same region can be attached to the network connectivity configuration.
	Region *string
	// The network connectivity rules that apply to network traffic from your
	// serverless compute resources.
	EgressConfig *CustomerFacingNetworkConnectivityConfigEgressConfig
	// Time in epoch milliseconds when this object was updated.
	UpdatedTime *int64
	// Time in epoch milliseconds when this object was created.
	CreationTime *int64
}

type CreateNetworkPolicyRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// Network policy configuration details.
	NetworkPolicy *AccountNetworkPolicy
}

type CreateNetworkRequest struct {
	AccountId *string
	// The human-readable name of the network configuration.
	NetworkName *string
	// The ID of the VPC associated with this network configuration. VPC IDs can be
	// used in multiple networks.
	VpcId *string
	// IDs of at least two subnets associated with this network. Subnet IDs
	// **cannot** be used in multiple network configurations.
	SubnetIds []string
	// IDs of one to five security groups associated with this network. Security
	// group IDs **cannot** be used in multiple network configurations.
	SecurityGroupIds []string
	VpcEndpoints     *NetworkVpcEndpoints
	GcpNetworkInfo   *GcpNetworkInfo
}

type CreatePrivateAccessSettingsRequest struct {
	AccountId *string
	// The human-readable name of the private access settings object.
	PrivateAccessSettingsName *string
	// The AWS region for workspaces attached to this private access settings
	// object.
	Region *string
	// Determines if the workspace can be accessed over public internet. For fully
	// private workspaces, you can optionally specify false, but only if you
	// implement both the front-end and the back-end PrivateLink connections.
	// Otherwise, specify true, which means that public access is enabled.
	PublicAccessEnabled *bool
	// The private access level controls which VPC endpoints can connect to the UI
	// or API of any workspace that attaches this private access settings object.
	// `ACCOUNT` level access (the default) allows only VPC endpoints that are
	// registered in your <Databricks> account connect to your workspace. `ENDPOINT`
	// level access allows only specified VPC endpoints connect to your workspace.
	// For details, see allowed_vpc_endpoint_ids.
	PrivateAccessLevel PrivateAccessLevel
	// An array of Databricks VPC endpoint IDs. This is the <Databricks> ID returned
	// when registering the VPC endpoint configuration in your <Databricks> account.
	// This is not the ID of the VPC endpoint in AWS. Only used when
	// private_access_level is set to ENDPOINT. This is an allow list of VPC
	// endpoints registered in your <Databricks> account that can connect to your
	// workspace over AWS PrivateLink. Note: If hybrid access to your workspace is
	// enabled by setting public_access_enabled to true, this control only works for
	// PrivateLink connections. To control how your workspace is accessed via public
	// internet, see IP access lists.
	AllowedVpcEndpointIds []string
}

type CreatePrivateEndpointRule struct {
	// The ID of a private endpoint rule.
	RuleId *string
	// The ID of a network connectivity configuration, which is the parent resource
	// of this private endpoint rule object.
	NetworkConnectivityConfigId *string
	// The current status of this private endpoint. The private endpoint rules are
	// effective only if the connection state is ESTABLISHED. Remember that you must
	// approve new endpoints on your resources in the Cloud console before they take
	// effect. The possible values are: - PENDING: The endpoint has been created and
	// pending approval. - ESTABLISHED: The endpoint has been approved and is ready
	// to use in your serverless compute resources. - REJECTED: Connection was
	// rejected by the private link resource owner. - DISCONNECTED: Connection was
	// removed by the private link resource owner, the private endpoint becomes
	// informative and should be deleted for clean-up. - EXPIRED: If the endpoint
	// was created but not approved in 14 days, it will be EXPIRED. - CREATING: The
	// endpoint creation is in progress. Once successfully created, the state will
	// transition to PENDING. - CREATE_FAILED: The endpoint creation failed. You can
	// check the error_message field for more details.
	ConnectionState NccPrivateEndpointRule_PrivateLinkConnectionState
	// Only used by private endpoints to customer-managed private endpoint services.
	//
	// Domain names of target private link service. When updating this field, the
	// full list of target domain_names must be specified.
	DomainNames []string
	// Time in epoch milliseconds when this object was created.
	CreationTime *int64
	// Time in epoch milliseconds when this object was updated.
	UpdatedTime *int64
	// Whether this private endpoint is deactivated.
	Deactivated *bool
	// Time in epoch milliseconds when this object was deactivated.
	DeactivatedAt *int64
	ErrorMessage  *string
	// The Azure resource ID of the target resource.
	ResourceId *string
	// Not used by customer-managed private endpoint services.
	//
	// The sub-resource type (group ID) of the target resource. Note that to connect
	// to workspace root storage (root DBFS), you need two endpoints, one for blob
	// and one for dfs.
	GroupId *string
	// The name of the Azure private endpoint resource.
	EndpointName *string
	// <Databricks> account ID. You can find your account ID from the Accounts
	// Console.
	AccountId *string
	// The full target AWS endpoint service name that connects to the destination
	// resources of the private endpoint.
	EndpointService *string
	// Only used by private endpoints towards AWS S3 service.
	//
	// The globally unique S3 bucket names that will be accessed via the VPC
	// endpoint. The bucket names must be in the same region as the NCC/endpoint
	// service. When updating this field, we perform full update on this field.
	// Please ensure a full list of desired resource_names is provided.
	ResourceNames []string
	// The AWS VPC endpoint ID. You can use this ID to identify the VPC endpoint
	// created by <Databricks>.
	VpcEndpointId *string
	// Update this field to activate/deactivate this private endpoint to allow
	// egress access from serverless compute resources. Only honored for first-party
	// services on each cloud (e.g. AWS S3).
	Enabled  *bool
	Endpoint isCreatePrivateEndpointRule_Endpoint
}

type CreatePrivateEndpointRule_Endpoint_GcpEndpoint struct {
	GcpEndpoint GcpEndpoint
}

type CreateVpcEndpointRequest struct {
	AccountId *string
	// The human-readable name of the storage configuration.
	VpcEndpointName *string
	// The region in which this VPC endpoint object exists.
	Region *string
	// The ID of the VPC endpoint object in AWS.
	AwsVpcEndpointId *string
	VpcEndpointInfo  isCreateVpcEndpointRequest_VpcEndpointInfo
}

type CreateVpcEndpointRequest_VpcEndpointInfo_GcpVpcEndpointInfo struct {
	GcpVpcEndpointInfo GcpVpcEndpointInfo
}

type CustomerFacingNetworkConnectivityConfigEgressConfig struct {
	// The network connectivity rules that are applied by default without resource
	// specific configurations. You can find the stable network information of your
	// serverless compute resources here.
	DefaultRules *NetworkConnectivityConfigEgressConfig_DefaultRule
	// The network connectivity rules that configured for each destinations. These
	// rules override default rules.
	TargetRules *CustomerFacingNetworkConnectivityConfigEgressConfig_CustomerFacingTargetRule
}

type CustomerFacingNetworkConnectivityConfigEgressConfig_CustomerFacingTargetRule struct {
	AzurePrivateEndpointRules []NetworkConnectivityConfigAzurePrivateEndpointRule
	// AWS private endpoint rule controls the AWS private endpoint based egress
	// rules.
	AwsPrivateEndpointRules []NetworkConnectivityConfigAwsPrivateEndpointRule
}

type DeleteAccountIpAccessListRequest struct {
	AccountId *string
	// The ID for the corresponding IP access list
	ListId *string
}

type DeleteAccountIpAccessListResponse struct {
}

type DeleteEndpointRequest struct {
	Name *string
}

type DeleteIpAccessListRequest struct {
	// The ID for the corresponding IP access list
	ListId *string
}

type DeleteIpAccessListResponse struct {
}

type DeleteNccPrivateEndpointRuleRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// Your Network Connectvity Configuration ID.
	NetworkConnectivityConfigId *string
	// Your private endpoint rule ID.
	PrivateEndpointRuleId *string
}

type DeleteNetworkConnectivityConfigRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// Your Network Connectivity Configuration ID.
	NetworkConnectivityConfigId *string
}

type DeleteNetworkPolicyRequest struct {
	// The unique identifier of the network policy to delete.
	NetworkPolicyId *string
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
}

type DeleteNetworkRequest struct {
	// Databricks Account API network configuration ID.
	NetworkId *string
	AccountId *string
}

type DeletePrivateAccessSettingsRequest struct {
	PrivateAccessSettingsId *string
	AccountId               *string
}

type DeleteVpcEndpointRequest struct {
	VpcEndpointId *string
	AccountId     *string
}

type EgressNetworkPolicy struct {
	// The access policy enforced for egress traffic to the internet.
	NetworkAccess *EgressNetworkPolicy_NetworkAccessPolicy
}

type EgressNetworkPolicy_NetworkAccessPolicy struct {
	// The restriction mode that controls how serverless workloads can access the
	// internet.
	RestrictionMode EgressNetworkPolicy_NetworkAccessPolicy_RestrictionMode
	// List of internet destinations that serverless workloads are allowed to access
	// when in RESTRICTED_ACCESS mode.
	AllowedInternetDestinations []EgressNetworkPolicy_NetworkAccessPolicy_InternetDestination
	// List of storage destinations that serverless workloads are allowed to access
	// when in RESTRICTED_ACCESS mode.
	AllowedStorageDestinations []EgressNetworkPolicy_NetworkAccessPolicy_StorageDestination
	// Optional. When policy_enforcement is not provided, we default to
	// ENFORCE_MODE_ALL_SERVICES
	PolicyEnforcement *EgressNetworkPolicy_NetworkAccessPolicy_PolicyEnforcement
	// List of internet destinations that serverless workloads are blocked from
	// accessing. These destinations are enforced when restriction mode is
	// RESTRICTED_ACCESS or DRY_RUN. Currently supports DNS_NAME type only; IP_RANGE
	// support is planned.
	BlockedInternetDestinations []EgressNetworkPolicy_NetworkAccessPolicy_InternetDestination
	// List of <Databricks> workspace destinations that serverless workloads are
	// allowed to access when in RESTRICTED_ACCESS mode.
	AllowedDatabricksDestinations []EgressNetworkPolicy_NetworkAccessPolicy_DatabricksDestination
}

type EgressNetworkPolicy_NetworkAccessPolicy_DatabricksDestination struct {
	// The workspace IDs to allow egress traffic to.
	WorkspaceIds []int64
}

type EgressNetworkPolicy_NetworkAccessPolicy_InternetDestination struct {
	// The internet destination to which access will be allowed. Format dependent on
	// the destination type.
	Destination *string
	// The type of internet destination. Currently only DNS_NAME is supported.
	InternetDestinationType EgressNetworkPolicy_NetworkAccessPolicy_InternetDestination_InternetDestinationType
}

type EgressNetworkPolicy_NetworkAccessPolicy_InternetDestination_InternetDestinationType string

type EgressNetworkPolicy_NetworkAccessPolicy_PolicyEnforcement struct {
	// The mode of policy enforcement. ENFORCED blocks traffic that violates policy,
	// while DRY_RUN only logs violations without blocking. When not specified,
	// defaults to ENFORCED.
	EnforcementMode EgressNetworkPolicy_NetworkAccessPolicy_PolicyEnforcement_EnforcementMode
	// When empty, it means dry run for all products. When non-empty, it means dry
	// run for specific products and for the other products, they will run in
	// enforced mode.
	DryRunModeProductFilter []EgressNetworkPolicy_NetworkAccessPolicy_PolicyEnforcement_DryRunModeProductFilter
}

type EgressNetworkPolicy_NetworkAccessPolicy_PolicyEnforcement_DryRunModeProductFilter string

type EgressNetworkPolicy_NetworkAccessPolicy_PolicyEnforcement_EnforcementMode string

type EgressNetworkPolicy_NetworkAccessPolicy_RestrictionMode string

type EgressNetworkPolicy_NetworkAccessPolicy_StorageDestination struct {
	BucketName *string
	Region     *string
	// The type of storage destination.
	StorageDestinationType EgressNetworkPolicy_NetworkAccessPolicy_StorageDestination_StorageDestinationType
	// The Azure storage account name.
	AzureStorageAccount *string
	// The Azure storage service type (blob, dfs, etc.).
	AzureStorageService *string
}

type EgressNetworkPolicy_NetworkAccessPolicy_StorageDestination_StorageDestinationType string

type EgressResourceType string

type Endpoint struct {
	// The resource name of the endpoint, which uniquely identifies the endpoint.
	Name *string
	// The unique identifier for this endpoint under the account. This field is a
	// UUID generated by <Databricks>.
	EndpointId *string
	// The Databricks Account in which the endpoint object exists.
	AccountId *string
	// The human-readable display name of this endpoint. The input should conform to
	// RFC-1034, which restricts to letters, numbers, and hyphens, with the first
	// character a letter, the last a letter or a number, and a 63 character
	// maximum.
	DisplayName *string
	// The use case that determines the type of network connectivity this endpoint
	// provides. This field is automatically determined based on the endpoint
	// configuration and cloud-specific settings.
	UseCase EndpointUseCase_EndpointUseCase
	// The cloud provider region where this endpoint is located.
	Region *string
	// The state of the endpoint. The endpoint can only be used if the state is
	// `APPROVED`.
	State EndpointState
	// The cloud info of this endpoint. (-- Azure is GA; AWS and GCP added for
	// PLAT-165656 (Private Preview). --)
	EndpointInfo isEndpoint_EndpointInfo
	// The timestamp when the endpoint was created. The timestamp is in RFC 3339
	// format in UTC timezone.
	CreateTime *types.Time
}

type EndpointState string

type EndpointUseCase struct {
}

type EndpointUseCase_EndpointUseCase string

type Endpoint_EndpointInfo_AwsVpcEndpointInfo struct {
	AwsVpcEndpointInfo AwsVpcEndpointInfo
}

type Endpoint_EndpointInfo_AzurePrivateEndpointInfo struct {
	AzurePrivateEndpointInfo AzurePrivateEndpointInfo
}

type Endpoint_EndpointInfo_GcpPscEndpointInfo struct {
	GcpPscEndpointInfo GcpPscEndpointInfo
}

type GcpEndpoint struct {
	// Output only. The URI of the created PSC endpoint.
	PscEndpointUri *string `fieldmask:"psc_endpoint_uri"`
	// Selects which target services this private endpoint reaches.
	TargetServices isGcpEndpoint_TargetServices
	// contains filtered or unexported fields
}

type GcpEndpoint_TargetServices_AllVpcScServices struct {
	AllVpcScServices bool `fieldmask:"all_vpc_sc_services"`
}

type GcpEndpoint_TargetServices_GoogleApiEndpoints struct {
	GoogleApiEndpoints GoogleApiEndpoints `fieldmask:"google_api_endpoints"`
}

type GcpEndpoint_TargetServices_ServiceAttachment struct {
	ServiceAttachment string `fieldmask:"service_attachment"`
}

type GcpNetworkInfo struct {
	// The GCP project ID for network resources. This project is where the VPC and
	// subnet resides.
	NetworkProjectId *string
	// The customer-provided VPC ID.
	VpcId *string
	// The customer-provided Subnet ID that will be available to Clusters in
	// Workspaces using this Network.
	SubnetId     *string
	SubnetRegion *string
	// Name of the secondary range within the subnet that will be used by GKE as Pod
	// IP range. This is BYO VPC specific. DB VPC uses
	// network.getGcpManagedNetworkConfig.getGkeClusterPodIpRange
	PodIpRangeName *string
	// Name of the secondary range within the subnet that will be used by GKE as
	// Service IP range.
	ServiceIpRangeName *string
}

type GcpPscEndpointInfo struct {
	// The ID of the underlying Private Service Connect connection in the GCP
	// consumer project, assigned by GCP when the PSC connection is created.
	PscConnectionId *string
	// The GCP consumer project ID in which this PSC endpoint is created. Provided
	// by the customer when registering an existing PSC endpoint.
	ProjectId *string
	// The name of this PSC connection in the GCP consumer project. Provided by the
	// customer when registering an existing PSC endpoint.
	PscEndpoint *string
	// The GCP region of the PSC connection endpoint. Provided by the customer when
	// registering an existing PSC endpoint. GCP supports only same-region PSC, so
	// this must match the workspace region.
	EndpointRegion *string
	// The ID of the <Databricks> service attachment this PSC endpoint connects to.
	ServiceAttachmentId *string
}

type GcpVpcEndpointInfo struct {
	PscConnectionId     *string
	ProjectId           *string
	PscEndpointName     *string
	EndpointRegion      *string
	ServiceAttachmentId *string
}

type GetAccountIpAccessListRequest struct {
	AccountId *string
	// The ID for the corresponding IP access list
	ListId *string
}

type GetAccountIpAccessListResponse struct {
	IpAccessList *AccountIpAccessList
}

type GetEndpointRequest struct {
	Name *string
}

type GetIpAccessListRequest struct {
	// The ID for the corresponding IP access list
	ListId *string
}

type GetIpAccessListResponse struct {
	IpAccessList *IpAccessList
}

type GetNccPrivateEndpointRuleRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// Your Network Connectvity Configuration ID.
	NetworkConnectivityConfigId *string
	// Your private endpoint rule ID.
	PrivateEndpointRuleId *string
}

type GetNetworkConnectivityConfigRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// Your Network Connectivity Configuration ID.
	NetworkConnectivityConfigId *string
}

type GetNetworkPolicyRequest struct {
	// The unique identifier of the network policy to retrieve.
	NetworkPolicyId *string
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
}

type GetNetworkRequest struct {
	// Databricks Account API network configuration ID.
	NetworkId *string
	AccountId *string
}

type GetPrivateAccessSettingsRequest struct {
	PrivateAccessSettingsId *string
	AccountId               *string
}

type GetVpcEndpointRequest struct {
	// Databricks VPC endpoint ID.
	VpcEndpointId *string
	AccountId     *string
}

type GetWorkspaceNetworkOptionRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// The workspace ID.
	WorkspaceId *int64
}

type GoogleApiEndpoints struct {
	// Google API hostnames, e.g. "storage.googleapis.com",
	// "bigquery.googleapis.com". Use "googleapis.com" to cover all Google APIs.
	Endpoints []string `fieldmask:"endpoints"`
}

type IngressNetworkPolicy struct {
	// The network policy restrictions for public access to the workspace.
	// Configures how public internet traffic is allowed or denied access.
	PublicAccess *IngressNetworkPolicy_PublicAccess
	// The network policy restrictions for private access. Configures how requests
	// arriving over private connectivity are governed.
	PrivateAccess        *IngressNetworkPolicy_PrivateAccess
	CrossWorkspaceAccess *IngressNetworkPolicy_CrossWorkspaceAccess
}

type IngressNetworkPolicy_AccountApiDestination struct {
	// The API scopes to match. Use "all-apis" to match any account-level API.
	Scopes []string
	// Qualifies the breadth of API access for the listed scopes. See
	// ApiScopeQualifier.
	ScopeQualifier IngressNetworkPolicy_ApiScopeQualifier
}

type IngressNetworkPolicy_AccountDatabricksOneDestination struct {
	// Must be set to true.
	AllDestinations *bool
}

type IngressNetworkPolicy_AccountUiDestination struct {
	// Must be set to true.
	AllDestinations *bool
}

type IngressNetworkPolicy_ApiScopeQualifier string

type IngressNetworkPolicy_AppsRuntimeDestination struct {
	// Must be set to true.
	AllDestinations *bool
}

type IngressNetworkPolicy_Authentication struct {
	IdentityType IngressNetworkPolicy_Authentication_IdentityType
	// Valid only when IdentityType is IDENTITY_TYPE_SELECTED_IDENTITIES.
	Identities []IngressNetworkPolicy_AuthenticationIdentity
}

type IngressNetworkPolicy_AuthenticationIdentity struct {
	PrincipalType IngressNetworkPolicy_AuthenticationIdentity_PrincipalType
	PrincipalId   *int64
}

type IngressNetworkPolicy_AuthenticationIdentity_PrincipalType string

type IngressNetworkPolicy_Authentication_IdentityType string

type IngressNetworkPolicy_CrossWorkspaceAccess struct {
	// The restriction mode for cross-workspace access.
	RestrictionMode IngressNetworkPolicy_CrossWorkspaceAccess_RestrictionMode
	// Deny rules are evaluated first. A request matching any deny rule is denied,
	// regardless of allow rules. Only applies when restriction_mode is
	// RESTRICTED_ACCESS.
	DenyRules []IngressNetworkPolicy_CrossWorkspaceIngressRule
	// Allow rules are evaluated after deny rules. A request matching any allow rule
	// is allowed; a request matching no rule is denied by default. Only applies
	// when restriction_mode is RESTRICTED_ACCESS.
	AllowRules []IngressNetworkPolicy_CrossWorkspaceIngressRule
}

type IngressNetworkPolicy_CrossWorkspaceAccess_RestrictionMode string

type IngressNetworkPolicy_CrossWorkspaceIngressRule struct {
	// The origin the request must match — the source workspace the request comes
	// from, either specific source workspaces or any source workspace in any
	// account. See CrossWorkspaceRequestOrigin.
	Origin *IngressNetworkPolicy_CrossWorkspaceRequestOrigin
	// The destination the request must match — the resource being accessed, for
	// example the workspace UI or workspace APIs. See RequestDestination.
	Destination *IngressNetworkPolicy_RequestDestination
	// The authenticated identity the request must match. When unset, the rule
	// matches all users and service principals.
	Authentication *IngressNetworkPolicy_Authentication
	// The label for this ingress rule.
	Label *string
}

type IngressNetworkPolicy_CrossWorkspaceRequestOrigin struct {
	Source isIngressNetworkPolicy_CrossWorkspaceRequestOrigin_Source
}

type IngressNetworkPolicy_CrossWorkspaceRequestOrigin_Source_AllSourceWorkspaces struct {
	AllSourceWorkspaces bool
}

type IngressNetworkPolicy_CrossWorkspaceRequestOrigin_Source_SelectedWorkspaces struct {
	SelectedWorkspaces IngressNetworkPolicy_WorkspaceIdList
}

type IngressNetworkPolicy_Endpoints struct {
	// The IDs of the registered endpoints. Must contain at least one endpoint ID.
	EndpointIds []string
}

type IngressNetworkPolicy_IpRanges struct {
	// We only support IPv4 and IPv4 CIDR notation for now.
	IpRanges []string
}

type IngressNetworkPolicy_LakebaseRuntimeDestination struct {
	// Must be set to true.
	AllDestinations *bool
}

type IngressNetworkPolicy_PrivateAccess struct {
	// The restriction mode for private access.
	RestrictionMode IngressNetworkPolicy_PrivateAccess_RestrictionMode
	// Deny rules are evaluated first. A request matching any deny rule is denied,
	// regardless of allow rules. Only applies when restriction_mode is
	// RESTRICTED_ACCESS.
	DenyRules []IngressNetworkPolicy_PrivateIngressRule
	// Allow rules are evaluated after deny rules. A request matching any allow rule
	// is allowed; a request matching no rule is denied by default. Only applies
	// when restriction_mode is RESTRICTED_ACCESS.
	AllowRules []IngressNetworkPolicy_PrivateIngressRule
}

type IngressNetworkPolicy_PrivateAccess_RestrictionMode string

type IngressNetworkPolicy_PrivateIngressRule struct {
	// The origin the request must match — the private connectivity the request
	// arrives through, for example a specific set of registered endpoints or any
	// endpoint registered to the account. See PrivateRequestOrigin.
	Origin *IngressNetworkPolicy_PrivateRequestOrigin
	// The destination the request must match — the resource being accessed, for
	// example the workspace UI, workspace APIs, or account-level APIs. See
	// RequestDestination.
	Destination *IngressNetworkPolicy_RequestDestination
	// The authenticated identity the request must match. When unset, the rule
	// matches all users and service principals. On the account-level network
	// policy, scoping to specific identities is not currently supported, so this
	// field must be unset (the rule matches all users and service principals).
	Authentication *IngressNetworkPolicy_Authentication
	// The label for this ingress rule.
	Label *string
}

type IngressNetworkPolicy_PrivateRequestOrigin struct {
	Source isIngressNetworkPolicy_PrivateRequestOrigin_Source
}

type IngressNetworkPolicy_PrivateRequestOrigin_Source_AllPrivateAccess struct {
	AllPrivateAccess bool
}

type IngressNetworkPolicy_PrivateRequestOrigin_Source_AllRegisteredEndpoints struct {
	AllRegisteredEndpoints bool
}

type IngressNetworkPolicy_PrivateRequestOrigin_Source_AzureWorkspacePrivateLink struct {
	AzureWorkspacePrivateLink bool
}

type IngressNetworkPolicy_PrivateRequestOrigin_Source_Endpoints struct {
	Endpoints IngressNetworkPolicy_Endpoints
}

type IngressNetworkPolicy_PublicAccess struct {
	RestrictionMode IngressNetworkPolicy_PublicAccess_RestrictionMode
	DenyRules       []IngressNetworkPolicy_PublicIngressRule
	AllowRules      []IngressNetworkPolicy_PublicIngressRule
}

type IngressNetworkPolicy_PublicAccess_RestrictionMode string

type IngressNetworkPolicy_PublicIngressRule struct {
	Origin         *IngressNetworkPolicy_PublicRequestOrigin
	Destination    *IngressNetworkPolicy_RequestDestination
	Authentication *IngressNetworkPolicy_Authentication
	// The label for this ingress rule.
	Label *string
}

type IngressNetworkPolicy_PublicRequestOrigin struct {
	Source isIngressNetworkPolicy_PublicRequestOrigin_Source
}

type IngressNetworkPolicy_PublicRequestOrigin_Source_AllIpRanges struct {
	AllIpRanges bool
}

type IngressNetworkPolicy_PublicRequestOrigin_Source_ExcludedIpRanges struct {
	ExcludedIpRanges IngressNetworkPolicy_IpRanges
}

type IngressNetworkPolicy_PublicRequestOrigin_Source_IncludedIpRanges struct {
	IncludedIpRanges IngressNetworkPolicy_IpRanges
}

type IngressNetworkPolicy_RequestDestination struct {
	// When true, match all destinations, no other destination fields can be set.
	// When not set or false, at least one specific destination must be provided.
	AllDestinations *bool
	WorkspaceUi     *IngressNetworkPolicy_WorkspaceUiDestination
	WorkspaceApi    *IngressNetworkPolicy_WorkspaceApiDestination
	AppsRuntime     *IngressNetworkPolicy_AppsRuntimeDestination
	LakebaseRuntime *IngressNetworkPolicy_LakebaseRuntimeDestination
	// Matches requests to the account console UI. Can only be used in the
	// account-level network policy.
	AccountUi *IngressNetworkPolicy_AccountUiDestination
	// Matches requests to account-level APIs. Can only be used in the account-level
	// network policy.
	AccountApi *IngressNetworkPolicy_AccountApiDestination
	// Account DatabricksOne destination is not supported.
	AccountDatabricksOne *IngressNetworkPolicy_AccountDatabricksOneDestination
}

type IngressNetworkPolicy_WorkspaceApiDestination struct {
	Scopes []string
	// Qualifies the breadth of API access for the listed scopes. See
	// ApiScopeQualifier.
	ScopeQualifier IngressNetworkPolicy_ApiScopeQualifier
}

type IngressNetworkPolicy_WorkspaceIdList struct {
	WorkspaceIds []int64
}

type IngressNetworkPolicy_WorkspaceUiDestination struct {
	// Must be set to true.
	AllDestinations *bool
}

type IpAccessList struct {
	// Universally unique identifier (UUID) of the IP access list.
	ListId *string
	// Label for the IP access list. This **cannot** be empty.
	Label       *string
	IpAddresses []string
	// Total number of IP or CIDR values.
	AddressCount *int
	ListType     IpAccessListType
	// Creation timestamp in milliseconds.
	CreatedAt *int64
	// User ID of the user who created this list.
	CreatedBy *int64
	// Update timestamp in milliseconds.
	UpdatedAt *int64
	// User ID of the user who updated this list.
	UpdatedBy *int64
	// Specifies whether this IP access list is enabled.
	Enabled *bool
}

type IpAccessListType string

type ListAccountIpAccessListsRequest struct {
	AccountId *string
}

type ListAccountIpAccessListsResponse struct {
	IpAccessLists []AccountIpAccessList
}

type ListEndpointsRequest struct {
	// The parent resource name of the account to list endpoints for. Format:
	// `accounts/{account_id}`.
	Parent    *string
	PageToken *string
	PageSize  *int
}

type ListEndpointsResponse struct {
	Items         []Endpoint
	NextPageToken *string
}

type ListIpAccessLists struct {
}

type ListIpAccessListsResponse struct {
	IpAccessLists []IpAccessList
}

type ListNccPrivateEndpointRulesRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// Your Network Connectvity Configuration ID.
	NetworkConnectivityConfigId *string
	// Pagination token to go to next page based on previous query.
	PageToken *string
}

type ListNccPrivateEndpointRulesResponse struct {
	Items []NccPrivateEndpointRule
	// A token that can be used to get the next page of results. If null, there are
	// no more results to show.
	NextPageToken *string
}

type ListNetworkConnectivityConfigsRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// Pagination token to go to next page based on previous query.
	PageToken *string
}

type ListNetworkConnectivityConfigsResponse struct {
	Items []NetworkConnectivityConfig
	// A token that can be used to get the next page of results. If null, there are
	// no more results to show.
	NextPageToken *string
}

type ListNetworkPoliciesRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// Pagination token to go to next page based on previous query.
	PageToken *string
}

type ListNetworkPoliciesResponse struct {
	// List of network policies.
	Items []AccountNetworkPolicy
	// A token that can be used to get the next page of results. If null, there are
	// no more results to show.
	NextPageToken *string
}

type ListNetworkRequest struct {
	AccountId *string
}

type ListNetworkResponse struct {
	Networks []Network
}

type ListPrivateAccessSettingsRequest struct {
	AccountId *string
}

type ListPrivateAccessSettingsResponse struct {
	PrivateAccessSettings []PrivateAccessSettings
}

type ListVpcEndpointRequest struct {
	AccountId *string
}

type ListVpcEndpointResponse struct {
	VpcEndpoints []VpcEndpoint
}

type NccPrivateEndpointRule struct {
	// The ID of a private endpoint rule.
	RuleId *string
	// The ID of a network connectivity configuration, which is the parent resource
	// of this private endpoint rule object.
	NetworkConnectivityConfigId *string
	// The current status of this private endpoint. The private endpoint rules are
	// effective only if the connection state is ESTABLISHED. Remember that you must
	// approve new endpoints on your resources in the Cloud console before they take
	// effect. The possible values are: - PENDING: The endpoint has been created and
	// pending approval. - ESTABLISHED: The endpoint has been approved and is ready
	// to use in your serverless compute resources. - REJECTED: Connection was
	// rejected by the private link resource owner. - DISCONNECTED: Connection was
	// removed by the private link resource owner, the private endpoint becomes
	// informative and should be deleted for clean-up. - EXPIRED: If the endpoint
	// was created but not approved in 14 days, it will be EXPIRED. - CREATING: The
	// endpoint creation is in progress. Once successfully created, the state will
	// transition to PENDING. - CREATE_FAILED: The endpoint creation failed. You can
	// check the error_message field for more details.
	ConnectionState NccPrivateEndpointRule_PrivateLinkConnectionState
	// Only used by private endpoints to customer-managed private endpoint services.
	//
	// Domain names of target private link service. When updating this field, the
	// full list of target domain_names must be specified.
	DomainNames []string
	// Time in epoch milliseconds when this object was created.
	CreationTime *int64
	// Time in epoch milliseconds when this object was updated.
	UpdatedTime *int64
	// Whether this private endpoint is deactivated.
	Deactivated *bool
	// Time in epoch milliseconds when this object was deactivated.
	DeactivatedAt *int64
	ErrorMessage  *string
	// The Azure resource ID of the target resource.
	ResourceId *string
	// Not used by customer-managed private endpoint services.
	//
	// The sub-resource type (group ID) of the target resource. Note that to connect
	// to workspace root storage (root DBFS), you need two endpoints, one for blob
	// and one for dfs.
	GroupId *string
	// The name of the Azure private endpoint resource.
	EndpointName *string
	// <Databricks> account ID. You can find your account ID from the Accounts
	// Console.
	AccountId *string
	// The full target AWS endpoint service name that connects to the destination
	// resources of the private endpoint.
	EndpointService *string
	// Only used by private endpoints towards AWS S3 service.
	//
	// The globally unique S3 bucket names that will be accessed via the VPC
	// endpoint. The bucket names must be in the same region as the NCC/endpoint
	// service. When updating this field, we perform full update on this field.
	// Please ensure a full list of desired resource_names is provided.
	ResourceNames []string
	// The AWS VPC endpoint ID. You can use this ID to identify the VPC endpoint
	// created by <Databricks>.
	VpcEndpointId *string
	// Update this field to activate/deactivate this private endpoint to allow
	// egress access from serverless compute resources. Only honored for first-party
	// services on each cloud (e.g. AWS S3).
	Enabled  *bool
	Endpoint isNccPrivateEndpointRule_Endpoint
}

type NccPrivateEndpointRule_Endpoint_GcpEndpoint struct {
	GcpEndpoint GcpEndpoint
}

type NccPrivateEndpointRule_PrivateLinkConnectionState string

type Network struct {
	// The <Databricks> network configuration ID.
	NetworkId *string
	// The <Databricks> account ID associated with this network configuration.
	AccountId *string
	// Workspace ID associated with this network configuration.
	WorkspaceId *int64
	// The ID of the VPC associated with this network configuration. VPC IDs can be
	// used in multiple networks.
	VpcId *string
	// IDs of at least two subnets associated with this network. Subnet IDs
	// **cannot** be used in multiple network configurations.
	SubnetIds []string
	// IDs of one to five security groups associated with this network. Security
	// group IDs **cannot** be used in multiple network configurations.
	SecurityGroupIds []string
	VpcStatus        VpcStatus
	// Array of error messages about the network configuration.
	ErrorMessages []NetworkHealth
	// The human-readable name of the network configuration.
	NetworkName *string
	// Time in epoch milliseconds when the network was created.
	CreationTime *int64
	// Array of warning messages about the network configuration.
	WarningMessages []NetworkWarning
	VpcEndpoints    *NetworkVpcEndpoints
	NetworkInfo     isNetwork_NetworkInfo
}

type NetworkConnectivityConfig struct {
	// <Databricks> network connectivity configuration ID.
	NetworkConnectivityConfigId *string
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// The name of the network connectivity configuration. The name can contain
	// alphanumeric characters, hyphens, and underscores. The length must be between
	// 3 and 30 characters. The name must match the regular expression
	// ^[0-9a-zA-Z-_]{3,30}$
	Name *string
	// The region for the network connectivity configuration. Only workspaces in the
	// same region can be attached to the network connectivity configuration.
	Region *string
	// The network connectivity rules that apply to network traffic from your
	// serverless compute resources.
	EgressConfig *CustomerFacingNetworkConnectivityConfigEgressConfig
	// Time in epoch milliseconds when this object was updated.
	UpdatedTime *int64
	// Time in epoch milliseconds when this object was created.
	CreationTime *int64
}

type NetworkConnectivityConfigAwsPrivateEndpointRule struct {
	// The ID of a private endpoint rule.
	RuleId *string
	// The ID of a network connectivity configuration, which is the parent resource
	// of this private endpoint rule object.
	NetworkConnectivityConfigId *string
	// <Databricks> account ID. You can find your account ID from the Accounts
	// Console.
	AccountId *string
	// The full target AWS endpoint service name that connects to the destination
	// resources of the private endpoint.
	EndpointService *string
	// Only used by private endpoints towards a VPC endpoint service for
	// customer-managed VPC endpoint service.
	//
	// The target AWS resource FQDNs accessible via the VPC endpoint service. When
	// updating this field, we perform full update on this field. Please ensure a
	// full list of desired domain_names is provided.
	DomainNames []string
	// Only used by private endpoints towards AWS S3 service.
	//
	// The globally unique S3 bucket names that will be accessed via the VPC
	// endpoint. The bucket names must be in the same region as the NCC/endpoint
	// service. When updating this field, we perform full update on this field.
	// Please ensure a full list of desired resource_names is provided.
	ResourceNames []string
	// The AWS VPC endpoint ID. You can use this ID to identify VPC endpoint created
	// by <Databricks>.
	VpcEndpointId *string
	// The current status of this private endpoint. The private endpoint rules are
	// effective only if the connection state is ESTABLISHED. Remember that you must
	// approve new endpoints on your resources in the AWS console before they take
	// effect. The possible values are: - PENDING: The endpoint has been created and
	// pending approval. - ESTABLISHED: The endpoint has been approved and is ready
	// to use in your serverless compute resources. - REJECTED: Connection was
	// rejected by the private link resource owner. - DISCONNECTED: Connection was
	// removed by the private link resource owner, the private endpoint becomes
	// informative and should be deleted for clean-up. - EXPIRED: If the endpoint is
	// created but not approved in 14 days, it is EXPIRED.
	ConnectionState NetworkConnectivityConfigAwsPrivateEndpointRule_PrivateLinkConnectionState
	// Time in epoch milliseconds when this object was created.
	CreationTime *int64
	// Time in epoch milliseconds when this object was updated.
	UpdatedTime *int64
	// Whether this private endpoint is deactivated.
	Deactivated *bool
	// Time in epoch milliseconds when this object was deactivated.
	DeactivatedAt *int64
	// Only used by private endpoints towards an AWS S3 service.
	//
	// Update this field to activate/deactivate this private endpoint to allow
	// egress access from serverless compute resources.
	Enabled      *bool
	ErrorMessage *string
}

type NetworkConnectivityConfigAwsPrivateEndpointRule_PrivateLinkConnectionState string

type NetworkConnectivityConfigAzurePrivateEndpointRule struct {
	// The ID of a private endpoint rule.
	RuleId *string
	// The ID of a network connectivity configuration, which is the parent resource
	// of this private endpoint rule object.
	NetworkConnectivityConfigId *string
	// The Azure resource ID of the target resource.
	ResourceId *string
	// Only used by private endpoints to Azure first-party services.
	//
	// The sub-resource type (group ID) of the target resource. Note that to connect
	// to workspace root storage (root DBFS), you need two endpoints, one for blob
	// and one for dfs.
	GroupId *string
	// The name of the Azure private endpoint resource.
	EndpointName *string
	// The current status of this private endpoint. The private endpoint rules are
	// effective only if the connection state is ESTABLISHED. Remember that you must
	// approve new endpoints on your resources in the Azure portal before they take
	// effect. The possible values are: - INIT: (deprecated) The endpoint has been
	// created and pending approval. - PENDING: The endpoint has been created and
	// pending approval. - ESTABLISHED: The endpoint has been approved and is ready
	// to use in your serverless compute resources. - REJECTED: Connection was
	// rejected by the private link resource owner. - DISCONNECTED: Connection was
	// removed by the private link resource owner, the private endpoint becomes
	// informative and should be deleted for clean-up. - EXPIRED: If the endpoint
	// was created but not approved in 14 days, it will be EXPIRED.
	ConnectionState NetworkConnectivityConfigAzurePrivateEndpointRule_PrivateLinkConnectionState
	// Time in epoch milliseconds when this object was created.
	CreationTime *int64
	// Time in epoch milliseconds when this object was updated.
	UpdatedTime *int64
	// Whether this private endpoint is deactivated.
	Deactivated *bool
	// Time in epoch milliseconds when this object was deactivated.
	DeactivatedAt *int64
	// Not used by customer-managed private endpoint services.
	//
	// Domain names of target private link service. When updating this field, the
	// full list of target domain_names must be specified.
	DomainNames  []string
	ErrorMessage *string
}

type NetworkConnectivityConfigAzurePrivateEndpointRule_PrivateLinkConnectionState string

type NetworkConnectivityConfigEgressConfig struct {
}

type NetworkConnectivityConfigEgressConfig_DefaultRule struct {
	AzureServiceEndpointRule *NetworkConnectivityConfigEgressConfig_DefaultRule_AzureServiceEndpointRule
	AwsStableIpRule          *NetworkConnectivityConfigEgressConfig_DefaultRule_AwsStableIpRule
}

type NetworkConnectivityConfigEgressConfig_DefaultRule_AwsStableIpRule struct {
	// The list of stable IP CIDR blocks from which <Databricks> network traffic
	// originates when accessing your resources.
	CidrBlocks []string
}

type NetworkConnectivityConfigEgressConfig_DefaultRule_AzureServiceEndpointRule struct {
	// The Azure region in which this service endpoint rule applies..
	TargetRegion *string
	// The Azure services to which this service endpoint rule applies to.
	TargetServices []EgressResourceType
	// The list of subnets from which <Databricks> network traffic originates when
	// accessing your Azure resources.
	Subnets []string
}

type NetworkHealth struct {
	ErrorType *string
	// Details of the error.
	ErrorMessage *string
}

type NetworkVpcEndpoints struct {
	// The VPC endpoint ID used by this network to access the Databricks REST API.
	RestApi []string
	// The VPC endpoint ID used by this network to access the <Databricks> secure
	// cluster connectivity relay.
	DataplaneRelay []string
}

type NetworkWarning struct {
	WarningType *string
	// Details of the warning.
	WarningMessage *string
}

type Network_NetworkInfo_GcpNetworkInfo struct {
	GcpNetworkInfo GcpNetworkInfo
}

type PrivateAccessLevel string

type PrivateAccessSettings struct {
	// <Databricks> private access settings ID.
	PrivateAccessSettingsId *string
	// The <Databricks> account ID that hosts the private access settings.
	AccountId *string
	// The human-readable name of the private access settings object.
	PrivateAccessSettingsName *string
	// The AWS region for workspaces attached to this private access settings
	// object.
	Region *string
	// Determines if the workspace can be accessed over public internet. For fully
	// private workspaces, you can optionally specify false, but only if you
	// implement both the front-end and the back-end PrivateLink connections.
	// Otherwise, specify true, which means that public access is enabled.
	PublicAccessEnabled *bool
	// The private access level controls which VPC endpoints can connect to the UI
	// or API of any workspace that attaches this private access settings object.
	// `ACCOUNT` level access (the default) allows only VPC endpoints that are
	// registered in your <Databricks> account connect to your workspace. `ENDPOINT`
	// level access allows only specified VPC endpoints connect to your workspace.
	// For details, see allowed_vpc_endpoint_ids.
	PrivateAccessLevel PrivateAccessLevel
	// An array of Databricks VPC endpoint IDs. This is the <Databricks> ID that is
	// returned when registering the VPC endpoint configuration in your <Databricks>
	// account. This is not the ID of the VPC endpoint in AWS. Only used when
	// private_access_level is set to ENDPOINT. This is an allow list of VPC
	// endpoints that in your account that can connect to your workspace over AWS
	// PrivateLink. If hybrid access to your workspace is enabled by setting
	// public_access_enabled to true, this control only works for PrivateLink
	// connections. To control how your workspace is accessed via public internet,
	// see IP access lists.
	AllowedVpcEndpointIds []string
}

type ReplaceAccountIpAccessListRequest struct {
	AccountId *string
	// The ID for the corresponding IP access list
	ListId *string
	// Label for the IP access list. This **cannot** be empty.
	Label       *string
	ListType    AccountIpAccessListType_IpAccessListType
	IpAddresses []string
	// Specifies whether this IP access list is enabled.
	Enabled *bool
}

type ReplaceAccountIpAccessListResponse struct {
	IpAccessList *AccountIpAccessList
}

type ReplaceIpAccessListRequest struct {
	// The ID for the corresponding IP access list
	ListId *string
	// Label for the IP access list. This **cannot** be empty.
	Label       *string
	ListType    IpAccessListType
	IpAddresses []string
	// Specifies whether this IP access list is enabled.
	Enabled *bool
}

type ReplaceIpAccessListResponse struct {
	IpAccessList *IpAccessList
}

type UpdateAccountIpAccessListRequest struct {
	AccountId *string
	// The ID for the corresponding IP access list
	ListId *string
	// Label for the IP access list. This **cannot** be empty.
	Label       *string
	ListType    AccountIpAccessListType_IpAccessListType
	IpAddresses []string
	// Specifies whether this IP access list is enabled.
	Enabled *bool
}

type UpdateAccountIpAccessListResponse struct {
	IpAccessList *AccountIpAccessList
}

type UpdateIpAccessListRequest struct {
	// The ID for the corresponding IP access list
	ListId *string
	// Label for the IP access list. This **cannot** be empty.
	Label       *string
	ListType    IpAccessListType
	IpAddresses []string
	// Specifies whether this IP access list is enabled.
	Enabled *bool
}

type UpdateIpAccessListResponse struct {
	IpAccessList *IpAccessList
}

type UpdateNccPrivateEndpointRuleRequest struct {
	// The ID of a network connectivity configuration, which is the parent resource
	// of this private endpoint rule object.
	NetworkConnectivityConfigId *string
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// Your private endpoint rule ID.
	PrivateEndpointRuleId *string
	PrivateEndpointRule   *UpdatePrivateEndpointRule
	UpdateMask            *types.FieldMask[UpdatePrivateEndpointRule]
}

type UpdateNetworkPolicyRequest struct {
	// The unique identifier for the network policy.
	NetworkPolicyId *string
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// Updated network policy configuration details.
	NetworkPolicy *AccountNetworkPolicy
}

type UpdatePrivateAccessSettingsRequest struct {
	// Properties of the new private access settings object.
	CustomerFacingPrivateAccessSettings *PrivateAccessSettings
}

type UpdatePrivateEndpointRule struct {
	// The ID of a private endpoint rule.
	RuleId *string `fieldmask:"rule_id"`
	// The ID of a network connectivity configuration, which is the parent resource
	// of this private endpoint rule object.
	NetworkConnectivityConfigId *string `fieldmask:"network_connectivity_config_id"`
	// The current status of this private endpoint. The private endpoint rules are
	// effective only if the connection state is ESTABLISHED. Remember that you must
	// approve new endpoints on your resources in the Cloud console before they take
	// effect. The possible values are: - PENDING: The endpoint has been created and
	// pending approval. - ESTABLISHED: The endpoint has been approved and is ready
	// to use in your serverless compute resources. - REJECTED: Connection was
	// rejected by the private link resource owner. - DISCONNECTED: Connection was
	// removed by the private link resource owner, the private endpoint becomes
	// informative and should be deleted for clean-up. - EXPIRED: If the endpoint
	// was created but not approved in 14 days, it will be EXPIRED. - CREATING: The
	// endpoint creation is in progress. Once successfully created, the state will
	// transition to PENDING. - CREATE_FAILED: The endpoint creation failed. You can
	// check the error_message field for more details.
	ConnectionState NccPrivateEndpointRule_PrivateLinkConnectionState `fieldmask:"connection_state"`
	// Only used by private endpoints to customer-managed private endpoint services.
	//
	// Domain names of target private link service. When updating this field, the
	// full list of target domain_names must be specified.
	DomainNames []string `fieldmask:"domain_names"`
	// Time in epoch milliseconds when this object was created.
	CreationTime *int64 `fieldmask:"creation_time"`
	// Time in epoch milliseconds when this object was updated.
	UpdatedTime *int64 `fieldmask:"updated_time"`
	// Whether this private endpoint is deactivated.
	Deactivated *bool `fieldmask:"deactivated"`
	// Time in epoch milliseconds when this object was deactivated.
	DeactivatedAt *int64  `fieldmask:"deactivated_at"`
	ErrorMessage  *string `fieldmask:"error_message"`
	// The Azure resource ID of the target resource.
	ResourceId *string `fieldmask:"resource_id"`
	// Not used by customer-managed private endpoint services.
	//
	// The sub-resource type (group ID) of the target resource. Note that to connect
	// to workspace root storage (root DBFS), you need two endpoints, one for blob
	// and one for dfs.
	GroupId *string `fieldmask:"group_id"`
	// The name of the Azure private endpoint resource.
	EndpointName *string `fieldmask:"endpoint_name"`
	// <Databricks> account ID. You can find your account ID from the Accounts
	// Console.
	AccountId *string `fieldmask:"account_id"`
	// The full target AWS endpoint service name that connects to the destination
	// resources of the private endpoint.
	EndpointService *string `fieldmask:"endpoint_service"`
	// Only used by private endpoints towards AWS S3 service.
	//
	// The globally unique S3 bucket names that will be accessed via the VPC
	// endpoint. The bucket names must be in the same region as the NCC/endpoint
	// service. When updating this field, we perform full update on this field.
	// Please ensure a full list of desired resource_names is provided.
	ResourceNames []string `fieldmask:"resource_names"`
	// The AWS VPC endpoint ID. You can use this ID to identify the VPC endpoint
	// created by <Databricks>.
	VpcEndpointId *string `fieldmask:"vpc_endpoint_id"`
	// Update this field to activate/deactivate this private endpoint to allow
	// egress access from serverless compute resources. Only honored for first-party
	// services on each cloud (e.g. AWS S3).
	Enabled  *bool `fieldmask:"enabled"`
	Endpoint isUpdatePrivateEndpointRule_Endpoint
	// contains filtered or unexported fields
}

type UpdatePrivateEndpointRule_Endpoint_GcpEndpoint struct {
	GcpEndpoint GcpEndpoint `fieldmask:"gcp_endpoint"`
}

type UpdateWorkspaceNetworkOptionRequest struct {
	// Your <Databricks> account ID. You can find your account ID in your
	// <Databricks> accounts console.
	AccountId *string
	// The workspace ID.
	WorkspaceId *int64
	// The network option details for the workspace.
	WorkspaceNetworkOption *WorkspaceNetworkOption
}

type VpcEndpoint struct {
	// Databricks VPC endpoint ID. This is the <Databricks>-specific name of the VPC
	// endpoint. Do not confuse this with the `aws_vpc_endpoint_id`, which is the ID
	// within AWS of the VPC endpoint.
	VpcEndpointId *string
	// The <Databricks> account ID that hosts the VPC endpoint configuration.
	AccountId *string
	// The human-readable name of the storage configuration.
	VpcEndpointName *string
	// The ID of the VPC endpoint object in AWS.
	AwsVpcEndpointId *string
	// The ID of the <Databricks> [endpoint service] that this VPC endpoint is
	// connected to. For a list of endpoint service IDs for each supported AWS
	// region, see the [Databricks PrivateLink documentation].
	//
	// [Databricks PrivateLink documentation]: https://docs.databricks.com/administration-guide/cloud-configurations/aws/privatelink.html
	// [endpoint service]: https://docs.aws.amazon.com/vpc/latest/privatelink/endpoint-service.html
	AwsEndpointServiceId *string
	// This enumeration represents the type of Databricks VPC endpoint service that
	// was used when creating this VPC endpoint. If the VPC endpoint connects to the
	// <Databricks> control plane for either the front-end connection or the
	// back-end REST API connection, the value is GENERAL_ACCESS. If the VPC
	// endpoint connects to the <Databricks> workspace for the back-end secure
	// cluster connectivity relay, the value is DATAPLANE_RELAY_ACCESS.
	UseCase VpcEndpointUseCase
	// The AWS region in which this VPC endpoint object exists.
	Region *string
	// The AWS Account in which the VPC endpoint object exists.
	AwsAccountId *string
	// The current state (such as `available` or `rejected`) of the VPC endpoint.
	// Derived from AWS. For the full set of values, see [AWS DescribeVpcEndpoint
	// documentation].
	//
	// [AWS DescribeVpcEndpoint documentation]: https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-vpc-endpoints.html
	State           *string
	VpcEndpointInfo isVpcEndpoint_VpcEndpointInfo
}

type VpcEndpointUseCase string

type VpcEndpoint_VpcEndpointInfo_GcpVpcEndpointInfo struct {
	GcpVpcEndpointInfo GcpVpcEndpointInfo
}

type VpcStatus string

type WorkspaceNetworkOption struct {
	// The network policy ID to apply to the workspace. This controls the network
	// access rules for all serverless compute resources in the workspace. Each
	// workspace can only be linked to one policy at a time. If no policy is
	// explicitly assigned, the workspace will use 'default-policy'.
	NetworkPolicyId *string
	// The workspace ID.
	WorkspaceId *int64
}