From b7a7288ae241fe114aee401b7a9da35f6a718e37 Mon Sep 17 00:00:00 2001 From: Omer Lachish Date: Tue, 15 Oct 2024 15:25:20 +0200 Subject: [PATCH 1/2] ran genkit generate-sdk terraform --- .codegen/_openapi_sha | 2 +- internal/service/apps_tf/model.go | 302 ++++- internal/service/billing_tf/model.go | 222 ++++ internal/service/catalog_tf/model.go | 1337 ++++++++++++++++++++- internal/service/compute_tf/model.go | 1074 +++++++++++++++++ internal/service/dashboards_tf/model.go | 692 ++++++++++- internal/service/files_tf/model.go | 216 ++++ internal/service/iam_tf/model.go | 408 +++++++ internal/service/jobs_tf/model.go | 819 +++++++++++++ internal/service/marketplace_tf/model.go | 678 +++++++++++ internal/service/ml_tf/model.go | 966 +++++++++++++++ internal/service/oauth2_tf/model.go | 192 +++ internal/service/pipelines_tf/model.go | 372 +++++- internal/service/provisioning_tf/model.go | 384 +++++- internal/service/serving_tf/model.go | 444 +++++++ internal/service/settings_tf/model.go | 955 ++++++++++++++- internal/service/sharing_tf/model.go | 428 ++++++- internal/service/sql_tf/model.go | 896 ++++++++++++++ internal/service/vectorsearch_tf/model.go | 258 ++++ internal/service/workspace_tf/model.go | 462 +++++++ 20 files changed, 10998 insertions(+), 109 deletions(-) diff --git a/.codegen/_openapi_sha b/.codegen/_openapi_sha index 303c785539..2d9cb6d86d 100644 --- a/.codegen/_openapi_sha +++ b/.codegen/_openapi_sha @@ -1 +1 @@ -0c86ea6dbd9a730c24ff0d4e509603e476955ac5 \ No newline at end of file +cf9c61453990df0f9453670f2fe68e1b128647a2 \ No newline at end of file diff --git a/internal/service/apps_tf/model.go b/internal/service/apps_tf/model.go index 0b4c6101e2..2c5594a1ec 100755 --- a/internal/service/apps_tf/model.go +++ b/internal/service/apps_tf/model.go @@ -15,16 +15,19 @@ import ( ) type App struct { - // The active deployment of the app. + // The active deployment of the app. A deployment is considered active when + // it has been deployed to the app compute. ActiveDeployment []AppDeployment `tfsdk:"active_deployment" tf:"optional,object"` AppStatus []ApplicationStatus `tfsdk:"app_status" tf:"optional,object"` ComputeStatus []ComputeStatus `tfsdk:"compute_status" tf:"optional,object"` // The creation time of the app. Formatted timestamp in ISO 6801. - CreateTime types.String `tfsdk:"create_time" tf:"optional"` + CreateTime types.String `tfsdk:"create_time" tf:"optional"` + EffectiveCreateTime types.String `tfsdk:"effective_create_time" tf:"computed,optional"` // The email of the user that created the app. - Creator types.String `tfsdk:"creator" tf:"optional"` + Creator types.String `tfsdk:"creator" tf:"optional"` + EffectiveCreator types.String `tfsdk:"effective_creator" tf:"computed,optional"` // The default workspace file system path of the source code from which app // deployment are created. This field tracks the workspace source code path // of the last active deployment. @@ -34,20 +37,67 @@ type App struct { // The name of the app. The name must contain only lowercase alphanumeric // characters and hyphens. It must be unique within the workspace. Name types.String `tfsdk:"name" tf:""` - // The pending deployment of the app. + // The pending deployment of the app. A deployment is considered pending + // when it is being prepared for deployment to the app compute. PendingDeployment []AppDeployment `tfsdk:"pending_deployment" tf:"optional,object"` // Resources for the app. Resources []AppResource `tfsdk:"resources" tf:"optional"` - ServicePrincipalId types.Int64 `tfsdk:"service_principal_id" tf:"optional"` + ServicePrincipalId types.Int64 `tfsdk:"service_principal_id" tf:"optional"` + EffectiveServicePrincipalId types.Int64 `tfsdk:"effective_service_principal_id" tf:"computed,optional"` - ServicePrincipalName types.String `tfsdk:"service_principal_name" tf:"optional"` + ServicePrincipalName types.String `tfsdk:"service_principal_name" tf:"optional"` + EffectiveServicePrincipalName types.String `tfsdk:"effective_service_principal_name" tf:"computed,optional"` // The update time of the app. Formatted timestamp in ISO 6801. - UpdateTime types.String `tfsdk:"update_time" tf:"optional"` + UpdateTime types.String `tfsdk:"update_time" tf:"optional"` + EffectiveUpdateTime types.String `tfsdk:"effective_update_time" tf:"computed,optional"` // The email of the user that last updated the app. - Updater types.String `tfsdk:"updater" tf:"optional"` + Updater types.String `tfsdk:"updater" tf:"optional"` + EffectiveUpdater types.String `tfsdk:"effective_updater" tf:"computed,optional"` // The URL of the app once it is deployed. - Url types.String `tfsdk:"url" tf:"optional"` + Url types.String `tfsdk:"url" tf:"optional"` + EffectiveUrl types.String `tfsdk:"effective_url" tf:"computed,optional"` +} + +func (newState *App) SyncEffectiveFieldsDuringCreateOrUpdate(plan App) { + newState.EffectiveCreateTime = newState.CreateTime + newState.CreateTime = plan.CreateTime + newState.EffectiveCreator = newState.Creator + newState.Creator = plan.Creator + newState.EffectiveServicePrincipalId = newState.ServicePrincipalId + newState.ServicePrincipalId = plan.ServicePrincipalId + newState.EffectiveServicePrincipalName = newState.ServicePrincipalName + newState.ServicePrincipalName = plan.ServicePrincipalName + newState.EffectiveUpdateTime = newState.UpdateTime + newState.UpdateTime = plan.UpdateTime + newState.EffectiveUpdater = newState.Updater + newState.Updater = plan.Updater + newState.EffectiveUrl = newState.Url + newState.Url = plan.Url +} + +func (newState *App) SyncEffectiveFieldsDuringRead(existingState App) { + if existingState.EffectiveCreateTime.ValueString() == newState.CreateTime.ValueString() { + newState.CreateTime = existingState.CreateTime + } + if existingState.EffectiveCreator.ValueString() == newState.Creator.ValueString() { + newState.Creator = existingState.Creator + } + if existingState.EffectiveServicePrincipalId.ValueInt64() == newState.ServicePrincipalId.ValueInt64() { + newState.ServicePrincipalId = existingState.ServicePrincipalId + } + if existingState.EffectiveServicePrincipalName.ValueString() == newState.ServicePrincipalName.ValueString() { + newState.ServicePrincipalName = existingState.ServicePrincipalName + } + if existingState.EffectiveUpdateTime.ValueString() == newState.UpdateTime.ValueString() { + newState.UpdateTime = existingState.UpdateTime + } + if existingState.EffectiveUpdater.ValueString() == newState.Updater.ValueString() { + newState.Updater = existingState.Updater + } + if existingState.EffectiveUrl.ValueString() == newState.Url.ValueString() { + newState.Url = existingState.Url + } } type AppAccessControlRequest struct { @@ -61,6 +111,12 @@ type AppAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *AppAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppAccessControlRequest) { +} + +func (newState *AppAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState AppAccessControlRequest) { +} + type AppAccessControlResponse struct { // All permissions. AllPermissions []AppPermission `tfsdk:"all_permissions" tf:"optional"` @@ -74,11 +130,19 @@ type AppAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *AppAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppAccessControlResponse) { +} + +func (newState *AppAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState AppAccessControlResponse) { +} + type AppDeployment struct { // The creation time of the deployment. Formatted timestamp in ISO 6801. - CreateTime types.String `tfsdk:"create_time" tf:"optional"` + CreateTime types.String `tfsdk:"create_time" tf:"optional"` + EffectiveCreateTime types.String `tfsdk:"effective_create_time" tf:"computed,optional"` // The email of the user creates the deployment. - Creator types.String `tfsdk:"creator" tf:"optional"` + Creator types.String `tfsdk:"creator" tf:"optional"` + EffectiveCreator types.String `tfsdk:"effective_creator" tf:"computed,optional"` // The deployment artifacts for an app. DeploymentArtifacts []AppDeploymentArtifacts `tfsdk:"deployment_artifacts" tf:"optional,object"` // The unique id of the deployment. @@ -96,7 +160,29 @@ type AppDeployment struct { // Status and status message of the deployment Status []AppDeploymentStatus `tfsdk:"status" tf:"optional,object"` // The update time of the deployment. Formatted timestamp in ISO 6801. - UpdateTime types.String `tfsdk:"update_time" tf:"optional"` + UpdateTime types.String `tfsdk:"update_time" tf:"optional"` + EffectiveUpdateTime types.String `tfsdk:"effective_update_time" tf:"computed,optional"` +} + +func (newState *AppDeployment) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppDeployment) { + newState.EffectiveCreateTime = newState.CreateTime + newState.CreateTime = plan.CreateTime + newState.EffectiveCreator = newState.Creator + newState.Creator = plan.Creator + newState.EffectiveUpdateTime = newState.UpdateTime + newState.UpdateTime = plan.UpdateTime +} + +func (newState *AppDeployment) SyncEffectiveFieldsDuringRead(existingState AppDeployment) { + if existingState.EffectiveCreateTime.ValueString() == newState.CreateTime.ValueString() { + newState.CreateTime = existingState.CreateTime + } + if existingState.EffectiveCreator.ValueString() == newState.Creator.ValueString() { + newState.Creator = existingState.Creator + } + if existingState.EffectiveUpdateTime.ValueString() == newState.UpdateTime.ValueString() { + newState.UpdateTime = existingState.UpdateTime + } } type AppDeploymentArtifacts struct { @@ -105,13 +191,31 @@ type AppDeploymentArtifacts struct { SourceCodePath types.String `tfsdk:"source_code_path" tf:"optional"` } +func (newState *AppDeploymentArtifacts) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppDeploymentArtifacts) { +} + +func (newState *AppDeploymentArtifacts) SyncEffectiveFieldsDuringRead(existingState AppDeploymentArtifacts) { +} + type AppDeploymentStatus struct { // Message corresponding with the deployment state. - Message types.String `tfsdk:"message" tf:"optional"` + Message types.String `tfsdk:"message" tf:"optional"` + EffectiveMessage types.String `tfsdk:"effective_message" tf:"computed,optional"` // State of the deployment. State types.String `tfsdk:"state" tf:"optional"` } +func (newState *AppDeploymentStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppDeploymentStatus) { + newState.EffectiveMessage = newState.Message + newState.Message = plan.Message +} + +func (newState *AppDeploymentStatus) SyncEffectiveFieldsDuringRead(existingState AppDeploymentStatus) { + if existingState.EffectiveMessage.ValueString() == newState.Message.ValueString() { + newState.Message = existingState.Message + } +} + type AppPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -120,6 +224,12 @@ type AppPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *AppPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppPermission) { +} + +func (newState *AppPermission) SyncEffectiveFieldsDuringRead(existingState AppPermission) { +} + type AppPermissions struct { AccessControlList []AppAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -128,18 +238,36 @@ type AppPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *AppPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppPermissions) { +} + +func (newState *AppPermissions) SyncEffectiveFieldsDuringRead(existingState AppPermissions) { +} + type AppPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *AppPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppPermissionsDescription) { +} + +func (newState *AppPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState AppPermissionsDescription) { +} + type AppPermissionsRequest struct { AccessControlList []AppAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The app for which to get or manage permissions. AppName types.String `tfsdk:"-"` } +func (newState *AppPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppPermissionsRequest) { +} + +func (newState *AppPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState AppPermissionsRequest) { +} + type AppResource struct { // Description of the App Resource. Description types.String `tfsdk:"description" tf:"optional"` @@ -155,6 +283,12 @@ type AppResource struct { SqlWarehouse []AppResourceSqlWarehouse `tfsdk:"sql_warehouse" tf:"optional,object"` } +func (newState *AppResource) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppResource) { +} + +func (newState *AppResource) SyncEffectiveFieldsDuringRead(existingState AppResource) { +} + type AppResourceJob struct { // Id of the job to grant permission on. Id types.String `tfsdk:"id" tf:""` @@ -163,6 +297,12 @@ type AppResourceJob struct { Permission types.String `tfsdk:"permission" tf:""` } +func (newState *AppResourceJob) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppResourceJob) { +} + +func (newState *AppResourceJob) SyncEffectiveFieldsDuringRead(existingState AppResourceJob) { +} + type AppResourceSecret struct { // Key of the secret to grant permission on. Key types.String `tfsdk:"key" tf:""` @@ -173,6 +313,12 @@ type AppResourceSecret struct { Scope types.String `tfsdk:"scope" tf:""` } +func (newState *AppResourceSecret) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppResourceSecret) { +} + +func (newState *AppResourceSecret) SyncEffectiveFieldsDuringRead(existingState AppResourceSecret) { +} + type AppResourceServingEndpoint struct { // Name of the serving endpoint to grant permission on. Name types.String `tfsdk:"name" tf:""` @@ -181,6 +327,12 @@ type AppResourceServingEndpoint struct { Permission types.String `tfsdk:"permission" tf:""` } +func (newState *AppResourceServingEndpoint) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppResourceServingEndpoint) { +} + +func (newState *AppResourceServingEndpoint) SyncEffectiveFieldsDuringRead(existingState AppResourceServingEndpoint) { +} + type AppResourceSqlWarehouse struct { // Id of the SQL warehouse to grant permission on. Id types.String `tfsdk:"id" tf:""` @@ -189,20 +341,50 @@ type AppResourceSqlWarehouse struct { Permission types.String `tfsdk:"permission" tf:""` } +func (newState *AppResourceSqlWarehouse) SyncEffectiveFieldsDuringCreateOrUpdate(plan AppResourceSqlWarehouse) { +} + +func (newState *AppResourceSqlWarehouse) SyncEffectiveFieldsDuringRead(existingState AppResourceSqlWarehouse) { +} + type ApplicationStatus struct { // Application status message - Message types.String `tfsdk:"message" tf:"optional"` + Message types.String `tfsdk:"message" tf:"optional"` + EffectiveMessage types.String `tfsdk:"effective_message" tf:"computed,optional"` // State of the application. State types.String `tfsdk:"state" tf:"optional"` } +func (newState *ApplicationStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan ApplicationStatus) { + newState.EffectiveMessage = newState.Message + newState.Message = plan.Message +} + +func (newState *ApplicationStatus) SyncEffectiveFieldsDuringRead(existingState ApplicationStatus) { + if existingState.EffectiveMessage.ValueString() == newState.Message.ValueString() { + newState.Message = existingState.Message + } +} + type ComputeStatus struct { // Compute status message - Message types.String `tfsdk:"message" tf:"optional"` + Message types.String `tfsdk:"message" tf:"optional"` + EffectiveMessage types.String `tfsdk:"effective_message" tf:"computed,optional"` // State of the app compute. State types.String `tfsdk:"state" tf:"optional"` } +func (newState *ComputeStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan ComputeStatus) { + newState.EffectiveMessage = newState.Message + newState.Message = plan.Message +} + +func (newState *ComputeStatus) SyncEffectiveFieldsDuringRead(existingState ComputeStatus) { + if existingState.EffectiveMessage.ValueString() == newState.Message.ValueString() { + newState.Message = existingState.Message + } +} + type CreateAppDeploymentRequest struct { // The name of the app. AppName types.String `tfsdk:"-"` @@ -220,6 +402,12 @@ type CreateAppDeploymentRequest struct { SourceCodePath types.String `tfsdk:"source_code_path" tf:"optional"` } +func (newState *CreateAppDeploymentRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateAppDeploymentRequest) { +} + +func (newState *CreateAppDeploymentRequest) SyncEffectiveFieldsDuringRead(existingState CreateAppDeploymentRequest) { +} + type CreateAppRequest struct { // The description of the app. Description types.String `tfsdk:"description" tf:"optional"` @@ -230,12 +418,24 @@ type CreateAppRequest struct { Resources []AppResource `tfsdk:"resources" tf:"optional"` } +func (newState *CreateAppRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateAppRequest) { +} + +func (newState *CreateAppRequest) SyncEffectiveFieldsDuringRead(existingState CreateAppRequest) { +} + // Delete an app type DeleteAppRequest struct { // The name of the app. Name types.String `tfsdk:"-"` } +func (newState *DeleteAppRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAppRequest) { +} + +func (newState *DeleteAppRequest) SyncEffectiveFieldsDuringRead(existingState DeleteAppRequest) { +} + // Get an app deployment type GetAppDeploymentRequest struct { // The name of the app. @@ -244,29 +444,59 @@ type GetAppDeploymentRequest struct { DeploymentId types.String `tfsdk:"-"` } +func (newState *GetAppDeploymentRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAppDeploymentRequest) { +} + +func (newState *GetAppDeploymentRequest) SyncEffectiveFieldsDuringRead(existingState GetAppDeploymentRequest) { +} + // Get app permission levels type GetAppPermissionLevelsRequest struct { // The app for which to get or manage permissions. AppName types.String `tfsdk:"-"` } +func (newState *GetAppPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAppPermissionLevelsRequest) { +} + +func (newState *GetAppPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetAppPermissionLevelsRequest) { +} + type GetAppPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []AppPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetAppPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAppPermissionLevelsResponse) { +} + +func (newState *GetAppPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetAppPermissionLevelsResponse) { +} + // Get app permissions type GetAppPermissionsRequest struct { // The app for which to get or manage permissions. AppName types.String `tfsdk:"-"` } +func (newState *GetAppPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAppPermissionsRequest) { +} + +func (newState *GetAppPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetAppPermissionsRequest) { +} + // Get an app type GetAppRequest struct { // The name of the app. Name types.String `tfsdk:"-"` } +func (newState *GetAppRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAppRequest) { +} + +func (newState *GetAppRequest) SyncEffectiveFieldsDuringRead(existingState GetAppRequest) { +} + // List app deployments type ListAppDeploymentsRequest struct { // The name of the app. @@ -278,6 +508,12 @@ type ListAppDeploymentsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListAppDeploymentsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAppDeploymentsRequest) { +} + +func (newState *ListAppDeploymentsRequest) SyncEffectiveFieldsDuringRead(existingState ListAppDeploymentsRequest) { +} + type ListAppDeploymentsResponse struct { // Deployment history of the app. AppDeployments []AppDeployment `tfsdk:"app_deployments" tf:"optional"` @@ -285,6 +521,12 @@ type ListAppDeploymentsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListAppDeploymentsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAppDeploymentsResponse) { +} + +func (newState *ListAppDeploymentsResponse) SyncEffectiveFieldsDuringRead(existingState ListAppDeploymentsResponse) { +} + // List apps type ListAppsRequest struct { // Upper bound for items returned. @@ -294,22 +536,46 @@ type ListAppsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListAppsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAppsRequest) { +} + +func (newState *ListAppsRequest) SyncEffectiveFieldsDuringRead(existingState ListAppsRequest) { +} + type ListAppsResponse struct { Apps []App `tfsdk:"apps" tf:"optional"` // Pagination token to request the next page of apps. NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListAppsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAppsResponse) { +} + +func (newState *ListAppsResponse) SyncEffectiveFieldsDuringRead(existingState ListAppsResponse) { +} + type StartAppRequest struct { // The name of the app. Name types.String `tfsdk:"-"` } +func (newState *StartAppRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan StartAppRequest) { +} + +func (newState *StartAppRequest) SyncEffectiveFieldsDuringRead(existingState StartAppRequest) { +} + type StopAppRequest struct { // The name of the app. Name types.String `tfsdk:"-"` } +func (newState *StopAppRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan StopAppRequest) { +} + +func (newState *StopAppRequest) SyncEffectiveFieldsDuringRead(existingState StopAppRequest) { +} + type UpdateAppRequest struct { // The description of the app. Description types.String `tfsdk:"description" tf:"optional"` @@ -319,3 +585,9 @@ type UpdateAppRequest struct { // Resources for the app. Resources []AppResource `tfsdk:"resources" tf:"optional"` } + +func (newState *UpdateAppRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateAppRequest) { +} + +func (newState *UpdateAppRequest) SyncEffectiveFieldsDuringRead(existingState UpdateAppRequest) { +} diff --git a/internal/service/billing_tf/model.go b/internal/service/billing_tf/model.go index f2a63fde2b..4aecb90bb0 100755 --- a/internal/service/billing_tf/model.go +++ b/internal/service/billing_tf/model.go @@ -25,6 +25,12 @@ type ActionConfiguration struct { Target types.String `tfsdk:"target" tf:"optional"` } +func (newState *ActionConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan ActionConfiguration) { +} + +func (newState *ActionConfiguration) SyncEffectiveFieldsDuringRead(existingState ActionConfiguration) { +} + type AlertConfiguration struct { // Configured actions for this alert. These define what happens when an // alert enters a triggered state. @@ -44,6 +50,12 @@ type AlertConfiguration struct { TriggerType types.String `tfsdk:"trigger_type" tf:"optional"` } +func (newState *AlertConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan AlertConfiguration) { +} + +func (newState *AlertConfiguration) SyncEffectiveFieldsDuringRead(existingState AlertConfiguration) { +} + type BudgetConfiguration struct { // Databricks account ID. AccountId types.String `tfsdk:"account_id" tf:"optional"` @@ -65,6 +77,12 @@ type BudgetConfiguration struct { UpdateTime types.Int64 `tfsdk:"update_time" tf:"optional"` } +func (newState *BudgetConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan BudgetConfiguration) { +} + +func (newState *BudgetConfiguration) SyncEffectiveFieldsDuringRead(existingState BudgetConfiguration) { +} + type BudgetConfigurationFilter struct { // A list of tag keys and values that will limit the budget to usage that // includes those specific custom tags. Tags are case-sensitive and should @@ -74,24 +92,48 @@ type BudgetConfigurationFilter struct { WorkspaceId []BudgetConfigurationFilterWorkspaceIdClause `tfsdk:"workspace_id" tf:"optional,object"` } +func (newState *BudgetConfigurationFilter) SyncEffectiveFieldsDuringCreateOrUpdate(plan BudgetConfigurationFilter) { +} + +func (newState *BudgetConfigurationFilter) SyncEffectiveFieldsDuringRead(existingState BudgetConfigurationFilter) { +} + type BudgetConfigurationFilterClause struct { Operator types.String `tfsdk:"operator" tf:"optional"` Values []types.String `tfsdk:"values" tf:"optional"` } +func (newState *BudgetConfigurationFilterClause) SyncEffectiveFieldsDuringCreateOrUpdate(plan BudgetConfigurationFilterClause) { +} + +func (newState *BudgetConfigurationFilterClause) SyncEffectiveFieldsDuringRead(existingState BudgetConfigurationFilterClause) { +} + type BudgetConfigurationFilterTagClause struct { Key types.String `tfsdk:"key" tf:"optional"` Value []BudgetConfigurationFilterClause `tfsdk:"value" tf:"optional,object"` } +func (newState *BudgetConfigurationFilterTagClause) SyncEffectiveFieldsDuringCreateOrUpdate(plan BudgetConfigurationFilterTagClause) { +} + +func (newState *BudgetConfigurationFilterTagClause) SyncEffectiveFieldsDuringRead(existingState BudgetConfigurationFilterTagClause) { +} + type BudgetConfigurationFilterWorkspaceIdClause struct { Operator types.String `tfsdk:"operator" tf:"optional"` Values []types.Int64 `tfsdk:"values" tf:"optional"` } +func (newState *BudgetConfigurationFilterWorkspaceIdClause) SyncEffectiveFieldsDuringCreateOrUpdate(plan BudgetConfigurationFilterWorkspaceIdClause) { +} + +func (newState *BudgetConfigurationFilterWorkspaceIdClause) SyncEffectiveFieldsDuringRead(existingState BudgetConfigurationFilterWorkspaceIdClause) { +} + type CreateBillingUsageDashboardRequest struct { // Workspace level usage dashboard shows usage data for the specified // workspace ID. Global level usage dashboard shows usage data for all @@ -102,11 +144,23 @@ type CreateBillingUsageDashboardRequest struct { WorkspaceId types.Int64 `tfsdk:"workspace_id" tf:"optional"` } +func (newState *CreateBillingUsageDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateBillingUsageDashboardRequest) { +} + +func (newState *CreateBillingUsageDashboardRequest) SyncEffectiveFieldsDuringRead(existingState CreateBillingUsageDashboardRequest) { +} + type CreateBillingUsageDashboardResponse struct { // The unique id of the usage dashboard. DashboardId types.String `tfsdk:"dashboard_id" tf:"optional"` } +func (newState *CreateBillingUsageDashboardResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateBillingUsageDashboardResponse) { +} + +func (newState *CreateBillingUsageDashboardResponse) SyncEffectiveFieldsDuringRead(existingState CreateBillingUsageDashboardResponse) { +} + type CreateBudgetConfigurationBudget struct { // Databricks account ID. AccountId types.String `tfsdk:"account_id" tf:"optional"` @@ -122,6 +176,12 @@ type CreateBudgetConfigurationBudget struct { Filter []BudgetConfigurationFilter `tfsdk:"filter" tf:"optional,object"` } +func (newState *CreateBudgetConfigurationBudget) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateBudgetConfigurationBudget) { +} + +func (newState *CreateBudgetConfigurationBudget) SyncEffectiveFieldsDuringRead(existingState CreateBudgetConfigurationBudget) { +} + type CreateBudgetConfigurationBudgetActionConfigurations struct { // The type of the action. ActionType types.String `tfsdk:"action_type" tf:"optional"` @@ -129,6 +189,12 @@ type CreateBudgetConfigurationBudgetActionConfigurations struct { Target types.String `tfsdk:"target" tf:"optional"` } +func (newState *CreateBudgetConfigurationBudgetActionConfigurations) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateBudgetConfigurationBudgetActionConfigurations) { +} + +func (newState *CreateBudgetConfigurationBudgetActionConfigurations) SyncEffectiveFieldsDuringRead(existingState CreateBudgetConfigurationBudgetActionConfigurations) { +} + type CreateBudgetConfigurationBudgetAlertConfigurations struct { // Configured actions for this alert. These define what happens when an // alert enters a triggered state. @@ -146,16 +212,34 @@ type CreateBudgetConfigurationBudgetAlertConfigurations struct { TriggerType types.String `tfsdk:"trigger_type" tf:"optional"` } +func (newState *CreateBudgetConfigurationBudgetAlertConfigurations) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateBudgetConfigurationBudgetAlertConfigurations) { +} + +func (newState *CreateBudgetConfigurationBudgetAlertConfigurations) SyncEffectiveFieldsDuringRead(existingState CreateBudgetConfigurationBudgetAlertConfigurations) { +} + type CreateBudgetConfigurationRequest struct { // Properties of the new budget configuration. Budget []CreateBudgetConfigurationBudget `tfsdk:"budget" tf:"object"` } +func (newState *CreateBudgetConfigurationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateBudgetConfigurationRequest) { +} + +func (newState *CreateBudgetConfigurationRequest) SyncEffectiveFieldsDuringRead(existingState CreateBudgetConfigurationRequest) { +} + type CreateBudgetConfigurationResponse struct { // The created budget configuration. Budget []BudgetConfiguration `tfsdk:"budget" tf:"optional,object"` } +func (newState *CreateBudgetConfigurationResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateBudgetConfigurationResponse) { +} + +func (newState *CreateBudgetConfigurationResponse) SyncEffectiveFieldsDuringRead(existingState CreateBudgetConfigurationResponse) { +} + type CreateLogDeliveryConfigurationParams struct { // The optional human-readable name of the log delivery configuration. // Defaults to empty. @@ -228,15 +312,33 @@ type CreateLogDeliveryConfigurationParams struct { WorkspaceIdsFilter []types.Int64 `tfsdk:"workspace_ids_filter" tf:"optional"` } +func (newState *CreateLogDeliveryConfigurationParams) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateLogDeliveryConfigurationParams) { +} + +func (newState *CreateLogDeliveryConfigurationParams) SyncEffectiveFieldsDuringRead(existingState CreateLogDeliveryConfigurationParams) { +} + // Delete budget type DeleteBudgetConfigurationRequest struct { // The Databricks budget configuration ID. BudgetId types.String `tfsdk:"-"` } +func (newState *DeleteBudgetConfigurationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteBudgetConfigurationRequest) { +} + +func (newState *DeleteBudgetConfigurationRequest) SyncEffectiveFieldsDuringRead(existingState DeleteBudgetConfigurationRequest) { +} + type DeleteBudgetConfigurationResponse struct { } +func (newState *DeleteBudgetConfigurationResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteBudgetConfigurationResponse) { +} + +func (newState *DeleteBudgetConfigurationResponse) SyncEffectiveFieldsDuringRead(existingState DeleteBudgetConfigurationResponse) { +} + // Return billable usage logs type DownloadRequest struct { // Format: `YYYY-MM`. Last month to return billable usage logs for. This @@ -251,10 +353,22 @@ type DownloadRequest struct { StartMonth types.String `tfsdk:"-"` } +func (newState *DownloadRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DownloadRequest) { +} + +func (newState *DownloadRequest) SyncEffectiveFieldsDuringRead(existingState DownloadRequest) { +} + type DownloadResponse struct { Contents io.ReadCloser `tfsdk:"-"` } +func (newState *DownloadResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DownloadResponse) { +} + +func (newState *DownloadResponse) SyncEffectiveFieldsDuringRead(existingState DownloadResponse) { +} + // Get usage dashboard type GetBillingUsageDashboardRequest struct { // Workspace level usage dashboard shows usage data for the specified @@ -266,6 +380,12 @@ type GetBillingUsageDashboardRequest struct { WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *GetBillingUsageDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetBillingUsageDashboardRequest) { +} + +func (newState *GetBillingUsageDashboardRequest) SyncEffectiveFieldsDuringRead(existingState GetBillingUsageDashboardRequest) { +} + type GetBillingUsageDashboardResponse struct { // The unique id of the usage dashboard. DashboardId types.String `tfsdk:"dashboard_id" tf:"optional"` @@ -273,22 +393,46 @@ type GetBillingUsageDashboardResponse struct { DashboardUrl types.String `tfsdk:"dashboard_url" tf:"optional"` } +func (newState *GetBillingUsageDashboardResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetBillingUsageDashboardResponse) { +} + +func (newState *GetBillingUsageDashboardResponse) SyncEffectiveFieldsDuringRead(existingState GetBillingUsageDashboardResponse) { +} + // Get budget type GetBudgetConfigurationRequest struct { // The Databricks budget configuration ID. BudgetId types.String `tfsdk:"-"` } +func (newState *GetBudgetConfigurationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetBudgetConfigurationRequest) { +} + +func (newState *GetBudgetConfigurationRequest) SyncEffectiveFieldsDuringRead(existingState GetBudgetConfigurationRequest) { +} + type GetBudgetConfigurationResponse struct { Budget []BudgetConfiguration `tfsdk:"budget" tf:"optional,object"` } +func (newState *GetBudgetConfigurationResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetBudgetConfigurationResponse) { +} + +func (newState *GetBudgetConfigurationResponse) SyncEffectiveFieldsDuringRead(existingState GetBudgetConfigurationResponse) { +} + // Get log delivery configuration type GetLogDeliveryRequest struct { // Databricks log delivery configuration ID LogDeliveryConfigurationId types.String `tfsdk:"-"` } +func (newState *GetLogDeliveryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetLogDeliveryRequest) { +} + +func (newState *GetLogDeliveryRequest) SyncEffectiveFieldsDuringRead(existingState GetLogDeliveryRequest) { +} + // Get all budgets type ListBudgetConfigurationsRequest struct { // A page token received from a previous get all budget configurations call. @@ -297,6 +441,12 @@ type ListBudgetConfigurationsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListBudgetConfigurationsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListBudgetConfigurationsRequest) { +} + +func (newState *ListBudgetConfigurationsRequest) SyncEffectiveFieldsDuringRead(existingState ListBudgetConfigurationsRequest) { +} + type ListBudgetConfigurationsResponse struct { Budgets []BudgetConfiguration `tfsdk:"budgets" tf:"optional"` // Token which can be sent as `page_token` to retrieve the next page of @@ -304,6 +454,12 @@ type ListBudgetConfigurationsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListBudgetConfigurationsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListBudgetConfigurationsResponse) { +} + +func (newState *ListBudgetConfigurationsResponse) SyncEffectiveFieldsDuringRead(existingState ListBudgetConfigurationsResponse) { +} + // Get all log delivery configurations type ListLogDeliveryRequest struct { // Filter by credential configuration ID. @@ -314,6 +470,12 @@ type ListLogDeliveryRequest struct { StorageConfigurationId types.String `tfsdk:"-"` } +func (newState *ListLogDeliveryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListLogDeliveryRequest) { +} + +func (newState *ListLogDeliveryRequest) SyncEffectiveFieldsDuringRead(existingState ListLogDeliveryRequest) { +} + type LogDeliveryConfiguration struct { // The Databricks account ID that hosts the log delivery configuration. AccountId types.String `tfsdk:"account_id" tf:"optional"` @@ -398,6 +560,12 @@ type LogDeliveryConfiguration struct { WorkspaceIdsFilter []types.Int64 `tfsdk:"workspace_ids_filter" tf:"optional"` } +func (newState *LogDeliveryConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogDeliveryConfiguration) { +} + +func (newState *LogDeliveryConfiguration) SyncEffectiveFieldsDuringRead(existingState LogDeliveryConfiguration) { +} + // Databricks log delivery status. type LogDeliveryStatus struct { // The UTC time for the latest log delivery attempt. @@ -421,9 +589,21 @@ type LogDeliveryStatus struct { Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *LogDeliveryStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogDeliveryStatus) { +} + +func (newState *LogDeliveryStatus) SyncEffectiveFieldsDuringRead(existingState LogDeliveryStatus) { +} + type PatchStatusResponse struct { } +func (newState *PatchStatusResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PatchStatusResponse) { +} + +func (newState *PatchStatusResponse) SyncEffectiveFieldsDuringRead(existingState PatchStatusResponse) { +} + type UpdateBudgetConfigurationBudget struct { // Databricks account ID. AccountId types.String `tfsdk:"account_id" tf:"optional"` @@ -441,6 +621,12 @@ type UpdateBudgetConfigurationBudget struct { Filter []BudgetConfigurationFilter `tfsdk:"filter" tf:"optional,object"` } +func (newState *UpdateBudgetConfigurationBudget) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateBudgetConfigurationBudget) { +} + +func (newState *UpdateBudgetConfigurationBudget) SyncEffectiveFieldsDuringRead(existingState UpdateBudgetConfigurationBudget) { +} + type UpdateBudgetConfigurationRequest struct { // The updated budget. This will overwrite the budget specified by the // budget ID. @@ -449,11 +635,23 @@ type UpdateBudgetConfigurationRequest struct { BudgetId types.String `tfsdk:"-"` } +func (newState *UpdateBudgetConfigurationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateBudgetConfigurationRequest) { +} + +func (newState *UpdateBudgetConfigurationRequest) SyncEffectiveFieldsDuringRead(existingState UpdateBudgetConfigurationRequest) { +} + type UpdateBudgetConfigurationResponse struct { // The updated budget. Budget []BudgetConfiguration `tfsdk:"budget" tf:"optional,object"` } +func (newState *UpdateBudgetConfigurationResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateBudgetConfigurationResponse) { +} + +func (newState *UpdateBudgetConfigurationResponse) SyncEffectiveFieldsDuringRead(existingState UpdateBudgetConfigurationResponse) { +} + type UpdateLogDeliveryConfigurationStatusRequest struct { // Databricks log delivery configuration ID LogDeliveryConfigurationId types.String `tfsdk:"-"` @@ -465,14 +663,38 @@ type UpdateLogDeliveryConfigurationStatusRequest struct { Status types.String `tfsdk:"status" tf:""` } +func (newState *UpdateLogDeliveryConfigurationStatusRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateLogDeliveryConfigurationStatusRequest) { +} + +func (newState *UpdateLogDeliveryConfigurationStatusRequest) SyncEffectiveFieldsDuringRead(existingState UpdateLogDeliveryConfigurationStatusRequest) { +} + type WrappedCreateLogDeliveryConfiguration struct { LogDeliveryConfiguration []CreateLogDeliveryConfigurationParams `tfsdk:"log_delivery_configuration" tf:"optional,object"` } +func (newState *WrappedCreateLogDeliveryConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan WrappedCreateLogDeliveryConfiguration) { +} + +func (newState *WrappedCreateLogDeliveryConfiguration) SyncEffectiveFieldsDuringRead(existingState WrappedCreateLogDeliveryConfiguration) { +} + type WrappedLogDeliveryConfiguration struct { LogDeliveryConfiguration []LogDeliveryConfiguration `tfsdk:"log_delivery_configuration" tf:"optional,object"` } +func (newState *WrappedLogDeliveryConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan WrappedLogDeliveryConfiguration) { +} + +func (newState *WrappedLogDeliveryConfiguration) SyncEffectiveFieldsDuringRead(existingState WrappedLogDeliveryConfiguration) { +} + type WrappedLogDeliveryConfigurations struct { LogDeliveryConfigurations []LogDeliveryConfiguration `tfsdk:"log_delivery_configurations" tf:"optional"` } + +func (newState *WrappedLogDeliveryConfigurations) SyncEffectiveFieldsDuringCreateOrUpdate(plan WrappedLogDeliveryConfigurations) { +} + +func (newState *WrappedLogDeliveryConfigurations) SyncEffectiveFieldsDuringRead(existingState WrappedLogDeliveryConfigurations) { +} diff --git a/internal/service/catalog_tf/model.go b/internal/service/catalog_tf/model.go index 25fa29c013..d064881534 100755 --- a/internal/service/catalog_tf/model.go +++ b/internal/service/catalog_tf/model.go @@ -18,6 +18,12 @@ type AccountsCreateMetastore struct { MetastoreInfo []CreateMetastore `tfsdk:"metastore_info" tf:"optional,object"` } +func (newState *AccountsCreateMetastore) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccountsCreateMetastore) { +} + +func (newState *AccountsCreateMetastore) SyncEffectiveFieldsDuringRead(existingState AccountsCreateMetastore) { +} + type AccountsCreateMetastoreAssignment struct { MetastoreAssignment []CreateMetastoreAssignment `tfsdk:"metastore_assignment" tf:"optional,object"` // Unity Catalog metastore ID @@ -26,24 +32,54 @@ type AccountsCreateMetastoreAssignment struct { WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *AccountsCreateMetastoreAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccountsCreateMetastoreAssignment) { +} + +func (newState *AccountsCreateMetastoreAssignment) SyncEffectiveFieldsDuringRead(existingState AccountsCreateMetastoreAssignment) { +} + type AccountsCreateStorageCredential struct { CredentialInfo []CreateStorageCredential `tfsdk:"credential_info" tf:"optional,object"` // Unity Catalog metastore ID MetastoreId types.String `tfsdk:"-"` } +func (newState *AccountsCreateStorageCredential) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccountsCreateStorageCredential) { +} + +func (newState *AccountsCreateStorageCredential) SyncEffectiveFieldsDuringRead(existingState AccountsCreateStorageCredential) { +} + type AccountsMetastoreAssignment struct { MetastoreAssignment []MetastoreAssignment `tfsdk:"metastore_assignment" tf:"optional,object"` } +func (newState *AccountsMetastoreAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccountsMetastoreAssignment) { +} + +func (newState *AccountsMetastoreAssignment) SyncEffectiveFieldsDuringRead(existingState AccountsMetastoreAssignment) { +} + type AccountsMetastoreInfo struct { MetastoreInfo []MetastoreInfo `tfsdk:"metastore_info" tf:"optional,object"` } +func (newState *AccountsMetastoreInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccountsMetastoreInfo) { +} + +func (newState *AccountsMetastoreInfo) SyncEffectiveFieldsDuringRead(existingState AccountsMetastoreInfo) { +} + type AccountsStorageCredentialInfo struct { CredentialInfo []StorageCredentialInfo `tfsdk:"credential_info" tf:"optional,object"` } +func (newState *AccountsStorageCredentialInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccountsStorageCredentialInfo) { +} + +func (newState *AccountsStorageCredentialInfo) SyncEffectiveFieldsDuringRead(existingState AccountsStorageCredentialInfo) { +} + type AccountsUpdateMetastore struct { // Unity Catalog metastore ID MetastoreId types.String `tfsdk:"-"` @@ -51,6 +87,12 @@ type AccountsUpdateMetastore struct { MetastoreInfo []UpdateMetastore `tfsdk:"metastore_info" tf:"optional,object"` } +func (newState *AccountsUpdateMetastore) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccountsUpdateMetastore) { +} + +func (newState *AccountsUpdateMetastore) SyncEffectiveFieldsDuringRead(existingState AccountsUpdateMetastore) { +} + type AccountsUpdateMetastoreAssignment struct { MetastoreAssignment []UpdateMetastoreAssignment `tfsdk:"metastore_assignment" tf:"optional,object"` // Unity Catalog metastore ID @@ -59,6 +101,12 @@ type AccountsUpdateMetastoreAssignment struct { WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *AccountsUpdateMetastoreAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccountsUpdateMetastoreAssignment) { +} + +func (newState *AccountsUpdateMetastoreAssignment) SyncEffectiveFieldsDuringRead(existingState AccountsUpdateMetastoreAssignment) { +} + type AccountsUpdateStorageCredential struct { CredentialInfo []UpdateStorageCredential `tfsdk:"credential_info" tf:"optional,object"` // Unity Catalog metastore ID @@ -67,6 +115,12 @@ type AccountsUpdateStorageCredential struct { StorageCredentialName types.String `tfsdk:"-"` } +func (newState *AccountsUpdateStorageCredential) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccountsUpdateStorageCredential) { +} + +func (newState *AccountsUpdateStorageCredential) SyncEffectiveFieldsDuringRead(existingState AccountsUpdateStorageCredential) { +} + type ArtifactAllowlistInfo struct { // A list of allowed artifact match patterns. ArtifactMatchers []ArtifactMatcher `tfsdk:"artifact_matchers" tf:"optional"` @@ -78,6 +132,12 @@ type ArtifactAllowlistInfo struct { MetastoreId types.String `tfsdk:"metastore_id" tf:"optional"` } +func (newState *ArtifactAllowlistInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ArtifactAllowlistInfo) { +} + +func (newState *ArtifactAllowlistInfo) SyncEffectiveFieldsDuringRead(existingState ArtifactAllowlistInfo) { +} + type ArtifactMatcher struct { // The artifact path or maven coordinate Artifact types.String `tfsdk:"artifact" tf:""` @@ -85,9 +145,21 @@ type ArtifactMatcher struct { MatchType types.String `tfsdk:"match_type" tf:""` } +func (newState *ArtifactMatcher) SyncEffectiveFieldsDuringCreateOrUpdate(plan ArtifactMatcher) { +} + +func (newState *ArtifactMatcher) SyncEffectiveFieldsDuringRead(existingState ArtifactMatcher) { +} + type AssignResponse struct { } +func (newState *AssignResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan AssignResponse) { +} + +func (newState *AssignResponse) SyncEffectiveFieldsDuringRead(existingState AssignResponse) { +} + // AWS temporary credentials for API authentication. Read more at // https://docs.aws.amazon.com/STS/latest/APIReference/API_Credentials.html. type AwsCredentials struct { @@ -103,11 +175,23 @@ type AwsCredentials struct { SessionToken types.String `tfsdk:"session_token" tf:"optional"` } +func (newState *AwsCredentials) SyncEffectiveFieldsDuringCreateOrUpdate(plan AwsCredentials) { +} + +func (newState *AwsCredentials) SyncEffectiveFieldsDuringRead(existingState AwsCredentials) { +} + type AwsIamRoleRequest struct { // The Amazon Resource Name (ARN) of the AWS IAM role for S3 data access. RoleArn types.String `tfsdk:"role_arn" tf:""` } +func (newState *AwsIamRoleRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan AwsIamRoleRequest) { +} + +func (newState *AwsIamRoleRequest) SyncEffectiveFieldsDuringRead(existingState AwsIamRoleRequest) { +} + type AwsIamRoleResponse struct { // The external ID used in role assumption to prevent confused deputy // problem.. @@ -119,6 +203,12 @@ type AwsIamRoleResponse struct { UnityCatalogIamArn types.String `tfsdk:"unity_catalog_iam_arn" tf:"optional"` } +func (newState *AwsIamRoleResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan AwsIamRoleResponse) { +} + +func (newState *AwsIamRoleResponse) SyncEffectiveFieldsDuringRead(existingState AwsIamRoleResponse) { +} + type AzureManagedIdentityRequest struct { // The Azure resource ID of the Azure Databricks Access Connector. Use the // format @@ -133,6 +223,12 @@ type AzureManagedIdentityRequest struct { ManagedIdentityId types.String `tfsdk:"managed_identity_id" tf:"optional"` } +func (newState *AzureManagedIdentityRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan AzureManagedIdentityRequest) { +} + +func (newState *AzureManagedIdentityRequest) SyncEffectiveFieldsDuringRead(existingState AzureManagedIdentityRequest) { +} + type AzureManagedIdentityResponse struct { // The Azure resource ID of the Azure Databricks Access Connector. Use the // format @@ -149,6 +245,12 @@ type AzureManagedIdentityResponse struct { ManagedIdentityId types.String `tfsdk:"managed_identity_id" tf:"optional"` } +func (newState *AzureManagedIdentityResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan AzureManagedIdentityResponse) { +} + +func (newState *AzureManagedIdentityResponse) SyncEffectiveFieldsDuringRead(existingState AzureManagedIdentityResponse) { +} + type AzureServicePrincipal struct { // The application ID of the application registration within the referenced // AAD tenant. @@ -160,6 +262,12 @@ type AzureServicePrincipal struct { DirectoryId types.String `tfsdk:"directory_id" tf:""` } +func (newState *AzureServicePrincipal) SyncEffectiveFieldsDuringCreateOrUpdate(plan AzureServicePrincipal) { +} + +func (newState *AzureServicePrincipal) SyncEffectiveFieldsDuringRead(existingState AzureServicePrincipal) { +} + // Azure temporary credentials for API authentication. Read more at // https://docs.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas type AzureUserDelegationSas struct { @@ -167,6 +275,12 @@ type AzureUserDelegationSas struct { SasToken types.String `tfsdk:"sas_token" tf:"optional"` } +func (newState *AzureUserDelegationSas) SyncEffectiveFieldsDuringCreateOrUpdate(plan AzureUserDelegationSas) { +} + +func (newState *AzureUserDelegationSas) SyncEffectiveFieldsDuringRead(existingState AzureUserDelegationSas) { +} + // Cancel refresh type CancelRefreshRequest struct { // ID of the refresh. @@ -175,9 +289,21 @@ type CancelRefreshRequest struct { TableName types.String `tfsdk:"-"` } +func (newState *CancelRefreshRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CancelRefreshRequest) { +} + +func (newState *CancelRefreshRequest) SyncEffectiveFieldsDuringRead(existingState CancelRefreshRequest) { +} + type CancelRefreshResponse struct { } +func (newState *CancelRefreshResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CancelRefreshResponse) { +} + +func (newState *CancelRefreshResponse) SyncEffectiveFieldsDuringRead(existingState CancelRefreshResponse) { +} + type CatalogInfo struct { // Indicates whether the principal is limited to retrieving metadata for the // associated object through the BROWSE privilege when include_browse is @@ -236,6 +362,12 @@ type CatalogInfo struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *CatalogInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CatalogInfo) { +} + +func (newState *CatalogInfo) SyncEffectiveFieldsDuringRead(existingState CatalogInfo) { +} + type CloudflareApiToken struct { // The Cloudflare access key id of the token. AccessKeyId types.String `tfsdk:"access_key_id" tf:""` @@ -245,6 +377,12 @@ type CloudflareApiToken struct { SecretAccessKey types.String `tfsdk:"secret_access_key" tf:""` } +func (newState *CloudflareApiToken) SyncEffectiveFieldsDuringCreateOrUpdate(plan CloudflareApiToken) { +} + +func (newState *CloudflareApiToken) SyncEffectiveFieldsDuringRead(existingState CloudflareApiToken) { +} + type ColumnInfo struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -272,6 +410,12 @@ type ColumnInfo struct { TypeText types.String `tfsdk:"type_text" tf:"optional"` } +func (newState *ColumnInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ColumnInfo) { +} + +func (newState *ColumnInfo) SyncEffectiveFieldsDuringRead(existingState ColumnInfo) { +} + type ColumnMask struct { // The full name of the column mask SQL UDF. FunctionName types.String `tfsdk:"function_name" tf:"optional"` @@ -282,6 +426,12 @@ type ColumnMask struct { UsingColumnNames []types.String `tfsdk:"using_column_names" tf:"optional"` } +func (newState *ColumnMask) SyncEffectiveFieldsDuringCreateOrUpdate(plan ColumnMask) { +} + +func (newState *ColumnMask) SyncEffectiveFieldsDuringRead(existingState ColumnMask) { +} + type ConnectionInfo struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -324,6 +474,12 @@ type ConnectionInfo struct { Url types.String `tfsdk:"url" tf:"optional"` } +func (newState *ConnectionInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ConnectionInfo) { +} + +func (newState *ConnectionInfo) SyncEffectiveFieldsDuringRead(existingState ConnectionInfo) { +} + // Detailed status of an online table. Shown if the online table is in the // ONLINE_CONTINUOUS_UPDATE or the ONLINE_UPDATING_PIPELINE_RESOURCES state. type ContinuousUpdateStatus struct { @@ -338,6 +494,12 @@ type ContinuousUpdateStatus struct { Timestamp types.String `tfsdk:"timestamp" tf:"optional"` } +func (newState *ContinuousUpdateStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan ContinuousUpdateStatus) { +} + +func (newState *ContinuousUpdateStatus) SyncEffectiveFieldsDuringRead(existingState ContinuousUpdateStatus) { +} + type CreateCatalog struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -360,6 +522,12 @@ type CreateCatalog struct { StorageRoot types.String `tfsdk:"storage_root" tf:"optional"` } +func (newState *CreateCatalog) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCatalog) { +} + +func (newState *CreateCatalog) SyncEffectiveFieldsDuringRead(existingState CreateCatalog) { +} + type CreateConnection struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -376,6 +544,12 @@ type CreateConnection struct { ReadOnly types.Bool `tfsdk:"read_only" tf:"optional"` } +func (newState *CreateConnection) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateConnection) { +} + +func (newState *CreateConnection) SyncEffectiveFieldsDuringRead(existingState CreateConnection) { +} + type CreateExternalLocation struct { // The AWS access point to use when accesing s3 for this external location. AccessPoint types.String `tfsdk:"access_point" tf:"optional"` @@ -400,6 +574,12 @@ type CreateExternalLocation struct { Url types.String `tfsdk:"url" tf:""` } +func (newState *CreateExternalLocation) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateExternalLocation) { +} + +func (newState *CreateExternalLocation) SyncEffectiveFieldsDuringRead(existingState CreateExternalLocation) { +} + type CreateFunction struct { // Name of parent catalog. CatalogName types.String `tfsdk:"catalog_name" tf:""` @@ -449,11 +629,23 @@ type CreateFunction struct { SqlPath types.String `tfsdk:"sql_path" tf:"optional"` } +func (newState *CreateFunction) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateFunction) { +} + +func (newState *CreateFunction) SyncEffectiveFieldsDuringRead(existingState CreateFunction) { +} + type CreateFunctionRequest struct { // Partial __FunctionInfo__ specifying the function to be created. FunctionInfo []CreateFunction `tfsdk:"function_info" tf:"object"` } +func (newState *CreateFunctionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateFunctionRequest) { +} + +func (newState *CreateFunctionRequest) SyncEffectiveFieldsDuringRead(existingState CreateFunctionRequest) { +} + type CreateMetastore struct { // The user-specified name of the metastore. Name types.String `tfsdk:"name" tf:""` @@ -466,6 +658,12 @@ type CreateMetastore struct { StorageRoot types.String `tfsdk:"storage_root" tf:"optional"` } +func (newState *CreateMetastore) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateMetastore) { +} + +func (newState *CreateMetastore) SyncEffectiveFieldsDuringRead(existingState CreateMetastore) { +} + type CreateMetastoreAssignment struct { // The name of the default catalog in the metastore. This field is // depracted. Please use "Default Namespace API" to configure the default @@ -477,6 +675,12 @@ type CreateMetastoreAssignment struct { WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *CreateMetastoreAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateMetastoreAssignment) { +} + +func (newState *CreateMetastoreAssignment) SyncEffectiveFieldsDuringRead(existingState CreateMetastoreAssignment) { +} + type CreateMonitor struct { // The directory to store monitoring assets (e.g. dashboard, metric tables). AssetsDir types.String `tfsdk:"assets_dir" tf:""` @@ -518,6 +722,12 @@ type CreateMonitor struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *CreateMonitor) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateMonitor) { +} + +func (newState *CreateMonitor) SyncEffectiveFieldsDuringRead(existingState CreateMonitor) { +} + // Online Table information. type CreateOnlineTableRequest struct { // Full three-part (catalog, schema, table) name of the table. @@ -526,6 +736,12 @@ type CreateOnlineTableRequest struct { Spec []OnlineTableSpec `tfsdk:"spec" tf:"optional,object"` } +func (newState *CreateOnlineTableRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateOnlineTableRequest) { +} + +func (newState *CreateOnlineTableRequest) SyncEffectiveFieldsDuringRead(existingState CreateOnlineTableRequest) { +} + type CreateRegisteredModelRequest struct { // The name of the catalog where the schema and the registered model reside CatalogName types.String `tfsdk:"catalog_name" tf:""` @@ -540,9 +756,21 @@ type CreateRegisteredModelRequest struct { StorageLocation types.String `tfsdk:"storage_location" tf:"optional"` } +func (newState *CreateRegisteredModelRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateRegisteredModelRequest) { +} + +func (newState *CreateRegisteredModelRequest) SyncEffectiveFieldsDuringRead(existingState CreateRegisteredModelRequest) { +} + type CreateResponse struct { } +func (newState *CreateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateResponse) { +} + +func (newState *CreateResponse) SyncEffectiveFieldsDuringRead(existingState CreateResponse) { +} + type CreateSchema struct { // Name of parent catalog. CatalogName types.String `tfsdk:"catalog_name" tf:""` @@ -556,6 +784,12 @@ type CreateSchema struct { StorageRoot types.String `tfsdk:"storage_root" tf:"optional"` } +func (newState *CreateSchema) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateSchema) { +} + +func (newState *CreateSchema) SyncEffectiveFieldsDuringRead(existingState CreateSchema) { +} + type CreateStorageCredential struct { // The AWS IAM role configuration. AwsIamRole []AwsIamRoleRequest `tfsdk:"aws_iam_role" tf:"optional,object"` @@ -578,6 +812,12 @@ type CreateStorageCredential struct { SkipValidation types.Bool `tfsdk:"skip_validation" tf:"optional"` } +func (newState *CreateStorageCredential) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateStorageCredential) { +} + +func (newState *CreateStorageCredential) SyncEffectiveFieldsDuringRead(existingState CreateStorageCredential) { +} + type CreateTableConstraint struct { // A table constraint, as defined by *one* of the following fields being // set: __primary_key_constraint__, __foreign_key_constraint__, @@ -587,6 +827,12 @@ type CreateTableConstraint struct { FullNameArg types.String `tfsdk:"full_name_arg" tf:""` } +func (newState *CreateTableConstraint) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateTableConstraint) { +} + +func (newState *CreateTableConstraint) SyncEffectiveFieldsDuringRead(existingState CreateTableConstraint) { +} + type CreateVolumeRequestContent struct { // The name of the catalog where the schema and the volume are CatalogName types.String `tfsdk:"catalog_name" tf:""` @@ -602,15 +848,33 @@ type CreateVolumeRequestContent struct { VolumeType types.String `tfsdk:"volume_type" tf:""` } +func (newState *CreateVolumeRequestContent) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateVolumeRequestContent) { +} + +func (newState *CreateVolumeRequestContent) SyncEffectiveFieldsDuringRead(existingState CreateVolumeRequestContent) { +} + // Currently assigned workspaces type CurrentWorkspaceBindings struct { // A list of workspace IDs. Workspaces []types.Int64 `tfsdk:"workspaces" tf:"optional"` } +func (newState *CurrentWorkspaceBindings) SyncEffectiveFieldsDuringCreateOrUpdate(plan CurrentWorkspaceBindings) { +} + +func (newState *CurrentWorkspaceBindings) SyncEffectiveFieldsDuringRead(existingState CurrentWorkspaceBindings) { +} + type DatabricksGcpServiceAccountRequest struct { } +func (newState *DatabricksGcpServiceAccountRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DatabricksGcpServiceAccountRequest) { +} + +func (newState *DatabricksGcpServiceAccountRequest) SyncEffectiveFieldsDuringRead(existingState DatabricksGcpServiceAccountRequest) { +} + type DatabricksGcpServiceAccountResponse struct { // The Databricks internal ID that represents this service account. This is // an output-only field. @@ -619,6 +883,12 @@ type DatabricksGcpServiceAccountResponse struct { Email types.String `tfsdk:"email" tf:"optional"` } +func (newState *DatabricksGcpServiceAccountResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DatabricksGcpServiceAccountResponse) { +} + +func (newState *DatabricksGcpServiceAccountResponse) SyncEffectiveFieldsDuringRead(existingState DatabricksGcpServiceAccountResponse) { +} + // Delete a metastore assignment type DeleteAccountMetastoreAssignmentRequest struct { // Unity Catalog metastore ID @@ -627,6 +897,12 @@ type DeleteAccountMetastoreAssignmentRequest struct { WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *DeleteAccountMetastoreAssignmentRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAccountMetastoreAssignmentRequest) { +} + +func (newState *DeleteAccountMetastoreAssignmentRequest) SyncEffectiveFieldsDuringRead(existingState DeleteAccountMetastoreAssignmentRequest) { +} + // Delete a metastore type DeleteAccountMetastoreRequest struct { // Force deletion even if the metastore is not empty. Default is false. @@ -635,6 +911,12 @@ type DeleteAccountMetastoreRequest struct { MetastoreId types.String `tfsdk:"-"` } +func (newState *DeleteAccountMetastoreRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAccountMetastoreRequest) { +} + +func (newState *DeleteAccountMetastoreRequest) SyncEffectiveFieldsDuringRead(existingState DeleteAccountMetastoreRequest) { +} + // Delete a storage credential type DeleteAccountStorageCredentialRequest struct { // Force deletion even if the Storage Credential is not empty. Default is @@ -646,6 +928,12 @@ type DeleteAccountStorageCredentialRequest struct { StorageCredentialName types.String `tfsdk:"-"` } +func (newState *DeleteAccountStorageCredentialRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAccountStorageCredentialRequest) { +} + +func (newState *DeleteAccountStorageCredentialRequest) SyncEffectiveFieldsDuringRead(existingState DeleteAccountStorageCredentialRequest) { +} + // Delete a Registered Model Alias type DeleteAliasRequest struct { // The name of the alias @@ -654,9 +942,21 @@ type DeleteAliasRequest struct { FullName types.String `tfsdk:"-"` } +func (newState *DeleteAliasRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAliasRequest) { +} + +func (newState *DeleteAliasRequest) SyncEffectiveFieldsDuringRead(existingState DeleteAliasRequest) { +} + type DeleteAliasResponse struct { } +func (newState *DeleteAliasResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAliasResponse) { +} + +func (newState *DeleteAliasResponse) SyncEffectiveFieldsDuringRead(existingState DeleteAliasResponse) { +} + // Delete a catalog type DeleteCatalogRequest struct { // Force deletion even if the catalog is not empty. @@ -665,12 +965,24 @@ type DeleteCatalogRequest struct { Name types.String `tfsdk:"-"` } +func (newState *DeleteCatalogRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteCatalogRequest) { +} + +func (newState *DeleteCatalogRequest) SyncEffectiveFieldsDuringRead(existingState DeleteCatalogRequest) { +} + // Delete a connection type DeleteConnectionRequest struct { // The name of the connection to be deleted. Name types.String `tfsdk:"-"` } +func (newState *DeleteConnectionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteConnectionRequest) { +} + +func (newState *DeleteConnectionRequest) SyncEffectiveFieldsDuringRead(existingState DeleteConnectionRequest) { +} + // Delete an external location type DeleteExternalLocationRequest struct { // Force deletion even if there are dependent external tables or mounts. @@ -679,6 +991,12 @@ type DeleteExternalLocationRequest struct { Name types.String `tfsdk:"-"` } +func (newState *DeleteExternalLocationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteExternalLocationRequest) { +} + +func (newState *DeleteExternalLocationRequest) SyncEffectiveFieldsDuringRead(existingState DeleteExternalLocationRequest) { +} + // Delete a function type DeleteFunctionRequest struct { // Force deletion even if the function is notempty. @@ -688,6 +1006,12 @@ type DeleteFunctionRequest struct { Name types.String `tfsdk:"-"` } +func (newState *DeleteFunctionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteFunctionRequest) { +} + +func (newState *DeleteFunctionRequest) SyncEffectiveFieldsDuringRead(existingState DeleteFunctionRequest) { +} + // Delete a metastore type DeleteMetastoreRequest struct { // Force deletion even if the metastore is not empty. Default is false. @@ -696,6 +1020,12 @@ type DeleteMetastoreRequest struct { Id types.String `tfsdk:"-"` } +func (newState *DeleteMetastoreRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteMetastoreRequest) { +} + +func (newState *DeleteMetastoreRequest) SyncEffectiveFieldsDuringRead(existingState DeleteMetastoreRequest) { +} + // Delete a Model Version type DeleteModelVersionRequest struct { // The three-level (fully qualified) name of the model version @@ -704,27 +1034,57 @@ type DeleteModelVersionRequest struct { Version types.Int64 `tfsdk:"-"` } +func (newState *DeleteModelVersionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteModelVersionRequest) { +} + +func (newState *DeleteModelVersionRequest) SyncEffectiveFieldsDuringRead(existingState DeleteModelVersionRequest) { +} + // Delete an Online Table type DeleteOnlineTableRequest struct { // Full three-part (catalog, schema, table) name of the table. Name types.String `tfsdk:"-"` } +func (newState *DeleteOnlineTableRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteOnlineTableRequest) { +} + +func (newState *DeleteOnlineTableRequest) SyncEffectiveFieldsDuringRead(existingState DeleteOnlineTableRequest) { +} + // Delete a table monitor type DeleteQualityMonitorRequest struct { // Full name of the table. TableName types.String `tfsdk:"-"` } +func (newState *DeleteQualityMonitorRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteQualityMonitorRequest) { +} + +func (newState *DeleteQualityMonitorRequest) SyncEffectiveFieldsDuringRead(existingState DeleteQualityMonitorRequest) { +} + // Delete a Registered Model type DeleteRegisteredModelRequest struct { // The three-level (fully qualified) name of the registered model FullName types.String `tfsdk:"-"` } +func (newState *DeleteRegisteredModelRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRegisteredModelRequest) { +} + +func (newState *DeleteRegisteredModelRequest) SyncEffectiveFieldsDuringRead(existingState DeleteRegisteredModelRequest) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + // Delete a schema type DeleteSchemaRequest struct { // Force deletion even if the schema is not empty. @@ -733,6 +1093,12 @@ type DeleteSchemaRequest struct { FullName types.String `tfsdk:"-"` } +func (newState *DeleteSchemaRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteSchemaRequest) { +} + +func (newState *DeleteSchemaRequest) SyncEffectiveFieldsDuringRead(existingState DeleteSchemaRequest) { +} + // Delete a credential type DeleteStorageCredentialRequest struct { // Force deletion even if there are dependent external locations or external @@ -742,6 +1108,12 @@ type DeleteStorageCredentialRequest struct { Name types.String `tfsdk:"-"` } +func (newState *DeleteStorageCredentialRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteStorageCredentialRequest) { +} + +func (newState *DeleteStorageCredentialRequest) SyncEffectiveFieldsDuringRead(existingState DeleteStorageCredentialRequest) { +} + // Delete a table constraint type DeleteTableConstraintRequest struct { // If true, try deleting all child constraints of the current constraint. If @@ -754,18 +1126,36 @@ type DeleteTableConstraintRequest struct { FullName types.String `tfsdk:"-"` } +func (newState *DeleteTableConstraintRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteTableConstraintRequest) { +} + +func (newState *DeleteTableConstraintRequest) SyncEffectiveFieldsDuringRead(existingState DeleteTableConstraintRequest) { +} + // Delete a table type DeleteTableRequest struct { // Full name of the table. FullName types.String `tfsdk:"-"` } +func (newState *DeleteTableRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteTableRequest) { +} + +func (newState *DeleteTableRequest) SyncEffectiveFieldsDuringRead(existingState DeleteTableRequest) { +} + // Delete a Volume type DeleteVolumeRequest struct { // The three-level (fully qualified) name of the volume Name types.String `tfsdk:"-"` } +func (newState *DeleteVolumeRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteVolumeRequest) { +} + +func (newState *DeleteVolumeRequest) SyncEffectiveFieldsDuringRead(existingState DeleteVolumeRequest) { +} + // Properties pertaining to the current state of the delta table as given by the // commit server. This does not contain **delta.*** (input) properties in // __TableInfo.properties__. @@ -774,6 +1164,12 @@ type DeltaRuntimePropertiesKvPairs struct { DeltaRuntimeProperties map[string]types.String `tfsdk:"delta_runtime_properties" tf:""` } +func (newState *DeltaRuntimePropertiesKvPairs) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeltaRuntimePropertiesKvPairs) { +} + +func (newState *DeltaRuntimePropertiesKvPairs) SyncEffectiveFieldsDuringRead(existingState DeltaRuntimePropertiesKvPairs) { +} + // A dependency of a SQL object. Either the __table__ field or the __function__ // field must be defined. type Dependency struct { @@ -783,12 +1179,24 @@ type Dependency struct { Table []TableDependency `tfsdk:"table" tf:"optional,object"` } +func (newState *Dependency) SyncEffectiveFieldsDuringCreateOrUpdate(plan Dependency) { +} + +func (newState *Dependency) SyncEffectiveFieldsDuringRead(existingState Dependency) { +} + // A list of dependencies. type DependencyList struct { // Array of dependencies. Dependencies []Dependency `tfsdk:"dependencies" tf:"optional"` } +func (newState *DependencyList) SyncEffectiveFieldsDuringCreateOrUpdate(plan DependencyList) { +} + +func (newState *DependencyList) SyncEffectiveFieldsDuringRead(existingState DependencyList) { +} + // Disable a system schema type DisableRequest struct { // The metastore ID under which the system schema lives. @@ -797,15 +1205,33 @@ type DisableRequest struct { SchemaName types.String `tfsdk:"-"` } +func (newState *DisableRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DisableRequest) { +} + +func (newState *DisableRequest) SyncEffectiveFieldsDuringRead(existingState DisableRequest) { +} + type DisableResponse struct { } +func (newState *DisableResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DisableResponse) { +} + +func (newState *DisableResponse) SyncEffectiveFieldsDuringRead(existingState DisableResponse) { +} + type EffectivePermissionsList struct { // The privileges conveyed to each principal (either directly or via // inheritance) PrivilegeAssignments []EffectivePrivilegeAssignment `tfsdk:"privilege_assignments" tf:"optional"` } +func (newState *EffectivePermissionsList) SyncEffectiveFieldsDuringCreateOrUpdate(plan EffectivePermissionsList) { +} + +func (newState *EffectivePermissionsList) SyncEffectiveFieldsDuringRead(existingState EffectivePermissionsList) { +} + type EffectivePredictiveOptimizationFlag struct { // The name of the object from which the flag was inherited. If there was no // inheritance, this field is left blank. @@ -818,6 +1244,12 @@ type EffectivePredictiveOptimizationFlag struct { Value types.String `tfsdk:"value" tf:""` } +func (newState *EffectivePredictiveOptimizationFlag) SyncEffectiveFieldsDuringCreateOrUpdate(plan EffectivePredictiveOptimizationFlag) { +} + +func (newState *EffectivePredictiveOptimizationFlag) SyncEffectiveFieldsDuringRead(existingState EffectivePredictiveOptimizationFlag) { +} + type EffectivePrivilege struct { // The full name of the object that conveys this privilege via inheritance. // This field is omitted when privilege is not inherited (it's assigned to @@ -831,6 +1263,12 @@ type EffectivePrivilege struct { Privilege types.String `tfsdk:"privilege" tf:"optional"` } +func (newState *EffectivePrivilege) SyncEffectiveFieldsDuringCreateOrUpdate(plan EffectivePrivilege) { +} + +func (newState *EffectivePrivilege) SyncEffectiveFieldsDuringRead(existingState EffectivePrivilege) { +} + type EffectivePrivilegeAssignment struct { // The principal (user email address or group name). Principal types.String `tfsdk:"principal" tf:"optional"` @@ -839,6 +1277,12 @@ type EffectivePrivilegeAssignment struct { Privileges []EffectivePrivilege `tfsdk:"privileges" tf:"optional"` } +func (newState *EffectivePrivilegeAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan EffectivePrivilegeAssignment) { +} + +func (newState *EffectivePrivilegeAssignment) SyncEffectiveFieldsDuringRead(existingState EffectivePrivilegeAssignment) { +} + // Enable a system schema type EnableRequest struct { // The metastore ID under which the system schema lives. @@ -847,21 +1291,45 @@ type EnableRequest struct { SchemaName types.String `tfsdk:"-"` } +func (newState *EnableRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan EnableRequest) { +} + +func (newState *EnableRequest) SyncEffectiveFieldsDuringRead(existingState EnableRequest) { +} + type EnableResponse struct { } +func (newState *EnableResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan EnableResponse) { +} + +func (newState *EnableResponse) SyncEffectiveFieldsDuringRead(existingState EnableResponse) { +} + // Encryption options that apply to clients connecting to cloud storage. type EncryptionDetails struct { // Server-Side Encryption properties for clients communicating with AWS s3. SseEncryptionDetails []SseEncryptionDetails `tfsdk:"sse_encryption_details" tf:"optional,object"` } +func (newState *EncryptionDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan EncryptionDetails) { +} + +func (newState *EncryptionDetails) SyncEffectiveFieldsDuringRead(existingState EncryptionDetails) { +} + // Get boolean reflecting if table exists type ExistsRequest struct { // Full name of the table. FullName types.String `tfsdk:"-"` } +func (newState *ExistsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExistsRequest) { +} + +func (newState *ExistsRequest) SyncEffectiveFieldsDuringRead(existingState ExistsRequest) { +} + type ExternalLocationInfo struct { // The AWS access point to use when accesing s3 for this external location. AccessPoint types.String `tfsdk:"access_point" tf:"optional"` @@ -905,6 +1373,12 @@ type ExternalLocationInfo struct { Url types.String `tfsdk:"url" tf:"optional"` } +func (newState *ExternalLocationInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExternalLocationInfo) { +} + +func (newState *ExternalLocationInfo) SyncEffectiveFieldsDuringRead(existingState ExternalLocationInfo) { +} + // Detailed status of an online table. Shown if the online table is in the // OFFLINE_FAILED or the ONLINE_PIPELINE_FAILED state. type FailedStatus struct { @@ -919,6 +1393,12 @@ type FailedStatus struct { Timestamp types.String `tfsdk:"timestamp" tf:"optional"` } +func (newState *FailedStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan FailedStatus) { +} + +func (newState *FailedStatus) SyncEffectiveFieldsDuringRead(existingState FailedStatus) { +} + type ForeignKeyConstraint struct { // Column names for this constraint. ChildColumns []types.String `tfsdk:"child_columns" tf:""` @@ -930,6 +1410,12 @@ type ForeignKeyConstraint struct { ParentTable types.String `tfsdk:"parent_table" tf:""` } +func (newState *ForeignKeyConstraint) SyncEffectiveFieldsDuringCreateOrUpdate(plan ForeignKeyConstraint) { +} + +func (newState *ForeignKeyConstraint) SyncEffectiveFieldsDuringRead(existingState ForeignKeyConstraint) { +} + // A function that is dependent on a SQL object. type FunctionDependency struct { // Full name of the dependent function, in the form of @@ -937,6 +1423,12 @@ type FunctionDependency struct { FunctionFullName types.String `tfsdk:"function_full_name" tf:""` } +func (newState *FunctionDependency) SyncEffectiveFieldsDuringCreateOrUpdate(plan FunctionDependency) { +} + +func (newState *FunctionDependency) SyncEffectiveFieldsDuringRead(existingState FunctionDependency) { +} + type FunctionInfo struct { // Indicates whether the principal is limited to retrieving metadata for the // associated object through the BROWSE privilege when include_browse is @@ -1007,6 +1499,12 @@ type FunctionInfo struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *FunctionInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan FunctionInfo) { +} + +func (newState *FunctionInfo) SyncEffectiveFieldsDuringRead(existingState FunctionInfo) { +} + type FunctionParameterInfo struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -1034,18 +1532,36 @@ type FunctionParameterInfo struct { TypeText types.String `tfsdk:"type_text" tf:""` } +func (newState *FunctionParameterInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan FunctionParameterInfo) { +} + +func (newState *FunctionParameterInfo) SyncEffectiveFieldsDuringRead(existingState FunctionParameterInfo) { +} + type FunctionParameterInfos struct { // The array of __FunctionParameterInfo__ definitions of the function's // parameters. Parameters []FunctionParameterInfo `tfsdk:"parameters" tf:"optional"` } +func (newState *FunctionParameterInfos) SyncEffectiveFieldsDuringCreateOrUpdate(plan FunctionParameterInfos) { +} + +func (newState *FunctionParameterInfos) SyncEffectiveFieldsDuringRead(existingState FunctionParameterInfos) { +} + // GCP temporary credentials for API authentication. Read more at // https://developers.google.com/identity/protocols/oauth2/service-account type GcpOauthToken struct { OauthToken types.String `tfsdk:"oauth_token" tf:"optional"` } +func (newState *GcpOauthToken) SyncEffectiveFieldsDuringCreateOrUpdate(plan GcpOauthToken) { +} + +func (newState *GcpOauthToken) SyncEffectiveFieldsDuringRead(existingState GcpOauthToken) { +} + type GenerateTemporaryTableCredentialRequest struct { // The operation performed against the table data, either READ or // READ_WRITE. If READ_WRITE is specified, the credentials returned will @@ -1055,6 +1571,12 @@ type GenerateTemporaryTableCredentialRequest struct { TableId types.String `tfsdk:"table_id" tf:"optional"` } +func (newState *GenerateTemporaryTableCredentialRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenerateTemporaryTableCredentialRequest) { +} + +func (newState *GenerateTemporaryTableCredentialRequest) SyncEffectiveFieldsDuringRead(existingState GenerateTemporaryTableCredentialRequest) { +} + type GenerateTemporaryTableCredentialResponse struct { // AWS temporary credentials for API authentication. Read more at // https://docs.aws.amazon.com/STS/latest/APIReference/API_Credentials.html. @@ -1075,18 +1597,36 @@ type GenerateTemporaryTableCredentialResponse struct { Url types.String `tfsdk:"url" tf:"optional"` } +func (newState *GenerateTemporaryTableCredentialResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenerateTemporaryTableCredentialResponse) { +} + +func (newState *GenerateTemporaryTableCredentialResponse) SyncEffectiveFieldsDuringRead(existingState GenerateTemporaryTableCredentialResponse) { +} + // Gets the metastore assignment for a workspace type GetAccountMetastoreAssignmentRequest struct { // Workspace ID. WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *GetAccountMetastoreAssignmentRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAccountMetastoreAssignmentRequest) { +} + +func (newState *GetAccountMetastoreAssignmentRequest) SyncEffectiveFieldsDuringRead(existingState GetAccountMetastoreAssignmentRequest) { +} + // Get a metastore type GetAccountMetastoreRequest struct { // Unity Catalog metastore ID MetastoreId types.String `tfsdk:"-"` } +func (newState *GetAccountMetastoreRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAccountMetastoreRequest) { +} + +func (newState *GetAccountMetastoreRequest) SyncEffectiveFieldsDuringRead(existingState GetAccountMetastoreRequest) { +} + // Gets the named storage credential type GetAccountStorageCredentialRequest struct { // Unity Catalog metastore ID @@ -1095,12 +1635,24 @@ type GetAccountStorageCredentialRequest struct { StorageCredentialName types.String `tfsdk:"-"` } +func (newState *GetAccountStorageCredentialRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAccountStorageCredentialRequest) { +} + +func (newState *GetAccountStorageCredentialRequest) SyncEffectiveFieldsDuringRead(existingState GetAccountStorageCredentialRequest) { +} + // Get an artifact allowlist type GetArtifactAllowlistRequest struct { // The artifact type of the allowlist. ArtifactType types.String `tfsdk:"-"` } +func (newState *GetArtifactAllowlistRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetArtifactAllowlistRequest) { +} + +func (newState *GetArtifactAllowlistRequest) SyncEffectiveFieldsDuringRead(existingState GetArtifactAllowlistRequest) { +} + // Get securable workspace bindings type GetBindingsRequest struct { // Maximum number of workspace bindings to return. - When set to 0, the page @@ -1118,6 +1670,12 @@ type GetBindingsRequest struct { SecurableType types.String `tfsdk:"-"` } +func (newState *GetBindingsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetBindingsRequest) { +} + +func (newState *GetBindingsRequest) SyncEffectiveFieldsDuringRead(existingState GetBindingsRequest) { +} + // Get Model Version By Alias type GetByAliasRequest struct { // The name of the alias @@ -1129,6 +1687,12 @@ type GetByAliasRequest struct { IncludeAliases types.Bool `tfsdk:"-"` } +func (newState *GetByAliasRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetByAliasRequest) { +} + +func (newState *GetByAliasRequest) SyncEffectiveFieldsDuringRead(existingState GetByAliasRequest) { +} + // Get a catalog type GetCatalogRequest struct { // Whether to include catalogs in the response for which the principal can @@ -1138,12 +1702,24 @@ type GetCatalogRequest struct { Name types.String `tfsdk:"-"` } +func (newState *GetCatalogRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetCatalogRequest) { +} + +func (newState *GetCatalogRequest) SyncEffectiveFieldsDuringRead(existingState GetCatalogRequest) { +} + // Get a connection type GetConnectionRequest struct { // Name of the connection. Name types.String `tfsdk:"-"` } +func (newState *GetConnectionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetConnectionRequest) { +} + +func (newState *GetConnectionRequest) SyncEffectiveFieldsDuringRead(existingState GetConnectionRequest) { +} + // Get effective permissions type GetEffectiveRequest struct { // Full name of securable. @@ -1155,6 +1731,12 @@ type GetEffectiveRequest struct { SecurableType types.String `tfsdk:"-"` } +func (newState *GetEffectiveRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetEffectiveRequest) { +} + +func (newState *GetEffectiveRequest) SyncEffectiveFieldsDuringRead(existingState GetEffectiveRequest) { +} + // Get an external location type GetExternalLocationRequest struct { // Whether to include external locations in the response for which the @@ -1164,6 +1746,12 @@ type GetExternalLocationRequest struct { Name types.String `tfsdk:"-"` } +func (newState *GetExternalLocationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetExternalLocationRequest) { +} + +func (newState *GetExternalLocationRequest) SyncEffectiveFieldsDuringRead(existingState GetExternalLocationRequest) { +} + // Get a function type GetFunctionRequest struct { // Whether to include functions in the response for which the principal can @@ -1174,6 +1762,12 @@ type GetFunctionRequest struct { Name types.String `tfsdk:"-"` } +func (newState *GetFunctionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetFunctionRequest) { +} + +func (newState *GetFunctionRequest) SyncEffectiveFieldsDuringRead(existingState GetFunctionRequest) { +} + // Get permissions type GetGrantRequest struct { // Full name of securable. @@ -1185,12 +1779,24 @@ type GetGrantRequest struct { SecurableType types.String `tfsdk:"-"` } +func (newState *GetGrantRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetGrantRequest) { +} + +func (newState *GetGrantRequest) SyncEffectiveFieldsDuringRead(existingState GetGrantRequest) { +} + // Get a metastore type GetMetastoreRequest struct { // Unique ID of the metastore. Id types.String `tfsdk:"-"` } +func (newState *GetMetastoreRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetMetastoreRequest) { +} + +func (newState *GetMetastoreRequest) SyncEffectiveFieldsDuringRead(existingState GetMetastoreRequest) { +} + type GetMetastoreSummaryResponse struct { // Cloud vendor of the metastore home shard (e.g., `aws`, `azure`, `gcp`). Cloud types.String `tfsdk:"cloud" tf:"optional"` @@ -1236,6 +1842,12 @@ type GetMetastoreSummaryResponse struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *GetMetastoreSummaryResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetMetastoreSummaryResponse) { +} + +func (newState *GetMetastoreSummaryResponse) SyncEffectiveFieldsDuringRead(existingState GetMetastoreSummaryResponse) { +} + // Get a Model Version type GetModelVersionRequest struct { // The three-level (fully qualified) name of the model version @@ -1250,18 +1862,36 @@ type GetModelVersionRequest struct { Version types.Int64 `tfsdk:"-"` } +func (newState *GetModelVersionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetModelVersionRequest) { +} + +func (newState *GetModelVersionRequest) SyncEffectiveFieldsDuringRead(existingState GetModelVersionRequest) { +} + // Get an Online Table type GetOnlineTableRequest struct { // Full three-part (catalog, schema, table) name of the table. Name types.String `tfsdk:"-"` } +func (newState *GetOnlineTableRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetOnlineTableRequest) { +} + +func (newState *GetOnlineTableRequest) SyncEffectiveFieldsDuringRead(existingState GetOnlineTableRequest) { +} + // Get a table monitor type GetQualityMonitorRequest struct { // Full name of the table. TableName types.String `tfsdk:"-"` } +func (newState *GetQualityMonitorRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetQualityMonitorRequest) { +} + +func (newState *GetQualityMonitorRequest) SyncEffectiveFieldsDuringRead(existingState GetQualityMonitorRequest) { +} + // Get information for a single resource quota. type GetQuotaRequest struct { // Full name of the parent resource. Provide the metastore ID if the parent @@ -1274,11 +1904,23 @@ type GetQuotaRequest struct { QuotaName types.String `tfsdk:"-"` } +func (newState *GetQuotaRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetQuotaRequest) { +} + +func (newState *GetQuotaRequest) SyncEffectiveFieldsDuringRead(existingState GetQuotaRequest) { +} + type GetQuotaResponse struct { // The returned QuotaInfo. QuotaInfo []QuotaInfo `tfsdk:"quota_info" tf:"optional,object"` } +func (newState *GetQuotaResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetQuotaResponse) { +} + +func (newState *GetQuotaResponse) SyncEffectiveFieldsDuringRead(existingState GetQuotaResponse) { +} + // Get refresh type GetRefreshRequest struct { // ID of the refresh. @@ -1287,6 +1929,12 @@ type GetRefreshRequest struct { TableName types.String `tfsdk:"-"` } +func (newState *GetRefreshRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRefreshRequest) { +} + +func (newState *GetRefreshRequest) SyncEffectiveFieldsDuringRead(existingState GetRefreshRequest) { +} + // Get a Registered Model type GetRegisteredModelRequest struct { // The three-level (fully qualified) name of the registered model @@ -1298,6 +1946,12 @@ type GetRegisteredModelRequest struct { IncludeBrowse types.Bool `tfsdk:"-"` } +func (newState *GetRegisteredModelRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRegisteredModelRequest) { +} + +func (newState *GetRegisteredModelRequest) SyncEffectiveFieldsDuringRead(existingState GetRegisteredModelRequest) { +} + // Get a schema type GetSchemaRequest struct { // Full name of the schema. @@ -1307,12 +1961,24 @@ type GetSchemaRequest struct { IncludeBrowse types.Bool `tfsdk:"-"` } +func (newState *GetSchemaRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetSchemaRequest) { +} + +func (newState *GetSchemaRequest) SyncEffectiveFieldsDuringRead(existingState GetSchemaRequest) { +} + // Get a credential type GetStorageCredentialRequest struct { // Name of the storage credential. Name types.String `tfsdk:"-"` } +func (newState *GetStorageCredentialRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetStorageCredentialRequest) { +} + +func (newState *GetStorageCredentialRequest) SyncEffectiveFieldsDuringRead(existingState GetStorageCredentialRequest) { +} + // Get a table type GetTableRequest struct { // Full name of the table. @@ -1326,34 +1992,70 @@ type GetTableRequest struct { IncludeManifestCapabilities types.Bool `tfsdk:"-"` } +func (newState *GetTableRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetTableRequest) { +} + +func (newState *GetTableRequest) SyncEffectiveFieldsDuringRead(existingState GetTableRequest) { +} + // Get catalog workspace bindings type GetWorkspaceBindingRequest struct { // The name of the catalog. Name types.String `tfsdk:"-"` } +func (newState *GetWorkspaceBindingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWorkspaceBindingRequest) { +} + +func (newState *GetWorkspaceBindingRequest) SyncEffectiveFieldsDuringRead(existingState GetWorkspaceBindingRequest) { +} + // Get all workspaces assigned to a metastore type ListAccountMetastoreAssignmentsRequest struct { // Unity Catalog metastore ID MetastoreId types.String `tfsdk:"-"` } +func (newState *ListAccountMetastoreAssignmentsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAccountMetastoreAssignmentsRequest) { +} + +func (newState *ListAccountMetastoreAssignmentsRequest) SyncEffectiveFieldsDuringRead(existingState ListAccountMetastoreAssignmentsRequest) { +} + // The list of workspaces to which the given metastore is assigned. type ListAccountMetastoreAssignmentsResponse struct { WorkspaceIds []types.Int64 `tfsdk:"workspace_ids" tf:"optional"` } +func (newState *ListAccountMetastoreAssignmentsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAccountMetastoreAssignmentsResponse) { +} + +func (newState *ListAccountMetastoreAssignmentsResponse) SyncEffectiveFieldsDuringRead(existingState ListAccountMetastoreAssignmentsResponse) { +} + // Get all storage credentials assigned to a metastore type ListAccountStorageCredentialsRequest struct { // Unity Catalog metastore ID MetastoreId types.String `tfsdk:"-"` } +func (newState *ListAccountStorageCredentialsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAccountStorageCredentialsRequest) { +} + +func (newState *ListAccountStorageCredentialsRequest) SyncEffectiveFieldsDuringRead(existingState ListAccountStorageCredentialsRequest) { +} + type ListAccountStorageCredentialsResponse struct { // An array of metastore storage credentials. StorageCredentials []StorageCredentialInfo `tfsdk:"storage_credentials" tf:"optional"` } +func (newState *ListAccountStorageCredentialsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAccountStorageCredentialsResponse) { +} + +func (newState *ListAccountStorageCredentialsResponse) SyncEffectiveFieldsDuringRead(existingState ListAccountStorageCredentialsResponse) { +} + // List catalogs type ListCatalogsRequest struct { // Whether to include catalogs in the response for which the principal can @@ -1373,6 +2075,12 @@ type ListCatalogsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListCatalogsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListCatalogsRequest) { +} + +func (newState *ListCatalogsRequest) SyncEffectiveFieldsDuringRead(existingState ListCatalogsRequest) { +} + type ListCatalogsResponse struct { // An array of catalog information objects. Catalogs []CatalogInfo `tfsdk:"catalogs" tf:"optional"` @@ -1382,6 +2090,12 @@ type ListCatalogsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListCatalogsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListCatalogsResponse) { +} + +func (newState *ListCatalogsResponse) SyncEffectiveFieldsDuringRead(existingState ListCatalogsResponse) { +} + // List connections type ListConnectionsRequest struct { // Maximum number of connections to return. - If not set, all connections @@ -1395,6 +2109,12 @@ type ListConnectionsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListConnectionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListConnectionsRequest) { +} + +func (newState *ListConnectionsRequest) SyncEffectiveFieldsDuringRead(existingState ListConnectionsRequest) { +} + type ListConnectionsResponse struct { // An array of connection information objects. Connections []ConnectionInfo `tfsdk:"connections" tf:"optional"` @@ -1404,6 +2124,12 @@ type ListConnectionsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListConnectionsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListConnectionsResponse) { +} + +func (newState *ListConnectionsResponse) SyncEffectiveFieldsDuringRead(existingState ListConnectionsResponse) { +} + // List external locations type ListExternalLocationsRequest struct { // Whether to include external locations in the response for which the @@ -1420,6 +2146,12 @@ type ListExternalLocationsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListExternalLocationsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListExternalLocationsRequest) { +} + +func (newState *ListExternalLocationsRequest) SyncEffectiveFieldsDuringRead(existingState ListExternalLocationsRequest) { +} + type ListExternalLocationsResponse struct { // An array of external locations. ExternalLocations []ExternalLocationInfo `tfsdk:"external_locations" tf:"optional"` @@ -1429,6 +2161,12 @@ type ListExternalLocationsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListExternalLocationsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListExternalLocationsResponse) { +} + +func (newState *ListExternalLocationsResponse) SyncEffectiveFieldsDuringRead(existingState ListExternalLocationsResponse) { +} + // List functions type ListFunctionsRequest struct { // Name of parent catalog for functions of interest. @@ -1449,6 +2187,12 @@ type ListFunctionsRequest struct { SchemaName types.String `tfsdk:"-"` } +func (newState *ListFunctionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListFunctionsRequest) { +} + +func (newState *ListFunctionsRequest) SyncEffectiveFieldsDuringRead(existingState ListFunctionsRequest) { +} + type ListFunctionsResponse struct { // An array of function information objects. Functions []FunctionInfo `tfsdk:"functions" tf:"optional"` @@ -1458,11 +2202,23 @@ type ListFunctionsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListFunctionsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListFunctionsResponse) { +} + +func (newState *ListFunctionsResponse) SyncEffectiveFieldsDuringRead(existingState ListFunctionsResponse) { +} + type ListMetastoresResponse struct { // An array of metastore information objects. Metastores []MetastoreInfo `tfsdk:"metastores" tf:"optional"` } +func (newState *ListMetastoresResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListMetastoresResponse) { +} + +func (newState *ListMetastoresResponse) SyncEffectiveFieldsDuringRead(existingState ListMetastoresResponse) { +} + // List Model Versions type ListModelVersionsRequest struct { // The full three-level name of the registered model under which to list @@ -1483,6 +2239,12 @@ type ListModelVersionsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListModelVersionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListModelVersionsRequest) { +} + +func (newState *ListModelVersionsRequest) SyncEffectiveFieldsDuringRead(existingState ListModelVersionsRequest) { +} + type ListModelVersionsResponse struct { ModelVersions []ModelVersionInfo `tfsdk:"model_versions" tf:"optional"` // Opaque token to retrieve the next page of results. Absent if there are no @@ -1491,6 +2253,12 @@ type ListModelVersionsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListModelVersionsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListModelVersionsResponse) { +} + +func (newState *ListModelVersionsResponse) SyncEffectiveFieldsDuringRead(existingState ListModelVersionsResponse) { +} + // List all resource quotas under a metastore. type ListQuotasRequest struct { // The number of quotas to return. @@ -1499,6 +2267,12 @@ type ListQuotasRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListQuotasRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListQuotasRequest) { +} + +func (newState *ListQuotasRequest) SyncEffectiveFieldsDuringRead(existingState ListQuotasRequest) { +} + type ListQuotasResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -1508,12 +2282,24 @@ type ListQuotasResponse struct { Quotas []QuotaInfo `tfsdk:"quotas" tf:"optional"` } +func (newState *ListQuotasResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListQuotasResponse) { +} + +func (newState *ListQuotasResponse) SyncEffectiveFieldsDuringRead(existingState ListQuotasResponse) { +} + // List refreshes type ListRefreshesRequest struct { // Full name of the table. TableName types.String `tfsdk:"-"` } +func (newState *ListRefreshesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListRefreshesRequest) { +} + +func (newState *ListRefreshesRequest) SyncEffectiveFieldsDuringRead(existingState ListRefreshesRequest) { +} + // List Registered Models type ListRegisteredModelsRequest struct { // The identifier of the catalog under which to list registered models. If @@ -1547,6 +2333,12 @@ type ListRegisteredModelsRequest struct { SchemaName types.String `tfsdk:"-"` } +func (newState *ListRegisteredModelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListRegisteredModelsRequest) { +} + +func (newState *ListRegisteredModelsRequest) SyncEffectiveFieldsDuringRead(existingState ListRegisteredModelsRequest) { +} + type ListRegisteredModelsResponse struct { // Opaque token for pagination. Omitted if there are no more results. // page_token should be set to this value for fetching the next page. @@ -1555,6 +2347,12 @@ type ListRegisteredModelsResponse struct { RegisteredModels []RegisteredModelInfo `tfsdk:"registered_models" tf:"optional"` } +func (newState *ListRegisteredModelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListRegisteredModelsResponse) { +} + +func (newState *ListRegisteredModelsResponse) SyncEffectiveFieldsDuringRead(existingState ListRegisteredModelsResponse) { +} + // List schemas type ListSchemasRequest struct { // Parent catalog for schemas of interest. @@ -1573,6 +2371,12 @@ type ListSchemasRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListSchemasRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSchemasRequest) { +} + +func (newState *ListSchemasRequest) SyncEffectiveFieldsDuringRead(existingState ListSchemasRequest) { +} + type ListSchemasResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -1582,6 +2386,12 @@ type ListSchemasResponse struct { Schemas []SchemaInfo `tfsdk:"schemas" tf:"optional"` } +func (newState *ListSchemasResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSchemasResponse) { +} + +func (newState *ListSchemasResponse) SyncEffectiveFieldsDuringRead(existingState ListSchemasResponse) { +} + // List credentials type ListStorageCredentialsRequest struct { // Maximum number of storage credentials to return. If not set, all the @@ -1595,6 +2405,12 @@ type ListStorageCredentialsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListStorageCredentialsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListStorageCredentialsRequest) { +} + +func (newState *ListStorageCredentialsRequest) SyncEffectiveFieldsDuringRead(existingState ListStorageCredentialsRequest) { +} + type ListStorageCredentialsResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -1604,6 +2420,12 @@ type ListStorageCredentialsResponse struct { StorageCredentials []StorageCredentialInfo `tfsdk:"storage_credentials" tf:"optional"` } +func (newState *ListStorageCredentialsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListStorageCredentialsResponse) { +} + +func (newState *ListStorageCredentialsResponse) SyncEffectiveFieldsDuringRead(existingState ListStorageCredentialsResponse) { +} + // List table summaries type ListSummariesRequest struct { // Name of parent catalog for tables of interest. @@ -1628,6 +2450,12 @@ type ListSummariesRequest struct { TableNamePattern types.String `tfsdk:"-"` } +func (newState *ListSummariesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSummariesRequest) { +} + +func (newState *ListSummariesRequest) SyncEffectiveFieldsDuringRead(existingState ListSummariesRequest) { +} + // List system schemas type ListSystemSchemasRequest struct { // Maximum number of schemas to return. - When set to 0, the page length is @@ -1643,6 +2471,12 @@ type ListSystemSchemasRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListSystemSchemasRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSystemSchemasRequest) { +} + +func (newState *ListSystemSchemasRequest) SyncEffectiveFieldsDuringRead(existingState ListSystemSchemasRequest) { +} + type ListSystemSchemasResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -1652,6 +2486,12 @@ type ListSystemSchemasResponse struct { Schemas []SystemSchemaInfo `tfsdk:"schemas" tf:"optional"` } +func (newState *ListSystemSchemasResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSystemSchemasResponse) { +} + +func (newState *ListSystemSchemasResponse) SyncEffectiveFieldsDuringRead(existingState ListSystemSchemasResponse) { +} + type ListTableSummariesResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -1661,6 +2501,12 @@ type ListTableSummariesResponse struct { Tables []TableSummary `tfsdk:"tables" tf:"optional"` } +func (newState *ListTableSummariesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListTableSummariesResponse) { +} + +func (newState *ListTableSummariesResponse) SyncEffectiveFieldsDuringRead(existingState ListTableSummariesResponse) { +} + // List tables type ListTablesRequest struct { // Name of parent catalog for tables of interest. @@ -1689,6 +2535,12 @@ type ListTablesRequest struct { SchemaName types.String `tfsdk:"-"` } +func (newState *ListTablesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListTablesRequest) { +} + +func (newState *ListTablesRequest) SyncEffectiveFieldsDuringRead(existingState ListTablesRequest) { +} + type ListTablesResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -1698,6 +2550,12 @@ type ListTablesResponse struct { Tables []TableInfo `tfsdk:"tables" tf:"optional"` } +func (newState *ListTablesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListTablesResponse) { +} + +func (newState *ListTablesResponse) SyncEffectiveFieldsDuringRead(existingState ListTablesResponse) { +} + // List Volumes type ListVolumesRequest struct { // The identifier of the catalog @@ -1725,6 +2583,12 @@ type ListVolumesRequest struct { SchemaName types.String `tfsdk:"-"` } +func (newState *ListVolumesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListVolumesRequest) { +} + +func (newState *ListVolumesRequest) SyncEffectiveFieldsDuringRead(existingState ListVolumesRequest) { +} + type ListVolumesResponseContent struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -1734,6 +2598,12 @@ type ListVolumesResponseContent struct { Volumes []VolumeInfo `tfsdk:"volumes" tf:"optional"` } +func (newState *ListVolumesResponseContent) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListVolumesResponseContent) { +} + +func (newState *ListVolumesResponseContent) SyncEffectiveFieldsDuringRead(existingState ListVolumesResponseContent) { +} + type MetastoreAssignment struct { // The name of the default catalog in the metastore. DefaultCatalogName types.String `tfsdk:"default_catalog_name" tf:"optional"` @@ -1743,6 +2613,12 @@ type MetastoreAssignment struct { WorkspaceId types.Int64 `tfsdk:"workspace_id" tf:""` } +func (newState *MetastoreAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan MetastoreAssignment) { +} + +func (newState *MetastoreAssignment) SyncEffectiveFieldsDuringRead(existingState MetastoreAssignment) { +} + type MetastoreInfo struct { // Cloud vendor of the metastore home shard (e.g., `aws`, `azure`, `gcp`). Cloud types.String `tfsdk:"cloud" tf:"optional"` @@ -1788,6 +2664,12 @@ type MetastoreInfo struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *MetastoreInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan MetastoreInfo) { +} + +func (newState *MetastoreInfo) SyncEffectiveFieldsDuringRead(existingState MetastoreInfo) { +} + type ModelVersionInfo struct { // List of aliases associated with the model version Aliases []RegisteredModelAlias `tfsdk:"aliases" tf:"optional"` @@ -1841,6 +2723,12 @@ type ModelVersionInfo struct { Version types.Int64 `tfsdk:"version" tf:"optional"` } +func (newState *ModelVersionInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ModelVersionInfo) { +} + +func (newState *ModelVersionInfo) SyncEffectiveFieldsDuringRead(existingState ModelVersionInfo) { +} + type MonitorCronSchedule struct { // Read only field that indicates whether a schedule is paused or not. PauseStatus types.String `tfsdk:"pause_status" tf:"optional"` @@ -1853,17 +2741,35 @@ type MonitorCronSchedule struct { TimezoneId types.String `tfsdk:"timezone_id" tf:""` } +func (newState *MonitorCronSchedule) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorCronSchedule) { +} + +func (newState *MonitorCronSchedule) SyncEffectiveFieldsDuringRead(existingState MonitorCronSchedule) { +} + type MonitorDataClassificationConfig struct { // Whether data classification is enabled. Enabled types.Bool `tfsdk:"enabled" tf:"optional"` } +func (newState *MonitorDataClassificationConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorDataClassificationConfig) { +} + +func (newState *MonitorDataClassificationConfig) SyncEffectiveFieldsDuringRead(existingState MonitorDataClassificationConfig) { +} + type MonitorDestination struct { // The list of email addresses to send the notification to. A maximum of 5 // email addresses is supported. EmailAddresses []types.String `tfsdk:"email_addresses" tf:"optional"` } +func (newState *MonitorDestination) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorDestination) { +} + +func (newState *MonitorDestination) SyncEffectiveFieldsDuringRead(existingState MonitorDestination) { +} + type MonitorInferenceLog struct { // Granularities for aggregating data into time windows based on their // timestamp. Currently the following static granularities are supported: @@ -1895,6 +2801,12 @@ type MonitorInferenceLog struct { TimestampCol types.String `tfsdk:"timestamp_col" tf:""` } +func (newState *MonitorInferenceLog) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorInferenceLog) { +} + +func (newState *MonitorInferenceLog) SyncEffectiveFieldsDuringRead(existingState MonitorInferenceLog) { +} + type MonitorInfo struct { // The directory to store monitoring assets (e.g. dashboard, metric tables). AssetsDir types.String `tfsdk:"assets_dir" tf:"optional"` @@ -1947,6 +2859,12 @@ type MonitorInfo struct { TimeSeries []MonitorTimeSeries `tfsdk:"time_series" tf:"optional,object"` } +func (newState *MonitorInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorInfo) { +} + +func (newState *MonitorInfo) SyncEffectiveFieldsDuringRead(existingState MonitorInfo) { +} + type MonitorMetric struct { // Jinja template for a SQL expression that specifies how to compute the // metric. See [create metric definition]. @@ -1974,6 +2892,12 @@ type MonitorMetric struct { Type types.String `tfsdk:"type" tf:""` } +func (newState *MonitorMetric) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorMetric) { +} + +func (newState *MonitorMetric) SyncEffectiveFieldsDuringRead(existingState MonitorMetric) { +} + type MonitorNotifications struct { // Who to send notifications to on monitor failure. OnFailure []MonitorDestination `tfsdk:"on_failure" tf:"optional,object"` @@ -1982,6 +2906,12 @@ type MonitorNotifications struct { OnNewClassificationTagDetected []MonitorDestination `tfsdk:"on_new_classification_tag_detected" tf:"optional,object"` } +func (newState *MonitorNotifications) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorNotifications) { +} + +func (newState *MonitorNotifications) SyncEffectiveFieldsDuringRead(existingState MonitorNotifications) { +} + type MonitorRefreshInfo struct { // Time at which refresh operation completed (milliseconds since 1/1/1970 // UTC). @@ -2000,14 +2930,32 @@ type MonitorRefreshInfo struct { Trigger types.String `tfsdk:"trigger" tf:"optional"` } +func (newState *MonitorRefreshInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorRefreshInfo) { +} + +func (newState *MonitorRefreshInfo) SyncEffectiveFieldsDuringRead(existingState MonitorRefreshInfo) { +} + type MonitorRefreshListResponse struct { // List of refreshes. Refreshes []MonitorRefreshInfo `tfsdk:"refreshes" tf:"optional"` } +func (newState *MonitorRefreshListResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorRefreshListResponse) { +} + +func (newState *MonitorRefreshListResponse) SyncEffectiveFieldsDuringRead(existingState MonitorRefreshListResponse) { +} + type MonitorSnapshot struct { } +func (newState *MonitorSnapshot) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorSnapshot) { +} + +func (newState *MonitorSnapshot) SyncEffectiveFieldsDuringRead(existingState MonitorSnapshot) { +} + type MonitorTimeSeries struct { // Granularities for aggregating data into time windows based on their // timestamp. Currently the following static granularities are supported: @@ -2023,21 +2971,50 @@ type MonitorTimeSeries struct { TimestampCol types.String `tfsdk:"timestamp_col" tf:""` } +func (newState *MonitorTimeSeries) SyncEffectiveFieldsDuringCreateOrUpdate(plan MonitorTimeSeries) { +} + +func (newState *MonitorTimeSeries) SyncEffectiveFieldsDuringRead(existingState MonitorTimeSeries) { +} + type NamedTableConstraint struct { // The name of the constraint. Name types.String `tfsdk:"name" tf:""` } +func (newState *NamedTableConstraint) SyncEffectiveFieldsDuringCreateOrUpdate(plan NamedTableConstraint) { +} + +func (newState *NamedTableConstraint) SyncEffectiveFieldsDuringRead(existingState NamedTableConstraint) { +} + // Online Table information. type OnlineTable struct { // Full three-part (catalog, schema, table) name of the table. Name types.String `tfsdk:"name" tf:"optional"` // Specification of the online table. Spec []OnlineTableSpec `tfsdk:"spec" tf:"optional,object"` - // Online Table status + // Online Table data synchronization status Status []OnlineTableStatus `tfsdk:"status" tf:"optional,object"` // Data serving REST API URL for this table - TableServingUrl types.String `tfsdk:"table_serving_url" tf:"optional"` + TableServingUrl types.String `tfsdk:"table_serving_url" tf:"optional"` + EffectiveTableServingUrl types.String `tfsdk:"effective_table_serving_url" tf:"computed,optional"` + // The provisioning state of the online table entity in Unity Catalog. This + // is distinct from the state of the data synchronization pipeline (i.e. the + // table may be in "ACTIVE" but the pipeline may be in "PROVISIONING" as it + // runs asynchronously). + UnityCatalogProvisioningState types.String `tfsdk:"unity_catalog_provisioning_state" tf:"optional"` +} + +func (newState *OnlineTable) SyncEffectiveFieldsDuringCreateOrUpdate(plan OnlineTable) { + newState.EffectiveTableServingUrl = newState.TableServingUrl + newState.TableServingUrl = plan.TableServingUrl +} + +func (newState *OnlineTable) SyncEffectiveFieldsDuringRead(existingState OnlineTable) { + if existingState.EffectiveTableServingUrl.ValueString() == newState.TableServingUrl.ValueString() { + newState.TableServingUrl = existingState.TableServingUrl + } } // Specification of an online table. @@ -2052,7 +3029,8 @@ type OnlineTableSpec struct { PerformFullCopy types.Bool `tfsdk:"perform_full_copy" tf:"optional"` // ID of the associated pipeline. Generated by the server - cannot be set by // the caller. - PipelineId types.String `tfsdk:"pipeline_id" tf:"optional"` + PipelineId types.String `tfsdk:"pipeline_id" tf:"optional"` + EffectivePipelineId types.String `tfsdk:"effective_pipeline_id" tf:"computed,optional"` // Primary Key columns to be used for data insert/update in the destination. PrimaryKeyColumns []types.String `tfsdk:"primary_key_columns" tf:"optional"` // Pipeline runs continuously after generating the initial data. @@ -2067,12 +3045,35 @@ type OnlineTableSpec struct { TimeseriesKey types.String `tfsdk:"timeseries_key" tf:"optional"` } +func (newState *OnlineTableSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan OnlineTableSpec) { + newState.EffectivePipelineId = newState.PipelineId + newState.PipelineId = plan.PipelineId +} + +func (newState *OnlineTableSpec) SyncEffectiveFieldsDuringRead(existingState OnlineTableSpec) { + if existingState.EffectivePipelineId.ValueString() == newState.PipelineId.ValueString() { + newState.PipelineId = existingState.PipelineId + } +} + type OnlineTableSpecContinuousSchedulingPolicy struct { } +func (newState *OnlineTableSpecContinuousSchedulingPolicy) SyncEffectiveFieldsDuringCreateOrUpdate(plan OnlineTableSpecContinuousSchedulingPolicy) { +} + +func (newState *OnlineTableSpecContinuousSchedulingPolicy) SyncEffectiveFieldsDuringRead(existingState OnlineTableSpecContinuousSchedulingPolicy) { +} + type OnlineTableSpecTriggeredSchedulingPolicy struct { } +func (newState *OnlineTableSpecTriggeredSchedulingPolicy) SyncEffectiveFieldsDuringCreateOrUpdate(plan OnlineTableSpecTriggeredSchedulingPolicy) { +} + +func (newState *OnlineTableSpecTriggeredSchedulingPolicy) SyncEffectiveFieldsDuringRead(existingState OnlineTableSpecTriggeredSchedulingPolicy) { +} + // Status of an online table. type OnlineTableStatus struct { // Detailed status of an online table. Shown if the online table is in the @@ -2094,6 +3095,12 @@ type OnlineTableStatus struct { TriggeredUpdateStatus []TriggeredUpdateStatus `tfsdk:"triggered_update_status" tf:"optional,object"` } +func (newState *OnlineTableStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan OnlineTableStatus) { +} + +func (newState *OnlineTableStatus) SyncEffectiveFieldsDuringRead(existingState OnlineTableStatus) { +} + type PermissionsChange struct { // The set of privileges to add. Add []types.String `tfsdk:"add" tf:"optional"` @@ -2103,11 +3110,23 @@ type PermissionsChange struct { Remove []types.String `tfsdk:"remove" tf:"optional"` } +func (newState *PermissionsChange) SyncEffectiveFieldsDuringCreateOrUpdate(plan PermissionsChange) { +} + +func (newState *PermissionsChange) SyncEffectiveFieldsDuringRead(existingState PermissionsChange) { +} + type PermissionsList struct { // The privileges assigned to each principal PrivilegeAssignments []PrivilegeAssignment `tfsdk:"privilege_assignments" tf:"optional"` } +func (newState *PermissionsList) SyncEffectiveFieldsDuringCreateOrUpdate(plan PermissionsList) { +} + +func (newState *PermissionsList) SyncEffectiveFieldsDuringRead(existingState PermissionsList) { +} + // Progress information of the Online Table data synchronization pipeline. type PipelineProgress struct { // The estimated time remaining to complete this update in seconds. @@ -2124,6 +3143,12 @@ type PipelineProgress struct { TotalRowCount types.Int64 `tfsdk:"total_row_count" tf:"optional"` } +func (newState *PipelineProgress) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineProgress) { +} + +func (newState *PipelineProgress) SyncEffectiveFieldsDuringRead(existingState PipelineProgress) { +} + type PrimaryKeyConstraint struct { // Column names for this constraint. ChildColumns []types.String `tfsdk:"child_columns" tf:""` @@ -2131,6 +3156,12 @@ type PrimaryKeyConstraint struct { Name types.String `tfsdk:"name" tf:""` } +func (newState *PrimaryKeyConstraint) SyncEffectiveFieldsDuringCreateOrUpdate(plan PrimaryKeyConstraint) { +} + +func (newState *PrimaryKeyConstraint) SyncEffectiveFieldsDuringRead(existingState PrimaryKeyConstraint) { +} + type PrivilegeAssignment struct { // The principal (user email address or group name). Principal types.String `tfsdk:"principal" tf:"optional"` @@ -2138,11 +3169,23 @@ type PrivilegeAssignment struct { Privileges []types.String `tfsdk:"privileges" tf:"optional"` } +func (newState *PrivilegeAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan PrivilegeAssignment) { +} + +func (newState *PrivilegeAssignment) SyncEffectiveFieldsDuringRead(existingState PrivilegeAssignment) { +} + // Status of an asynchronously provisioned resource. type ProvisioningInfo struct { State types.String `tfsdk:"state" tf:"optional"` } +func (newState *ProvisioningInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ProvisioningInfo) { +} + +func (newState *ProvisioningInfo) SyncEffectiveFieldsDuringRead(existingState ProvisioningInfo) { +} + // Detailed status of an online table. Shown if the online table is in the // PROVISIONING_PIPELINE_RESOURCES or the PROVISIONING_INITIAL_SNAPSHOT state. type ProvisioningStatus struct { @@ -2151,6 +3194,12 @@ type ProvisioningStatus struct { InitialPipelineSyncProgress []PipelineProgress `tfsdk:"initial_pipeline_sync_progress" tf:"optional,object"` } +func (newState *ProvisioningStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan ProvisioningStatus) { +} + +func (newState *ProvisioningStatus) SyncEffectiveFieldsDuringRead(existingState ProvisioningStatus) { +} + type QuotaInfo struct { // The timestamp that indicates when the quota count was last updated. LastRefreshedAt types.Int64 `tfsdk:"last_refreshed_at" tf:"optional"` @@ -2167,6 +3216,12 @@ type QuotaInfo struct { QuotaName types.String `tfsdk:"quota_name" tf:"optional"` } +func (newState *QuotaInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan QuotaInfo) { +} + +func (newState *QuotaInfo) SyncEffectiveFieldsDuringRead(existingState QuotaInfo) { +} + // R2 temporary credentials for API authentication. Read more at // https://developers.cloudflare.com/r2/api/s3/tokens/. type R2Credentials struct { @@ -2178,6 +3233,12 @@ type R2Credentials struct { SessionToken types.String `tfsdk:"session_token" tf:"optional"` } +func (newState *R2Credentials) SyncEffectiveFieldsDuringCreateOrUpdate(plan R2Credentials) { +} + +func (newState *R2Credentials) SyncEffectiveFieldsDuringRead(existingState R2Credentials) { +} + // Get a Volume type ReadVolumeRequest struct { // Whether to include volumes in the response for which the principal can @@ -2187,6 +3248,12 @@ type ReadVolumeRequest struct { Name types.String `tfsdk:"-"` } +func (newState *ReadVolumeRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ReadVolumeRequest) { +} + +func (newState *ReadVolumeRequest) SyncEffectiveFieldsDuringRead(existingState ReadVolumeRequest) { +} + type RegenerateDashboardRequest struct { // Full name of the table. TableName types.String `tfsdk:"-"` @@ -2195,6 +3262,12 @@ type RegenerateDashboardRequest struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *RegenerateDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegenerateDashboardRequest) { +} + +func (newState *RegenerateDashboardRequest) SyncEffectiveFieldsDuringRead(existingState RegenerateDashboardRequest) { +} + type RegenerateDashboardResponse struct { // Id of the regenerated monitoring dashboard. DashboardId types.String `tfsdk:"dashboard_id" tf:"optional"` @@ -2202,6 +3275,12 @@ type RegenerateDashboardResponse struct { ParentFolder types.String `tfsdk:"parent_folder" tf:"optional"` } +func (newState *RegenerateDashboardResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegenerateDashboardResponse) { +} + +func (newState *RegenerateDashboardResponse) SyncEffectiveFieldsDuringRead(existingState RegenerateDashboardResponse) { +} + // Registered model alias. type RegisteredModelAlias struct { // Name of the alias, e.g. 'champion' or 'latest_stable' @@ -2210,6 +3289,12 @@ type RegisteredModelAlias struct { VersionNum types.Int64 `tfsdk:"version_num" tf:"optional"` } +func (newState *RegisteredModelAlias) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegisteredModelAlias) { +} + +func (newState *RegisteredModelAlias) SyncEffectiveFieldsDuringRead(existingState RegisteredModelAlias) { +} + type RegisteredModelInfo struct { // List of aliases associated with the registered model Aliases []RegisteredModelAlias `tfsdk:"aliases" tf:"optional"` @@ -2246,12 +3331,24 @@ type RegisteredModelInfo struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *RegisteredModelInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegisteredModelInfo) { +} + +func (newState *RegisteredModelInfo) SyncEffectiveFieldsDuringRead(existingState RegisteredModelInfo) { +} + // Queue a metric refresh for a monitor type RunRefreshRequest struct { // Full name of the table. TableName types.String `tfsdk:"-"` } +func (newState *RunRefreshRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunRefreshRequest) { +} + +func (newState *RunRefreshRequest) SyncEffectiveFieldsDuringRead(existingState RunRefreshRequest) { +} + type SchemaInfo struct { // Indicates whether the principal is limited to retrieving metadata for the // associated object through the BROWSE privilege when include_browse is @@ -2294,6 +3391,12 @@ type SchemaInfo struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *SchemaInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan SchemaInfo) { +} + +func (newState *SchemaInfo) SyncEffectiveFieldsDuringRead(existingState SchemaInfo) { +} + type SetArtifactAllowlist struct { // A list of allowed artifact match patterns. ArtifactMatchers []ArtifactMatcher `tfsdk:"artifact_matchers" tf:""` @@ -2301,6 +3404,12 @@ type SetArtifactAllowlist struct { ArtifactType types.String `tfsdk:"-"` } +func (newState *SetArtifactAllowlist) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetArtifactAllowlist) { +} + +func (newState *SetArtifactAllowlist) SyncEffectiveFieldsDuringRead(existingState SetArtifactAllowlist) { +} + type SetRegisteredModelAliasRequest struct { // The name of the alias Alias types.String `tfsdk:"alias" tf:""` @@ -2310,6 +3419,12 @@ type SetRegisteredModelAliasRequest struct { VersionNum types.Int64 `tfsdk:"version_num" tf:""` } +func (newState *SetRegisteredModelAliasRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetRegisteredModelAliasRequest) { +} + +func (newState *SetRegisteredModelAliasRequest) SyncEffectiveFieldsDuringRead(existingState SetRegisteredModelAliasRequest) { +} + // Server-Side Encryption properties for clients communicating with AWS s3. type SseEncryptionDetails struct { // The type of key encryption to use (affects headers from s3 client). @@ -2319,6 +3434,12 @@ type SseEncryptionDetails struct { AwsKmsKeyArn types.String `tfsdk:"aws_kms_key_arn" tf:"optional"` } +func (newState *SseEncryptionDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan SseEncryptionDetails) { +} + +func (newState *SseEncryptionDetails) SyncEffectiveFieldsDuringRead(existingState SseEncryptionDetails) { +} + type StorageCredentialInfo struct { // The AWS IAM role configuration. AwsIamRole []AwsIamRoleResponse `tfsdk:"aws_iam_role" tf:"optional,object"` @@ -2358,6 +3479,12 @@ type StorageCredentialInfo struct { UsedForManagedStorage types.Bool `tfsdk:"used_for_managed_storage" tf:"optional"` } +func (newState *StorageCredentialInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan StorageCredentialInfo) { +} + +func (newState *StorageCredentialInfo) SyncEffectiveFieldsDuringRead(existingState StorageCredentialInfo) { +} + type SystemSchemaInfo struct { // Name of the system schema. Schema types.String `tfsdk:"schema" tf:"optional"` @@ -2366,6 +3493,12 @@ type SystemSchemaInfo struct { State types.String `tfsdk:"state" tf:"optional"` } +func (newState *SystemSchemaInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan SystemSchemaInfo) { +} + +func (newState *SystemSchemaInfo) SyncEffectiveFieldsDuringRead(existingState SystemSchemaInfo) { +} + // A table constraint, as defined by *one* of the following fields being set: // __primary_key_constraint__, __foreign_key_constraint__, // __named_table_constraint__. @@ -2377,6 +3510,12 @@ type TableConstraint struct { PrimaryKeyConstraint []PrimaryKeyConstraint `tfsdk:"primary_key_constraint" tf:"optional,object"` } +func (newState *TableConstraint) SyncEffectiveFieldsDuringCreateOrUpdate(plan TableConstraint) { +} + +func (newState *TableConstraint) SyncEffectiveFieldsDuringRead(existingState TableConstraint) { +} + // A table that is dependent on a SQL object. type TableDependency struct { // Full name of the dependent table, in the form of @@ -2384,11 +3523,23 @@ type TableDependency struct { TableFullName types.String `tfsdk:"table_full_name" tf:""` } +func (newState *TableDependency) SyncEffectiveFieldsDuringCreateOrUpdate(plan TableDependency) { +} + +func (newState *TableDependency) SyncEffectiveFieldsDuringRead(existingState TableDependency) { +} + type TableExistsResponse struct { // Whether the table exists or not. TableExists types.Bool `tfsdk:"table_exists" tf:"optional"` } +func (newState *TableExistsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan TableExistsResponse) { +} + +func (newState *TableExistsResponse) SyncEffectiveFieldsDuringRead(existingState TableExistsResponse) { +} + type TableInfo struct { // The AWS access point to use when accesing s3 for this external location. AccessPoint types.String `tfsdk:"access_point" tf:"optional"` @@ -2469,6 +3620,12 @@ type TableInfo struct { ViewDependencies []DependencyList `tfsdk:"view_dependencies" tf:"optional,object"` } +func (newState *TableInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan TableInfo) { +} + +func (newState *TableInfo) SyncEffectiveFieldsDuringRead(existingState TableInfo) { +} + type TableRowFilter struct { // The full name of the row filter SQL UDF. FunctionName types.String `tfsdk:"function_name" tf:""` @@ -2478,6 +3635,12 @@ type TableRowFilter struct { InputColumnNames []types.String `tfsdk:"input_column_names" tf:""` } +func (newState *TableRowFilter) SyncEffectiveFieldsDuringCreateOrUpdate(plan TableRowFilter) { +} + +func (newState *TableRowFilter) SyncEffectiveFieldsDuringRead(existingState TableRowFilter) { +} + type TableSummary struct { // The full name of the table. FullName types.String `tfsdk:"full_name" tf:"optional"` @@ -2485,6 +3648,12 @@ type TableSummary struct { TableType types.String `tfsdk:"table_type" tf:"optional"` } +func (newState *TableSummary) SyncEffectiveFieldsDuringCreateOrUpdate(plan TableSummary) { +} + +func (newState *TableSummary) SyncEffectiveFieldsDuringRead(existingState TableSummary) { +} + // Detailed status of an online table. Shown if the online table is in the // ONLINE_TRIGGERED_UPDATE or the ONLINE_NO_PENDING_UPDATE state. type TriggeredUpdateStatus struct { @@ -2499,6 +3668,12 @@ type TriggeredUpdateStatus struct { TriggeredUpdateProgress []PipelineProgress `tfsdk:"triggered_update_progress" tf:"optional,object"` } +func (newState *TriggeredUpdateStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan TriggeredUpdateStatus) { +} + +func (newState *TriggeredUpdateStatus) SyncEffectiveFieldsDuringRead(existingState TriggeredUpdateStatus) { +} + // Delete an assignment type UnassignRequest struct { // Query for the ID of the metastore to delete. @@ -2507,12 +3682,30 @@ type UnassignRequest struct { WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *UnassignRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UnassignRequest) { +} + +func (newState *UnassignRequest) SyncEffectiveFieldsDuringRead(existingState UnassignRequest) { +} + type UnassignResponse struct { } +func (newState *UnassignResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UnassignResponse) { +} + +func (newState *UnassignResponse) SyncEffectiveFieldsDuringRead(existingState UnassignResponse) { +} + type UpdateAssignmentResponse struct { } +func (newState *UpdateAssignmentResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateAssignmentResponse) { +} + +func (newState *UpdateAssignmentResponse) SyncEffectiveFieldsDuringRead(existingState UpdateAssignmentResponse) { +} + type UpdateCatalog struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -2532,6 +3725,12 @@ type UpdateCatalog struct { Properties map[string]types.String `tfsdk:"properties" tf:"optional"` } +func (newState *UpdateCatalog) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateCatalog) { +} + +func (newState *UpdateCatalog) SyncEffectiveFieldsDuringRead(existingState UpdateCatalog) { +} + type UpdateConnection struct { // Name of the connection. Name types.String `tfsdk:"-"` @@ -2543,6 +3742,12 @@ type UpdateConnection struct { Owner types.String `tfsdk:"owner" tf:"optional"` } +func (newState *UpdateConnection) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateConnection) { +} + +func (newState *UpdateConnection) SyncEffectiveFieldsDuringRead(existingState UpdateConnection) { +} + type UpdateExternalLocation struct { // The AWS access point to use when accesing s3 for this external location. AccessPoint types.String `tfsdk:"access_point" tf:"optional"` @@ -2577,6 +3782,12 @@ type UpdateExternalLocation struct { Url types.String `tfsdk:"url" tf:"optional"` } +func (newState *UpdateExternalLocation) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateExternalLocation) { +} + +func (newState *UpdateExternalLocation) SyncEffectiveFieldsDuringRead(existingState UpdateExternalLocation) { +} + type UpdateFunction struct { // The fully-qualified name of the function (of the form // __catalog_name__.__schema_name__.__function__name__). @@ -2585,6 +3796,12 @@ type UpdateFunction struct { Owner types.String `tfsdk:"owner" tf:"optional"` } +func (newState *UpdateFunction) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateFunction) { +} + +func (newState *UpdateFunction) SyncEffectiveFieldsDuringRead(existingState UpdateFunction) { +} + type UpdateMetastore struct { // The organization name of a Delta Sharing entity, to be used in // Databricks-to-Databricks Delta Sharing as the official name. @@ -2606,6 +3823,12 @@ type UpdateMetastore struct { StorageRootCredentialId types.String `tfsdk:"storage_root_credential_id" tf:"optional"` } +func (newState *UpdateMetastore) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateMetastore) { +} + +func (newState *UpdateMetastore) SyncEffectiveFieldsDuringRead(existingState UpdateMetastore) { +} + type UpdateMetastoreAssignment struct { // The name of the default catalog in the metastore. This field is // depracted. Please use "Default Namespace API" to configure the default @@ -2617,6 +3840,12 @@ type UpdateMetastoreAssignment struct { WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *UpdateMetastoreAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateMetastoreAssignment) { +} + +func (newState *UpdateMetastoreAssignment) SyncEffectiveFieldsDuringRead(existingState UpdateMetastoreAssignment) { +} + type UpdateModelVersionRequest struct { // The comment attached to the model version Comment types.String `tfsdk:"comment" tf:"optional"` @@ -2626,6 +3855,12 @@ type UpdateModelVersionRequest struct { Version types.Int64 `tfsdk:"-"` } +func (newState *UpdateModelVersionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateModelVersionRequest) { +} + +func (newState *UpdateModelVersionRequest) SyncEffectiveFieldsDuringRead(existingState UpdateModelVersionRequest) { +} + type UpdateMonitor struct { // Name of the baseline table from which drift metrics are computed from. // Columns in the monitored table should also be present in the baseline @@ -2662,6 +3897,12 @@ type UpdateMonitor struct { TimeSeries []MonitorTimeSeries `tfsdk:"time_series" tf:"optional,object"` } +func (newState *UpdateMonitor) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateMonitor) { +} + +func (newState *UpdateMonitor) SyncEffectiveFieldsDuringRead(existingState UpdateMonitor) { +} + type UpdatePermissions struct { // Array of permissions change objects. Changes []PermissionsChange `tfsdk:"changes" tf:"optional"` @@ -2671,6 +3912,12 @@ type UpdatePermissions struct { SecurableType types.String `tfsdk:"-"` } +func (newState *UpdatePermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdatePermissions) { +} + +func (newState *UpdatePermissions) SyncEffectiveFieldsDuringRead(existingState UpdatePermissions) { +} + type UpdateRegisteredModelRequest struct { // The comment attached to the registered model Comment types.String `tfsdk:"comment" tf:"optional"` @@ -2682,9 +3929,21 @@ type UpdateRegisteredModelRequest struct { Owner types.String `tfsdk:"owner" tf:"optional"` } +func (newState *UpdateRegisteredModelRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateRegisteredModelRequest) { +} + +func (newState *UpdateRegisteredModelRequest) SyncEffectiveFieldsDuringRead(existingState UpdateRegisteredModelRequest) { +} + type UpdateResponse struct { } +func (newState *UpdateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateResponse) { +} + +func (newState *UpdateResponse) SyncEffectiveFieldsDuringRead(existingState UpdateResponse) { +} + type UpdateSchema struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -2701,6 +3960,12 @@ type UpdateSchema struct { Properties map[string]types.String `tfsdk:"properties" tf:"optional"` } +func (newState *UpdateSchema) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateSchema) { +} + +func (newState *UpdateSchema) SyncEffectiveFieldsDuringRead(existingState UpdateSchema) { +} + type UpdateStorageCredential struct { // The AWS IAM role configuration. AwsIamRole []AwsIamRoleRequest `tfsdk:"aws_iam_role" tf:"optional,object"` @@ -2733,6 +3998,12 @@ type UpdateStorageCredential struct { SkipValidation types.Bool `tfsdk:"skip_validation" tf:"optional"` } +func (newState *UpdateStorageCredential) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateStorageCredential) { +} + +func (newState *UpdateStorageCredential) SyncEffectiveFieldsDuringRead(existingState UpdateStorageCredential) { +} + // Update a table owner. type UpdateTableRequest struct { // Full name of the table. @@ -2741,6 +4012,12 @@ type UpdateTableRequest struct { Owner types.String `tfsdk:"owner" tf:"optional"` } +func (newState *UpdateTableRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateTableRequest) { +} + +func (newState *UpdateTableRequest) SyncEffectiveFieldsDuringRead(existingState UpdateTableRequest) { +} + type UpdateVolumeRequestContent struct { // The comment attached to the volume Comment types.String `tfsdk:"comment" tf:"optional"` @@ -2752,6 +4029,12 @@ type UpdateVolumeRequestContent struct { Owner types.String `tfsdk:"owner" tf:"optional"` } +func (newState *UpdateVolumeRequestContent) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateVolumeRequestContent) { +} + +func (newState *UpdateVolumeRequestContent) SyncEffectiveFieldsDuringRead(existingState UpdateVolumeRequestContent) { +} + type UpdateWorkspaceBindings struct { // A list of workspace IDs. AssignWorkspaces []types.Int64 `tfsdk:"assign_workspaces" tf:"optional"` @@ -2761,6 +4044,12 @@ type UpdateWorkspaceBindings struct { UnassignWorkspaces []types.Int64 `tfsdk:"unassign_workspaces" tf:"optional"` } +func (newState *UpdateWorkspaceBindings) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateWorkspaceBindings) { +} + +func (newState *UpdateWorkspaceBindings) SyncEffectiveFieldsDuringRead(existingState UpdateWorkspaceBindings) { +} + type UpdateWorkspaceBindingsParameters struct { // List of workspace bindings Add []WorkspaceBinding `tfsdk:"add" tf:"optional"` @@ -2772,6 +4061,12 @@ type UpdateWorkspaceBindingsParameters struct { SecurableType types.String `tfsdk:"-"` } +func (newState *UpdateWorkspaceBindingsParameters) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateWorkspaceBindingsParameters) { +} + +func (newState *UpdateWorkspaceBindingsParameters) SyncEffectiveFieldsDuringRead(existingState UpdateWorkspaceBindingsParameters) { +} + type ValidateStorageCredential struct { // The AWS IAM role configuration. AwsIamRole []AwsIamRoleRequest `tfsdk:"aws_iam_role" tf:"optional,object"` @@ -2793,6 +4088,12 @@ type ValidateStorageCredential struct { Url types.String `tfsdk:"url" tf:"optional"` } +func (newState *ValidateStorageCredential) SyncEffectiveFieldsDuringCreateOrUpdate(plan ValidateStorageCredential) { +} + +func (newState *ValidateStorageCredential) SyncEffectiveFieldsDuringRead(existingState ValidateStorageCredential) { +} + type ValidateStorageCredentialResponse struct { // Whether the tested location is a directory in cloud storage. IsDir types.Bool `tfsdk:"isDir" tf:"optional"` @@ -2800,6 +4101,12 @@ type ValidateStorageCredentialResponse struct { Results []ValidationResult `tfsdk:"results" tf:"optional"` } +func (newState *ValidateStorageCredentialResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ValidateStorageCredentialResponse) { +} + +func (newState *ValidateStorageCredentialResponse) SyncEffectiveFieldsDuringRead(existingState ValidateStorageCredentialResponse) { +} + type ValidationResult struct { // Error message would exist when the result does not equal to **PASS**. Message types.String `tfsdk:"message" tf:"optional"` @@ -2809,6 +4116,12 @@ type ValidationResult struct { Result types.String `tfsdk:"result" tf:"optional"` } +func (newState *ValidationResult) SyncEffectiveFieldsDuringCreateOrUpdate(plan ValidationResult) { +} + +func (newState *ValidationResult) SyncEffectiveFieldsDuringRead(existingState ValidationResult) { +} + type VolumeInfo struct { // The AWS access point to use when accesing s3 for this external location. AccessPoint types.String `tfsdk:"access_point" tf:"optional"` @@ -2848,12 +4161,24 @@ type VolumeInfo struct { VolumeType types.String `tfsdk:"volume_type" tf:"optional"` } +func (newState *VolumeInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan VolumeInfo) { +} + +func (newState *VolumeInfo) SyncEffectiveFieldsDuringRead(existingState VolumeInfo) { +} + type WorkspaceBinding struct { BindingType types.String `tfsdk:"binding_type" tf:"optional"` WorkspaceId types.Int64 `tfsdk:"workspace_id" tf:"optional"` } +func (newState *WorkspaceBinding) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkspaceBinding) { +} + +func (newState *WorkspaceBinding) SyncEffectiveFieldsDuringRead(existingState WorkspaceBinding) { +} + // Currently assigned workspace bindings type WorkspaceBindingsResponse struct { // List of workspace bindings @@ -2863,3 +4188,9 @@ type WorkspaceBindingsResponse struct { // request (for the next page of results). NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } + +func (newState *WorkspaceBindingsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkspaceBindingsResponse) { +} + +func (newState *WorkspaceBindingsResponse) SyncEffectiveFieldsDuringRead(existingState WorkspaceBindingsResponse) { +} diff --git a/internal/service/compute_tf/model.go b/internal/service/compute_tf/model.go index dcc16fd50f..653cfec24f 100755 --- a/internal/service/compute_tf/model.go +++ b/internal/service/compute_tf/model.go @@ -43,15 +43,33 @@ type AddInstanceProfile struct { SkipValidation types.Bool `tfsdk:"skip_validation" tf:"optional"` } +func (newState *AddInstanceProfile) SyncEffectiveFieldsDuringCreateOrUpdate(plan AddInstanceProfile) { +} + +func (newState *AddInstanceProfile) SyncEffectiveFieldsDuringRead(existingState AddInstanceProfile) { +} + type AddResponse struct { } +func (newState *AddResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan AddResponse) { +} + +func (newState *AddResponse) SyncEffectiveFieldsDuringRead(existingState AddResponse) { +} + type Adlsgen2Info struct { // abfss destination, e.g. // `abfss://@.dfs.core.windows.net/`. Destination types.String `tfsdk:"destination" tf:""` } +func (newState *Adlsgen2Info) SyncEffectiveFieldsDuringCreateOrUpdate(plan Adlsgen2Info) { +} + +func (newState *Adlsgen2Info) SyncEffectiveFieldsDuringRead(existingState Adlsgen2Info) { +} + type AutoScale struct { // The maximum number of workers to which the cluster can scale up when // overloaded. Note that `max_workers` must be strictly greater than @@ -63,6 +81,12 @@ type AutoScale struct { MinWorkers types.Int64 `tfsdk:"min_workers" tf:"optional"` } +func (newState *AutoScale) SyncEffectiveFieldsDuringCreateOrUpdate(plan AutoScale) { +} + +func (newState *AutoScale) SyncEffectiveFieldsDuringRead(existingState AutoScale) { +} + type AwsAttributes struct { // Availability type used for all subsequent nodes past the // `first_on_demand` ones. @@ -149,6 +173,12 @@ type AwsAttributes struct { ZoneId types.String `tfsdk:"zone_id" tf:"optional"` } +func (newState *AwsAttributes) SyncEffectiveFieldsDuringCreateOrUpdate(plan AwsAttributes) { +} + +func (newState *AwsAttributes) SyncEffectiveFieldsDuringRead(existingState AwsAttributes) { +} + type AzureAttributes struct { // Availability type used for all subsequent nodes past the // `first_on_demand` ones. Note: If `first_on_demand` is zero (which only @@ -175,6 +205,12 @@ type AzureAttributes struct { SpotBidMaxPrice types.Float64 `tfsdk:"spot_bid_max_price" tf:"optional"` } +func (newState *AzureAttributes) SyncEffectiveFieldsDuringCreateOrUpdate(plan AzureAttributes) { +} + +func (newState *AzureAttributes) SyncEffectiveFieldsDuringRead(existingState AzureAttributes) { +} + type CancelCommand struct { ClusterId types.String `tfsdk:"clusterId" tf:"optional"` @@ -183,9 +219,21 @@ type CancelCommand struct { ContextId types.String `tfsdk:"contextId" tf:"optional"` } +func (newState *CancelCommand) SyncEffectiveFieldsDuringCreateOrUpdate(plan CancelCommand) { +} + +func (newState *CancelCommand) SyncEffectiveFieldsDuringRead(existingState CancelCommand) { +} + type CancelResponse struct { } +func (newState *CancelResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CancelResponse) { +} + +func (newState *CancelResponse) SyncEffectiveFieldsDuringRead(existingState CancelResponse) { +} + type ChangeClusterOwner struct { // ClusterId types.String `tfsdk:"cluster_id" tf:""` @@ -193,9 +241,21 @@ type ChangeClusterOwner struct { OwnerUsername types.String `tfsdk:"owner_username" tf:""` } +func (newState *ChangeClusterOwner) SyncEffectiveFieldsDuringCreateOrUpdate(plan ChangeClusterOwner) { +} + +func (newState *ChangeClusterOwner) SyncEffectiveFieldsDuringRead(existingState ChangeClusterOwner) { +} + type ChangeClusterOwnerResponse struct { } +func (newState *ChangeClusterOwnerResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ChangeClusterOwnerResponse) { +} + +func (newState *ChangeClusterOwnerResponse) SyncEffectiveFieldsDuringRead(existingState ChangeClusterOwnerResponse) { +} + type ClientsTypes struct { // With jobs set, the cluster can be used for jobs Jobs types.Bool `tfsdk:"jobs" tf:"optional"` @@ -203,15 +263,33 @@ type ClientsTypes struct { Notebooks types.Bool `tfsdk:"notebooks" tf:"optional"` } +func (newState *ClientsTypes) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClientsTypes) { +} + +func (newState *ClientsTypes) SyncEffectiveFieldsDuringRead(existingState ClientsTypes) { +} + type CloneCluster struct { // The cluster that is being cloned. SourceClusterId types.String `tfsdk:"source_cluster_id" tf:""` } +func (newState *CloneCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan CloneCluster) { +} + +func (newState *CloneCluster) SyncEffectiveFieldsDuringRead(existingState CloneCluster) { +} + type CloudProviderNodeInfo struct { Status []types.String `tfsdk:"status" tf:"optional"` } +func (newState *CloudProviderNodeInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CloudProviderNodeInfo) { +} + +func (newState *CloudProviderNodeInfo) SyncEffectiveFieldsDuringRead(existingState CloudProviderNodeInfo) { +} + type ClusterAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -223,6 +301,12 @@ type ClusterAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *ClusterAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterAccessControlRequest) { +} + +func (newState *ClusterAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState ClusterAccessControlRequest) { +} + type ClusterAccessControlResponse struct { // All permissions. AllPermissions []ClusterPermission `tfsdk:"all_permissions" tf:"optional"` @@ -236,6 +320,12 @@ type ClusterAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *ClusterAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterAccessControlResponse) { +} + +func (newState *ClusterAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState ClusterAccessControlResponse) { +} + type ClusterAttributes struct { // Automatically terminates the cluster after it is inactive for this time // in minutes. If not set, this cluster will not be automatically @@ -369,6 +459,12 @@ type ClusterAttributes struct { WorkloadType []WorkloadType `tfsdk:"workload_type" tf:"optional,object"` } +func (newState *ClusterAttributes) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterAttributes) { +} + +func (newState *ClusterAttributes) SyncEffectiveFieldsDuringRead(existingState ClusterAttributes) { +} + type ClusterCompliance struct { // Canonical unique identifier for a cluster. ClusterId types.String `tfsdk:"cluster_id" tf:""` @@ -382,6 +478,12 @@ type ClusterCompliance struct { Violations map[string]types.String `tfsdk:"violations" tf:"optional"` } +func (newState *ClusterCompliance) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterCompliance) { +} + +func (newState *ClusterCompliance) SyncEffectiveFieldsDuringRead(existingState ClusterCompliance) { +} + type ClusterDetails struct { // Parameters needed in order to automatically scale clusters up and down // based on load. Note: autoscaling works best with DB runtime versions 3.0 @@ -598,6 +700,12 @@ type ClusterDetails struct { WorkloadType []WorkloadType `tfsdk:"workload_type" tf:"optional,object"` } +func (newState *ClusterDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterDetails) { +} + +func (newState *ClusterDetails) SyncEffectiveFieldsDuringRead(existingState ClusterDetails) { +} + type ClusterEvent struct { // ClusterId types.String `tfsdk:"cluster_id" tf:""` @@ -613,6 +721,12 @@ type ClusterEvent struct { Type types.String `tfsdk:"type" tf:"optional"` } +func (newState *ClusterEvent) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterEvent) { +} + +func (newState *ClusterEvent) SyncEffectiveFieldsDuringRead(existingState ClusterEvent) { +} + type ClusterLibraryStatuses struct { // Unique identifier for the cluster. ClusterId types.String `tfsdk:"cluster_id" tf:"optional"` @@ -620,6 +734,12 @@ type ClusterLibraryStatuses struct { LibraryStatuses []LibraryFullStatus `tfsdk:"library_statuses" tf:"optional"` } +func (newState *ClusterLibraryStatuses) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterLibraryStatuses) { +} + +func (newState *ClusterLibraryStatuses) SyncEffectiveFieldsDuringRead(existingState ClusterLibraryStatuses) { +} + type ClusterLogConf struct { // destination needs to be provided. e.g. `{ "dbfs" : { "destination" : // "dbfs:/home/cluster_log" } }` @@ -632,6 +752,12 @@ type ClusterLogConf struct { S3 []S3StorageInfo `tfsdk:"s3" tf:"optional,object"` } +func (newState *ClusterLogConf) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterLogConf) { +} + +func (newState *ClusterLogConf) SyncEffectiveFieldsDuringRead(existingState ClusterLogConf) { +} + type ClusterPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -640,6 +766,12 @@ type ClusterPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *ClusterPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterPermission) { +} + +func (newState *ClusterPermission) SyncEffectiveFieldsDuringRead(existingState ClusterPermission) { +} + type ClusterPermissions struct { AccessControlList []ClusterAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -648,18 +780,36 @@ type ClusterPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *ClusterPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterPermissions) { +} + +func (newState *ClusterPermissions) SyncEffectiveFieldsDuringRead(existingState ClusterPermissions) { +} + type ClusterPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *ClusterPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterPermissionsDescription) { +} + +func (newState *ClusterPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState ClusterPermissionsDescription) { +} + type ClusterPermissionsRequest struct { AccessControlList []ClusterAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The cluster for which to get or manage permissions. ClusterId types.String `tfsdk:"-"` } +func (newState *ClusterPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterPermissionsRequest) { +} + +func (newState *ClusterPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState ClusterPermissionsRequest) { +} + type ClusterPolicyAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -671,6 +821,12 @@ type ClusterPolicyAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *ClusterPolicyAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterPolicyAccessControlRequest) { +} + +func (newState *ClusterPolicyAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState ClusterPolicyAccessControlRequest) { +} + type ClusterPolicyAccessControlResponse struct { // All permissions. AllPermissions []ClusterPolicyPermission `tfsdk:"all_permissions" tf:"optional"` @@ -684,6 +840,12 @@ type ClusterPolicyAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *ClusterPolicyAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterPolicyAccessControlResponse) { +} + +func (newState *ClusterPolicyAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState ClusterPolicyAccessControlResponse) { +} + type ClusterPolicyPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -692,6 +854,12 @@ type ClusterPolicyPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *ClusterPolicyPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterPolicyPermission) { +} + +func (newState *ClusterPolicyPermission) SyncEffectiveFieldsDuringRead(existingState ClusterPolicyPermission) { +} + type ClusterPolicyPermissions struct { AccessControlList []ClusterPolicyAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -700,18 +868,36 @@ type ClusterPolicyPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *ClusterPolicyPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterPolicyPermissions) { +} + +func (newState *ClusterPolicyPermissions) SyncEffectiveFieldsDuringRead(existingState ClusterPolicyPermissions) { +} + type ClusterPolicyPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *ClusterPolicyPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterPolicyPermissionsDescription) { +} + +func (newState *ClusterPolicyPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState ClusterPolicyPermissionsDescription) { +} + type ClusterPolicyPermissionsRequest struct { AccessControlList []ClusterPolicyAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The cluster policy for which to get or manage permissions. ClusterPolicyId types.String `tfsdk:"-"` } +func (newState *ClusterPolicyPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterPolicyPermissionsRequest) { +} + +func (newState *ClusterPolicyPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState ClusterPolicyPermissionsRequest) { +} + // Represents a change to the cluster settings required for the cluster to // become compliant with its policy. type ClusterSettingsChange struct { @@ -729,6 +915,12 @@ type ClusterSettingsChange struct { PreviousValue types.String `tfsdk:"previous_value" tf:"optional"` } +func (newState *ClusterSettingsChange) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterSettingsChange) { +} + +func (newState *ClusterSettingsChange) SyncEffectiveFieldsDuringRead(existingState ClusterSettingsChange) { +} + type ClusterSize struct { // Parameters needed in order to automatically scale clusters up and down // based on load. Note: autoscaling works best with DB runtime versions 3.0 @@ -747,6 +939,12 @@ type ClusterSize struct { NumWorkers types.Int64 `tfsdk:"num_workers" tf:"optional"` } +func (newState *ClusterSize) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterSize) { +} + +func (newState *ClusterSize) SyncEffectiveFieldsDuringRead(existingState ClusterSize) { +} + type ClusterSpec 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 @@ -899,12 +1097,24 @@ type ClusterSpec struct { WorkloadType []WorkloadType `tfsdk:"workload_type" tf:"optional,object"` } +func (newState *ClusterSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterSpec) { +} + +func (newState *ClusterSpec) SyncEffectiveFieldsDuringRead(existingState ClusterSpec) { +} + // Get status type ClusterStatus struct { // Unique identifier of the cluster whose status should be retrieved. ClusterId types.String `tfsdk:"-"` } +func (newState *ClusterStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterStatus) { +} + +func (newState *ClusterStatus) SyncEffectiveFieldsDuringRead(existingState ClusterStatus) { +} + type Command struct { // Running cluster id ClusterId types.String `tfsdk:"clusterId" tf:"optional"` @@ -916,6 +1126,12 @@ type Command struct { Language types.String `tfsdk:"language" tf:"optional"` } +func (newState *Command) SyncEffectiveFieldsDuringCreateOrUpdate(plan Command) { +} + +func (newState *Command) SyncEffectiveFieldsDuringRead(existingState Command) { +} + // Get command info type CommandStatusRequest struct { ClusterId types.String `tfsdk:"-"` @@ -925,6 +1141,12 @@ type CommandStatusRequest struct { ContextId types.String `tfsdk:"-"` } +func (newState *CommandStatusRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CommandStatusRequest) { +} + +func (newState *CommandStatusRequest) SyncEffectiveFieldsDuringRead(existingState CommandStatusRequest) { +} + type CommandStatusResponse struct { Id types.String `tfsdk:"id" tf:"optional"` @@ -933,6 +1155,12 @@ type CommandStatusResponse struct { Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *CommandStatusResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CommandStatusResponse) { +} + +func (newState *CommandStatusResponse) SyncEffectiveFieldsDuringRead(existingState CommandStatusResponse) { +} + // Get status type ContextStatusRequest struct { ClusterId types.String `tfsdk:"-"` @@ -940,12 +1168,24 @@ type ContextStatusRequest struct { ContextId types.String `tfsdk:"-"` } +func (newState *ContextStatusRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ContextStatusRequest) { +} + +func (newState *ContextStatusRequest) SyncEffectiveFieldsDuringRead(existingState ContextStatusRequest) { +} + type ContextStatusResponse struct { Id types.String `tfsdk:"id" tf:"optional"` Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *ContextStatusResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ContextStatusResponse) { +} + +func (newState *ContextStatusResponse) SyncEffectiveFieldsDuringRead(existingState ContextStatusResponse) { +} + type CreateCluster 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 @@ -1101,10 +1341,22 @@ type CreateCluster struct { WorkloadType []WorkloadType `tfsdk:"workload_type" tf:"optional,object"` } +func (newState *CreateCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCluster) { +} + +func (newState *CreateCluster) SyncEffectiveFieldsDuringRead(existingState CreateCluster) { +} + type CreateClusterResponse struct { ClusterId types.String `tfsdk:"cluster_id" tf:"optional"` } +func (newState *CreateClusterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateClusterResponse) { +} + +func (newState *CreateClusterResponse) SyncEffectiveFieldsDuringRead(existingState CreateClusterResponse) { +} + type CreateContext struct { // Running cluster id ClusterId types.String `tfsdk:"clusterId" tf:"optional"` @@ -1112,6 +1364,12 @@ type CreateContext struct { Language types.String `tfsdk:"language" tf:"optional"` } +func (newState *CreateContext) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateContext) { +} + +func (newState *CreateContext) SyncEffectiveFieldsDuringRead(existingState CreateContext) { +} + type CreateInstancePool struct { // Attributes related to instance pools running on Amazon Web Services. If // not specified at pool creation, a set of default values will be used. @@ -1169,11 +1427,23 @@ type CreateInstancePool struct { PreloadedSparkVersions []types.String `tfsdk:"preloaded_spark_versions" tf:"optional"` } +func (newState *CreateInstancePool) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateInstancePool) { +} + +func (newState *CreateInstancePool) SyncEffectiveFieldsDuringRead(existingState CreateInstancePool) { +} + type CreateInstancePoolResponse struct { // The ID of the created instance pool. InstancePoolId types.String `tfsdk:"instance_pool_id" tf:"optional"` } +func (newState *CreateInstancePoolResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateInstancePoolResponse) { +} + +func (newState *CreateInstancePoolResponse) SyncEffectiveFieldsDuringRead(existingState CreateInstancePoolResponse) { +} + type CreatePolicy struct { // Policy definition document expressed in [Databricks Cluster Policy // Definition Language]. @@ -1210,20 +1480,44 @@ type CreatePolicy struct { PolicyFamilyId types.String `tfsdk:"policy_family_id" tf:"optional"` } +func (newState *CreatePolicy) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreatePolicy) { +} + +func (newState *CreatePolicy) SyncEffectiveFieldsDuringRead(existingState CreatePolicy) { +} + type CreatePolicyResponse struct { // Canonical unique identifier for the cluster policy. PolicyId types.String `tfsdk:"policy_id" tf:"optional"` } +func (newState *CreatePolicyResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreatePolicyResponse) { +} + +func (newState *CreatePolicyResponse) SyncEffectiveFieldsDuringRead(existingState CreatePolicyResponse) { +} + type CreateResponse struct { // The global init script ID. ScriptId types.String `tfsdk:"script_id" tf:"optional"` } +func (newState *CreateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateResponse) { +} + +func (newState *CreateResponse) SyncEffectiveFieldsDuringRead(existingState CreateResponse) { +} + type Created struct { Id types.String `tfsdk:"id" tf:"optional"` } +func (newState *Created) SyncEffectiveFieldsDuringCreateOrUpdate(plan Created) { +} + +func (newState *Created) SyncEffectiveFieldsDuringRead(existingState Created) { +} + type DataPlaneEventDetails struct { // EventType types.String `tfsdk:"event_type" tf:"optional"` @@ -1235,53 +1529,125 @@ type DataPlaneEventDetails struct { Timestamp types.Int64 `tfsdk:"timestamp" tf:"optional"` } +func (newState *DataPlaneEventDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan DataPlaneEventDetails) { +} + +func (newState *DataPlaneEventDetails) SyncEffectiveFieldsDuringRead(existingState DataPlaneEventDetails) { +} + type DbfsStorageInfo struct { // dbfs destination, e.g. `dbfs:/my/path` Destination types.String `tfsdk:"destination" tf:""` } +func (newState *DbfsStorageInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan DbfsStorageInfo) { +} + +func (newState *DbfsStorageInfo) SyncEffectiveFieldsDuringRead(existingState DbfsStorageInfo) { +} + type DeleteCluster struct { // The cluster to be terminated. ClusterId types.String `tfsdk:"cluster_id" tf:""` } +func (newState *DeleteCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteCluster) { +} + +func (newState *DeleteCluster) SyncEffectiveFieldsDuringRead(existingState DeleteCluster) { +} + type DeleteClusterResponse struct { } +func (newState *DeleteClusterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteClusterResponse) { +} + +func (newState *DeleteClusterResponse) SyncEffectiveFieldsDuringRead(existingState DeleteClusterResponse) { +} + // Delete init script type DeleteGlobalInitScriptRequest struct { // The ID of the global init script. ScriptId types.String `tfsdk:"-"` } +func (newState *DeleteGlobalInitScriptRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteGlobalInitScriptRequest) { +} + +func (newState *DeleteGlobalInitScriptRequest) SyncEffectiveFieldsDuringRead(existingState DeleteGlobalInitScriptRequest) { +} + type DeleteInstancePool struct { // The instance pool to be terminated. InstancePoolId types.String `tfsdk:"instance_pool_id" tf:""` } +func (newState *DeleteInstancePool) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteInstancePool) { +} + +func (newState *DeleteInstancePool) SyncEffectiveFieldsDuringRead(existingState DeleteInstancePool) { +} + type DeleteInstancePoolResponse struct { } +func (newState *DeleteInstancePoolResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteInstancePoolResponse) { +} + +func (newState *DeleteInstancePoolResponse) SyncEffectiveFieldsDuringRead(existingState DeleteInstancePoolResponse) { +} + type DeletePolicy struct { // The ID of the policy to delete. PolicyId types.String `tfsdk:"policy_id" tf:""` } +func (newState *DeletePolicy) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeletePolicy) { +} + +func (newState *DeletePolicy) SyncEffectiveFieldsDuringRead(existingState DeletePolicy) { +} + type DeletePolicyResponse struct { } +func (newState *DeletePolicyResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeletePolicyResponse) { +} + +func (newState *DeletePolicyResponse) SyncEffectiveFieldsDuringRead(existingState DeletePolicyResponse) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + type DestroyContext struct { ClusterId types.String `tfsdk:"clusterId" tf:""` ContextId types.String `tfsdk:"contextId" tf:""` } +func (newState *DestroyContext) SyncEffectiveFieldsDuringCreateOrUpdate(plan DestroyContext) { +} + +func (newState *DestroyContext) SyncEffectiveFieldsDuringRead(existingState DestroyContext) { +} + type DestroyResponse struct { } +func (newState *DestroyResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DestroyResponse) { +} + +func (newState *DestroyResponse) SyncEffectiveFieldsDuringRead(existingState DestroyResponse) { +} + type DiskSpec struct { // The number of disks launched for each instance: - This feature is only // enabled for supported node types. - Users can choose up to the limit of @@ -1317,12 +1683,24 @@ type DiskSpec struct { DiskType []DiskType `tfsdk:"disk_type" tf:"optional,object"` } +func (newState *DiskSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan DiskSpec) { +} + +func (newState *DiskSpec) SyncEffectiveFieldsDuringRead(existingState DiskSpec) { +} + type DiskType struct { AzureDiskVolumeType types.String `tfsdk:"azure_disk_volume_type" tf:"optional"` EbsVolumeType types.String `tfsdk:"ebs_volume_type" tf:"optional"` } +func (newState *DiskType) SyncEffectiveFieldsDuringCreateOrUpdate(plan DiskType) { +} + +func (newState *DiskType) SyncEffectiveFieldsDuringRead(existingState DiskType) { +} + type DockerBasicAuth struct { // Password of the user Password types.String `tfsdk:"password" tf:"optional"` @@ -1330,12 +1708,24 @@ type DockerBasicAuth struct { Username types.String `tfsdk:"username" tf:"optional"` } +func (newState *DockerBasicAuth) SyncEffectiveFieldsDuringCreateOrUpdate(plan DockerBasicAuth) { +} + +func (newState *DockerBasicAuth) SyncEffectiveFieldsDuringRead(existingState DockerBasicAuth) { +} + type DockerImage struct { BasicAuth []DockerBasicAuth `tfsdk:"basic_auth" tf:"optional,object"` // URL of the docker image. Url types.String `tfsdk:"url" tf:"optional"` } +func (newState *DockerImage) SyncEffectiveFieldsDuringCreateOrUpdate(plan DockerImage) { +} + +func (newState *DockerImage) SyncEffectiveFieldsDuringRead(existingState DockerImage) { +} + type EditCluster 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 @@ -1490,9 +1880,21 @@ type EditCluster struct { WorkloadType []WorkloadType `tfsdk:"workload_type" tf:"optional,object"` } +func (newState *EditCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditCluster) { +} + +func (newState *EditCluster) SyncEffectiveFieldsDuringRead(existingState EditCluster) { +} + type EditClusterResponse struct { } +func (newState *EditClusterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditClusterResponse) { +} + +func (newState *EditClusterResponse) SyncEffectiveFieldsDuringRead(existingState EditClusterResponse) { +} + type EditInstancePool struct { // Additional tags for pool resources. Databricks will tag all pool // resources (e.g., AWS instances and EBS volumes) with these tags in @@ -1527,9 +1929,21 @@ type EditInstancePool struct { NodeTypeId types.String `tfsdk:"node_type_id" tf:""` } +func (newState *EditInstancePool) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditInstancePool) { +} + +func (newState *EditInstancePool) SyncEffectiveFieldsDuringRead(existingState EditInstancePool) { +} + type EditInstancePoolResponse struct { } +func (newState *EditInstancePoolResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditInstancePoolResponse) { +} + +func (newState *EditInstancePoolResponse) SyncEffectiveFieldsDuringRead(existingState EditInstancePoolResponse) { +} + type EditPolicy struct { // Policy definition document expressed in [Databricks Cluster Policy // Definition Language]. @@ -1568,12 +1982,30 @@ type EditPolicy struct { PolicyId types.String `tfsdk:"policy_id" tf:""` } +func (newState *EditPolicy) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditPolicy) { +} + +func (newState *EditPolicy) SyncEffectiveFieldsDuringRead(existingState EditPolicy) { +} + type EditPolicyResponse struct { } +func (newState *EditPolicyResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditPolicyResponse) { +} + +func (newState *EditPolicyResponse) SyncEffectiveFieldsDuringRead(existingState EditPolicyResponse) { +} + type EditResponse struct { } +func (newState *EditResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditResponse) { +} + +func (newState *EditResponse) SyncEffectiveFieldsDuringRead(existingState EditResponse) { +} + type EnforceClusterComplianceRequest struct { // The ID of the cluster you want to enforce policy compliance on. ClusterId types.String `tfsdk:"cluster_id" tf:""` @@ -1582,6 +2014,12 @@ type EnforceClusterComplianceRequest struct { ValidateOnly types.Bool `tfsdk:"validate_only" tf:"optional"` } +func (newState *EnforceClusterComplianceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan EnforceClusterComplianceRequest) { +} + +func (newState *EnforceClusterComplianceRequest) SyncEffectiveFieldsDuringRead(existingState EnforceClusterComplianceRequest) { +} + type EnforceClusterComplianceResponse struct { // A list of changes that have been made to the cluster settings for the // cluster to become compliant with its policy. @@ -1591,6 +2029,12 @@ type EnforceClusterComplianceResponse struct { HasChanges types.Bool `tfsdk:"has_changes" tf:"optional"` } +func (newState *EnforceClusterComplianceResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan EnforceClusterComplianceResponse) { +} + +func (newState *EnforceClusterComplianceResponse) SyncEffectiveFieldsDuringRead(existingState EnforceClusterComplianceResponse) { +} + // The environment entity used to preserve serverless environment side panel and // jobs' environment for non-notebook task. In this minimal environment spec, // only pip dependencies are supported. @@ -1609,6 +2053,12 @@ type Environment struct { Dependencies []types.String `tfsdk:"dependencies" tf:"optional"` } +func (newState *Environment) SyncEffectiveFieldsDuringCreateOrUpdate(plan Environment) { +} + +func (newState *Environment) SyncEffectiveFieldsDuringRead(existingState Environment) { +} + type EventDetails struct { // * For created clusters, the attributes of the cluster. * For edited // clusters, the new attributes of the cluster. @@ -1660,6 +2110,12 @@ type EventDetails struct { User types.String `tfsdk:"user" tf:"optional"` } +func (newState *EventDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan EventDetails) { +} + +func (newState *EventDetails) SyncEffectiveFieldsDuringRead(existingState EventDetails) { +} + type GcpAttributes struct { // This field determines whether the instance pool will contain preemptible // VMs, on-demand VMs, or preemptible VMs with a fallback to on-demand VMs @@ -1694,17 +2150,35 @@ type GcpAttributes struct { ZoneId types.String `tfsdk:"zone_id" tf:"optional"` } +func (newState *GcpAttributes) SyncEffectiveFieldsDuringCreateOrUpdate(plan GcpAttributes) { +} + +func (newState *GcpAttributes) SyncEffectiveFieldsDuringRead(existingState GcpAttributes) { +} + type GcsStorageInfo struct { // GCS destination/URI, e.g. `gs://my-bucket/some-prefix` Destination types.String `tfsdk:"destination" tf:""` } +func (newState *GcsStorageInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan GcsStorageInfo) { +} + +func (newState *GcsStorageInfo) SyncEffectiveFieldsDuringRead(existingState GcsStorageInfo) { +} + // Get cluster policy compliance type GetClusterComplianceRequest struct { // The ID of the cluster to get the compliance status ClusterId types.String `tfsdk:"-"` } +func (newState *GetClusterComplianceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetClusterComplianceRequest) { +} + +func (newState *GetClusterComplianceRequest) SyncEffectiveFieldsDuringRead(existingState GetClusterComplianceRequest) { +} + type GetClusterComplianceResponse 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 @@ -1717,52 +2191,106 @@ type GetClusterComplianceResponse struct { Violations map[string]types.String `tfsdk:"violations" tf:"optional"` } +func (newState *GetClusterComplianceResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetClusterComplianceResponse) { +} + +func (newState *GetClusterComplianceResponse) SyncEffectiveFieldsDuringRead(existingState GetClusterComplianceResponse) { +} + // Get cluster permission levels type GetClusterPermissionLevelsRequest struct { // The cluster for which to get or manage permissions. ClusterId types.String `tfsdk:"-"` } +func (newState *GetClusterPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetClusterPermissionLevelsRequest) { +} + +func (newState *GetClusterPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetClusterPermissionLevelsRequest) { +} + type GetClusterPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []ClusterPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetClusterPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetClusterPermissionLevelsResponse) { +} + +func (newState *GetClusterPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetClusterPermissionLevelsResponse) { +} + // Get cluster permissions type GetClusterPermissionsRequest struct { // The cluster for which to get or manage permissions. ClusterId types.String `tfsdk:"-"` } +func (newState *GetClusterPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetClusterPermissionsRequest) { +} + +func (newState *GetClusterPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetClusterPermissionsRequest) { +} + // Get cluster policy permission levels type GetClusterPolicyPermissionLevelsRequest struct { // The cluster policy for which to get or manage permissions. ClusterPolicyId types.String `tfsdk:"-"` } +func (newState *GetClusterPolicyPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetClusterPolicyPermissionLevelsRequest) { +} + +func (newState *GetClusterPolicyPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetClusterPolicyPermissionLevelsRequest) { +} + type GetClusterPolicyPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []ClusterPolicyPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetClusterPolicyPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetClusterPolicyPermissionLevelsResponse) { +} + +func (newState *GetClusterPolicyPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetClusterPolicyPermissionLevelsResponse) { +} + // Get cluster policy permissions type GetClusterPolicyPermissionsRequest struct { // The cluster policy for which to get or manage permissions. ClusterPolicyId types.String `tfsdk:"-"` } +func (newState *GetClusterPolicyPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetClusterPolicyPermissionsRequest) { +} + +func (newState *GetClusterPolicyPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetClusterPolicyPermissionsRequest) { +} + // Get a cluster policy type GetClusterPolicyRequest struct { // Canonical unique identifier for the Cluster Policy. PolicyId types.String `tfsdk:"-"` } +func (newState *GetClusterPolicyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetClusterPolicyRequest) { +} + +func (newState *GetClusterPolicyRequest) SyncEffectiveFieldsDuringRead(existingState GetClusterPolicyRequest) { +} + // Get cluster info type GetClusterRequest struct { // The cluster about which to retrieve information. ClusterId types.String `tfsdk:"-"` } +func (newState *GetClusterRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetClusterRequest) { +} + +func (newState *GetClusterRequest) SyncEffectiveFieldsDuringRead(existingState GetClusterRequest) { +} + type GetEvents struct { // The ID of the cluster to retrieve events about. ClusterId types.String `tfsdk:"cluster_id" tf:""` @@ -1786,6 +2314,12 @@ type GetEvents struct { StartTime types.Int64 `tfsdk:"start_time" tf:"optional"` } +func (newState *GetEvents) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetEvents) { +} + +func (newState *GetEvents) SyncEffectiveFieldsDuringRead(existingState GetEvents) { +} + type GetEventsResponse struct { // Events []ClusterEvent `tfsdk:"events" tf:"optional"` @@ -1797,12 +2331,24 @@ type GetEventsResponse struct { TotalCount types.Int64 `tfsdk:"total_count" tf:"optional"` } +func (newState *GetEventsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetEventsResponse) { +} + +func (newState *GetEventsResponse) SyncEffectiveFieldsDuringRead(existingState GetEventsResponse) { +} + // Get an init script type GetGlobalInitScriptRequest struct { // The ID of the global init script. ScriptId types.String `tfsdk:"-"` } +func (newState *GetGlobalInitScriptRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetGlobalInitScriptRequest) { +} + +func (newState *GetGlobalInitScriptRequest) SyncEffectiveFieldsDuringRead(existingState GetGlobalInitScriptRequest) { +} + type GetInstancePool struct { // Attributes related to instance pools running on Amazon Web Services. If // not specified at pool creation, a set of default values will be used. @@ -1879,29 +2425,59 @@ type GetInstancePool struct { Status []InstancePoolStatus `tfsdk:"status" tf:"optional,object"` } +func (newState *GetInstancePool) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetInstancePool) { +} + +func (newState *GetInstancePool) SyncEffectiveFieldsDuringRead(existingState GetInstancePool) { +} + // Get instance pool permission levels type GetInstancePoolPermissionLevelsRequest struct { // The instance pool for which to get or manage permissions. InstancePoolId types.String `tfsdk:"-"` } +func (newState *GetInstancePoolPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetInstancePoolPermissionLevelsRequest) { +} + +func (newState *GetInstancePoolPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetInstancePoolPermissionLevelsRequest) { +} + type GetInstancePoolPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []InstancePoolPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetInstancePoolPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetInstancePoolPermissionLevelsResponse) { +} + +func (newState *GetInstancePoolPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetInstancePoolPermissionLevelsResponse) { +} + // Get instance pool permissions type GetInstancePoolPermissionsRequest struct { // The instance pool for which to get or manage permissions. InstancePoolId types.String `tfsdk:"-"` } +func (newState *GetInstancePoolPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetInstancePoolPermissionsRequest) { +} + +func (newState *GetInstancePoolPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetInstancePoolPermissionsRequest) { +} + // Get instance pool information type GetInstancePoolRequest struct { // The canonical unique identifier for the instance pool. InstancePoolId types.String `tfsdk:"-"` } +func (newState *GetInstancePoolRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetInstancePoolRequest) { +} + +func (newState *GetInstancePoolRequest) SyncEffectiveFieldsDuringRead(existingState GetInstancePoolRequest) { +} + // Get policy family information type GetPolicyFamilyRequest struct { // The family ID about which to retrieve information. @@ -1911,11 +2487,23 @@ type GetPolicyFamilyRequest struct { Version types.Int64 `tfsdk:"-"` } +func (newState *GetPolicyFamilyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPolicyFamilyRequest) { +} + +func (newState *GetPolicyFamilyRequest) SyncEffectiveFieldsDuringRead(existingState GetPolicyFamilyRequest) { +} + type GetSparkVersionsResponse struct { // All the available Spark versions. Versions []SparkVersion `tfsdk:"versions" tf:"optional"` } +func (newState *GetSparkVersionsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetSparkVersionsResponse) { +} + +func (newState *GetSparkVersionsResponse) SyncEffectiveFieldsDuringRead(existingState GetSparkVersionsResponse) { +} + type GlobalInitScriptCreateRequest struct { // Specifies whether the script is enabled. The script runs only if enabled. Enabled types.Bool `tfsdk:"enabled" tf:"optional"` @@ -1937,6 +2525,12 @@ type GlobalInitScriptCreateRequest struct { Script types.String `tfsdk:"script" tf:""` } +func (newState *GlobalInitScriptCreateRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GlobalInitScriptCreateRequest) { +} + +func (newState *GlobalInitScriptCreateRequest) SyncEffectiveFieldsDuringRead(existingState GlobalInitScriptCreateRequest) { +} + type GlobalInitScriptDetails struct { // Time when the script was created, represented as a Unix timestamp in // milliseconds. @@ -1959,6 +2553,12 @@ type GlobalInitScriptDetails struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *GlobalInitScriptDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan GlobalInitScriptDetails) { +} + +func (newState *GlobalInitScriptDetails) SyncEffectiveFieldsDuringRead(existingState GlobalInitScriptDetails) { +} + type GlobalInitScriptDetailsWithContent struct { // Time when the script was created, represented as a Unix timestamp in // milliseconds. @@ -1983,6 +2583,12 @@ type GlobalInitScriptDetailsWithContent struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *GlobalInitScriptDetailsWithContent) SyncEffectiveFieldsDuringCreateOrUpdate(plan GlobalInitScriptDetailsWithContent) { +} + +func (newState *GlobalInitScriptDetailsWithContent) SyncEffectiveFieldsDuringRead(existingState GlobalInitScriptDetailsWithContent) { +} + type GlobalInitScriptUpdateRequest struct { // Specifies whether the script is enabled. The script runs only if enabled. Enabled types.Bool `tfsdk:"enabled" tf:"optional"` @@ -2007,6 +2613,12 @@ type GlobalInitScriptUpdateRequest struct { ScriptId types.String `tfsdk:"-"` } +func (newState *GlobalInitScriptUpdateRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GlobalInitScriptUpdateRequest) { +} + +func (newState *GlobalInitScriptUpdateRequest) SyncEffectiveFieldsDuringRead(existingState GlobalInitScriptUpdateRequest) { +} + type InitScriptEventDetails struct { // The cluster scoped init scripts associated with this cluster event Cluster []InitScriptInfoAndExecutionDetails `tfsdk:"cluster" tf:"optional"` @@ -2016,6 +2628,12 @@ type InitScriptEventDetails struct { ReportedForNode types.String `tfsdk:"reported_for_node" tf:"optional"` } +func (newState *InitScriptEventDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan InitScriptEventDetails) { +} + +func (newState *InitScriptEventDetails) SyncEffectiveFieldsDuringRead(existingState InitScriptEventDetails) { +} + type InitScriptExecutionDetails struct { // Addition details regarding errors. ErrorMessage types.String `tfsdk:"error_message" tf:"optional"` @@ -2025,6 +2643,12 @@ type InitScriptExecutionDetails struct { Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *InitScriptExecutionDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan InitScriptExecutionDetails) { +} + +func (newState *InitScriptExecutionDetails) SyncEffectiveFieldsDuringRead(existingState InitScriptExecutionDetails) { +} + type InitScriptInfo struct { // destination needs to be provided. e.g. `{ "abfss" : { "destination" : // "abfss://@.dfs.core.windows.net/" @@ -2053,6 +2677,12 @@ type InitScriptInfo struct { Workspace []WorkspaceStorageInfo `tfsdk:"workspace" tf:"optional,object"` } +func (newState *InitScriptInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan InitScriptInfo) { +} + +func (newState *InitScriptInfo) SyncEffectiveFieldsDuringRead(existingState InitScriptInfo) { +} + type InitScriptInfoAndExecutionDetails struct { // Details about the script ExecutionDetails []InitScriptExecutionDetails `tfsdk:"execution_details" tf:"optional,object"` @@ -2060,6 +2690,12 @@ type InitScriptInfoAndExecutionDetails struct { Script []InitScriptInfo `tfsdk:"script" tf:"optional,object"` } +func (newState *InitScriptInfoAndExecutionDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan InitScriptInfoAndExecutionDetails) { +} + +func (newState *InitScriptInfoAndExecutionDetails) SyncEffectiveFieldsDuringRead(existingState InitScriptInfoAndExecutionDetails) { +} + type InstallLibraries struct { // Unique identifier for the cluster on which to install these libraries. ClusterId types.String `tfsdk:"cluster_id" tf:""` @@ -2067,9 +2703,21 @@ type InstallLibraries struct { Libraries []Library `tfsdk:"libraries" tf:""` } +func (newState *InstallLibraries) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstallLibraries) { +} + +func (newState *InstallLibraries) SyncEffectiveFieldsDuringRead(existingState InstallLibraries) { +} + type InstallLibrariesResponse struct { } +func (newState *InstallLibrariesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstallLibrariesResponse) { +} + +func (newState *InstallLibrariesResponse) SyncEffectiveFieldsDuringRead(existingState InstallLibrariesResponse) { +} + type InstancePoolAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -2081,6 +2729,12 @@ type InstancePoolAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *InstancePoolAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolAccessControlRequest) { +} + +func (newState *InstancePoolAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState InstancePoolAccessControlRequest) { +} + type InstancePoolAccessControlResponse struct { // All permissions. AllPermissions []InstancePoolPermission `tfsdk:"all_permissions" tf:"optional"` @@ -2094,6 +2748,12 @@ type InstancePoolAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *InstancePoolAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolAccessControlResponse) { +} + +func (newState *InstancePoolAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState InstancePoolAccessControlResponse) { +} + type InstancePoolAndStats struct { // Attributes related to instance pools running on Amazon Web Services. If // not specified at pool creation, a set of default values will be used. @@ -2170,6 +2830,12 @@ type InstancePoolAndStats struct { Status []InstancePoolStatus `tfsdk:"status" tf:"optional,object"` } +func (newState *InstancePoolAndStats) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolAndStats) { +} + +func (newState *InstancePoolAndStats) SyncEffectiveFieldsDuringRead(existingState InstancePoolAndStats) { +} + type InstancePoolAwsAttributes struct { // Availability type used for the spot nodes. // @@ -2202,6 +2868,12 @@ type InstancePoolAwsAttributes struct { ZoneId types.String `tfsdk:"zone_id" tf:"optional"` } +func (newState *InstancePoolAwsAttributes) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolAwsAttributes) { +} + +func (newState *InstancePoolAwsAttributes) SyncEffectiveFieldsDuringRead(existingState InstancePoolAwsAttributes) { +} + type InstancePoolAzureAttributes struct { // Shows the Availability type used for the spot nodes. // @@ -2213,6 +2885,12 @@ type InstancePoolAzureAttributes struct { SpotBidMaxPrice types.Float64 `tfsdk:"spot_bid_max_price" tf:"optional"` } +func (newState *InstancePoolAzureAttributes) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolAzureAttributes) { +} + +func (newState *InstancePoolAzureAttributes) SyncEffectiveFieldsDuringRead(existingState InstancePoolAzureAttributes) { +} + type InstancePoolGcpAttributes struct { // This field determines whether the instance pool will contain preemptible // VMs, on-demand VMs, or preemptible VMs with a fallback to on-demand VMs @@ -2244,6 +2922,12 @@ type InstancePoolGcpAttributes struct { ZoneId types.String `tfsdk:"zone_id" tf:"optional"` } +func (newState *InstancePoolGcpAttributes) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolGcpAttributes) { +} + +func (newState *InstancePoolGcpAttributes) SyncEffectiveFieldsDuringRead(existingState InstancePoolGcpAttributes) { +} + type InstancePoolPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -2252,6 +2936,12 @@ type InstancePoolPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *InstancePoolPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolPermission) { +} + +func (newState *InstancePoolPermission) SyncEffectiveFieldsDuringRead(existingState InstancePoolPermission) { +} + type InstancePoolPermissions struct { AccessControlList []InstancePoolAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -2260,18 +2950,36 @@ type InstancePoolPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *InstancePoolPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolPermissions) { +} + +func (newState *InstancePoolPermissions) SyncEffectiveFieldsDuringRead(existingState InstancePoolPermissions) { +} + type InstancePoolPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *InstancePoolPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolPermissionsDescription) { +} + +func (newState *InstancePoolPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState InstancePoolPermissionsDescription) { +} + type InstancePoolPermissionsRequest struct { AccessControlList []InstancePoolAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The instance pool for which to get or manage permissions. InstancePoolId types.String `tfsdk:"-"` } +func (newState *InstancePoolPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolPermissionsRequest) { +} + +func (newState *InstancePoolPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState InstancePoolPermissionsRequest) { +} + type InstancePoolStats struct { // Number of active instances in the pool that are NOT part of a cluster. IdleCount types.Int64 `tfsdk:"idle_count" tf:"optional"` @@ -2283,6 +2991,12 @@ type InstancePoolStats struct { UsedCount types.Int64 `tfsdk:"used_count" tf:"optional"` } +func (newState *InstancePoolStats) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolStats) { +} + +func (newState *InstancePoolStats) SyncEffectiveFieldsDuringRead(existingState InstancePoolStats) { +} + type InstancePoolStatus struct { // List of error messages for the failed pending instances. The // pending_instance_errors follows FIFO with maximum length of the min_idle @@ -2291,6 +3005,12 @@ type InstancePoolStatus struct { PendingInstanceErrors []PendingInstanceError `tfsdk:"pending_instance_errors" tf:"optional"` } +func (newState *InstancePoolStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstancePoolStatus) { +} + +func (newState *InstancePoolStatus) SyncEffectiveFieldsDuringRead(existingState InstancePoolStatus) { +} + type InstanceProfile struct { // The AWS IAM role ARN of the role associated with the instance profile. // This field is required if your role name and instance profile name do not @@ -2312,6 +3032,12 @@ type InstanceProfile struct { IsMetaInstanceProfile types.Bool `tfsdk:"is_meta_instance_profile" tf:"optional"` } +func (newState *InstanceProfile) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstanceProfile) { +} + +func (newState *InstanceProfile) SyncEffectiveFieldsDuringRead(existingState InstanceProfile) { +} + type Library struct { // Specification of a CRAN library to be installed as part of the library Cran []RCranLibrary `tfsdk:"cran" tf:"optional,object"` @@ -2348,6 +3074,12 @@ type Library struct { Whl types.String `tfsdk:"whl" tf:"optional"` } +func (newState *Library) SyncEffectiveFieldsDuringCreateOrUpdate(plan Library) { +} + +func (newState *Library) SyncEffectiveFieldsDuringRead(existingState Library) { +} + // The status of the library on a specific cluster. type LibraryFullStatus struct { // Whether the library was set to be installed on all clusters via the @@ -2362,11 +3094,23 @@ type LibraryFullStatus struct { Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *LibraryFullStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan LibraryFullStatus) { +} + +func (newState *LibraryFullStatus) SyncEffectiveFieldsDuringRead(existingState LibraryFullStatus) { +} + type ListAllClusterLibraryStatusesResponse struct { // A list of cluster statuses. Statuses []ClusterLibraryStatuses `tfsdk:"statuses" tf:"optional"` } +func (newState *ListAllClusterLibraryStatusesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAllClusterLibraryStatusesResponse) { +} + +func (newState *ListAllClusterLibraryStatusesResponse) SyncEffectiveFieldsDuringRead(existingState ListAllClusterLibraryStatusesResponse) { +} + type ListAvailableZonesResponse struct { // The availability zone if no `zone_id` is provided in the cluster creation // request. @@ -2375,6 +3119,12 @@ type ListAvailableZonesResponse struct { Zones []types.String `tfsdk:"zones" tf:"optional"` } +func (newState *ListAvailableZonesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAvailableZonesResponse) { +} + +func (newState *ListAvailableZonesResponse) SyncEffectiveFieldsDuringRead(existingState ListAvailableZonesResponse) { +} + // List cluster policy compliance type ListClusterCompliancesRequest struct { // Use this field to specify the maximum number of results to be returned by @@ -2388,6 +3138,12 @@ type ListClusterCompliancesRequest struct { PolicyId types.String `tfsdk:"-"` } +func (newState *ListClusterCompliancesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListClusterCompliancesRequest) { +} + +func (newState *ListClusterCompliancesRequest) SyncEffectiveFieldsDuringRead(existingState ListClusterCompliancesRequest) { +} + type ListClusterCompliancesResponse struct { // A list of clusters and their policy compliance statuses. Clusters []ClusterCompliance `tfsdk:"clusters" tf:"optional"` @@ -2400,6 +3156,12 @@ type ListClusterCompliancesResponse struct { PrevPageToken types.String `tfsdk:"prev_page_token" tf:"optional"` } +func (newState *ListClusterCompliancesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListClusterCompliancesResponse) { +} + +func (newState *ListClusterCompliancesResponse) SyncEffectiveFieldsDuringRead(existingState ListClusterCompliancesResponse) { +} + // List cluster policies type ListClusterPoliciesRequest struct { // The cluster policy attribute to sort by. * `POLICY_CREATION_TIME` - Sort @@ -2411,6 +3173,12 @@ type ListClusterPoliciesRequest struct { SortOrder types.String `tfsdk:"-"` } +func (newState *ListClusterPoliciesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListClusterPoliciesRequest) { +} + +func (newState *ListClusterPoliciesRequest) SyncEffectiveFieldsDuringRead(existingState ListClusterPoliciesRequest) { +} + type ListClustersFilterBy struct { // The source of cluster creation. ClusterSources []types.String `tfsdk:"cluster_sources" tf:"optional"` @@ -2422,6 +3190,12 @@ type ListClustersFilterBy struct { PolicyId types.String `tfsdk:"policy_id" tf:"optional"` } +func (newState *ListClustersFilterBy) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListClustersFilterBy) { +} + +func (newState *ListClustersFilterBy) SyncEffectiveFieldsDuringRead(existingState ListClustersFilterBy) { +} + // List clusters type ListClustersRequest struct { // Filters to apply to the list of clusters. @@ -2437,6 +3211,12 @@ type ListClustersRequest struct { SortBy []ListClustersSortBy `tfsdk:"-"` } +func (newState *ListClustersRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListClustersRequest) { +} + +func (newState *ListClustersRequest) SyncEffectiveFieldsDuringRead(existingState ListClustersRequest) { +} + type ListClustersResponse struct { // Clusters []ClusterDetails `tfsdk:"clusters" tf:"optional"` @@ -2449,6 +3229,12 @@ type ListClustersResponse struct { PrevPageToken types.String `tfsdk:"prev_page_token" tf:"optional"` } +func (newState *ListClustersResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListClustersResponse) { +} + +func (newState *ListClustersResponse) SyncEffectiveFieldsDuringRead(existingState ListClustersResponse) { +} + type ListClustersSortBy struct { // The direction to sort by. Direction types.String `tfsdk:"direction" tf:"optional"` @@ -2458,29 +3244,65 @@ type ListClustersSortBy struct { Field types.String `tfsdk:"field" tf:"optional"` } +func (newState *ListClustersSortBy) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListClustersSortBy) { +} + +func (newState *ListClustersSortBy) SyncEffectiveFieldsDuringRead(existingState ListClustersSortBy) { +} + type ListGlobalInitScriptsResponse struct { Scripts []GlobalInitScriptDetails `tfsdk:"scripts" tf:"optional"` } +func (newState *ListGlobalInitScriptsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListGlobalInitScriptsResponse) { +} + +func (newState *ListGlobalInitScriptsResponse) SyncEffectiveFieldsDuringRead(existingState ListGlobalInitScriptsResponse) { +} + type ListInstancePools struct { InstancePools []InstancePoolAndStats `tfsdk:"instance_pools" tf:"optional"` } +func (newState *ListInstancePools) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListInstancePools) { +} + +func (newState *ListInstancePools) SyncEffectiveFieldsDuringRead(existingState ListInstancePools) { +} + type ListInstanceProfilesResponse struct { // A list of instance profiles that the user can access. InstanceProfiles []InstanceProfile `tfsdk:"instance_profiles" tf:"optional"` } +func (newState *ListInstanceProfilesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListInstanceProfilesResponse) { +} + +func (newState *ListInstanceProfilesResponse) SyncEffectiveFieldsDuringRead(existingState ListInstanceProfilesResponse) { +} + type ListNodeTypesResponse struct { // The list of available Spark node types. NodeTypes []NodeType `tfsdk:"node_types" tf:"optional"` } +func (newState *ListNodeTypesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListNodeTypesResponse) { +} + +func (newState *ListNodeTypesResponse) SyncEffectiveFieldsDuringRead(existingState ListNodeTypesResponse) { +} + type ListPoliciesResponse struct { // List of policies. Policies []Policy `tfsdk:"policies" tf:"optional"` } +func (newState *ListPoliciesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListPoliciesResponse) { +} + +func (newState *ListPoliciesResponse) SyncEffectiveFieldsDuringRead(existingState ListPoliciesResponse) { +} + // List policy families type ListPolicyFamiliesRequest struct { // Maximum number of policy families to return. @@ -2489,6 +3311,12 @@ type ListPolicyFamiliesRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListPolicyFamiliesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListPolicyFamiliesRequest) { +} + +func (newState *ListPolicyFamiliesRequest) SyncEffectiveFieldsDuringRead(existingState ListPolicyFamiliesRequest) { +} + type ListPolicyFamiliesResponse struct { // A token that can be used to get the next page of results. If not present, // there are no more results to show. @@ -2497,11 +3325,23 @@ type ListPolicyFamiliesResponse struct { PolicyFamilies []PolicyFamily `tfsdk:"policy_families" tf:"optional"` } +func (newState *ListPolicyFamiliesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListPolicyFamiliesResponse) { +} + +func (newState *ListPolicyFamiliesResponse) SyncEffectiveFieldsDuringRead(existingState ListPolicyFamiliesResponse) { +} + type LocalFileInfo struct { // local file destination, e.g. `file:/my/local/file.sh` Destination types.String `tfsdk:"destination" tf:""` } +func (newState *LocalFileInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan LocalFileInfo) { +} + +func (newState *LocalFileInfo) SyncEffectiveFieldsDuringRead(existingState LocalFileInfo) { +} + type LogAnalyticsInfo struct { // LogAnalyticsPrimaryKey types.String `tfsdk:"log_analytics_primary_key" tf:"optional"` @@ -2509,6 +3349,12 @@ type LogAnalyticsInfo struct { LogAnalyticsWorkspaceId types.String `tfsdk:"log_analytics_workspace_id" tf:"optional"` } +func (newState *LogAnalyticsInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogAnalyticsInfo) { +} + +func (newState *LogAnalyticsInfo) SyncEffectiveFieldsDuringRead(existingState LogAnalyticsInfo) { +} + type LogSyncStatus struct { // The timestamp of last attempt. If the last attempt fails, // `last_exception` will contain the exception in the last attempt. @@ -2518,6 +3364,12 @@ type LogSyncStatus struct { LastException types.String `tfsdk:"last_exception" tf:"optional"` } +func (newState *LogSyncStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogSyncStatus) { +} + +func (newState *LogSyncStatus) SyncEffectiveFieldsDuringRead(existingState LogSyncStatus) { +} + type MavenLibrary struct { // Gradle-style maven coordinates. For example: "org.jsoup:jsoup:1.7.2". Coordinates types.String `tfsdk:"coordinates" tf:""` @@ -2532,6 +3384,12 @@ type MavenLibrary struct { Repo types.String `tfsdk:"repo" tf:"optional"` } +func (newState *MavenLibrary) SyncEffectiveFieldsDuringCreateOrUpdate(plan MavenLibrary) { +} + +func (newState *MavenLibrary) SyncEffectiveFieldsDuringRead(existingState MavenLibrary) { +} + type NodeInstanceType struct { InstanceTypeId types.String `tfsdk:"instance_type_id" tf:"optional"` @@ -2544,6 +3402,12 @@ type NodeInstanceType struct { LocalNvmeDisks types.Int64 `tfsdk:"local_nvme_disks" tf:"optional"` } +func (newState *NodeInstanceType) SyncEffectiveFieldsDuringCreateOrUpdate(plan NodeInstanceType) { +} + +func (newState *NodeInstanceType) SyncEffectiveFieldsDuringRead(existingState NodeInstanceType) { +} + type NodeType struct { Category types.String `tfsdk:"category" tf:"optional"` // A string description associated with this node type, e.g., "r3.xlarge". @@ -2594,28 +3458,64 @@ type NodeType struct { SupportsElasticDisk types.Bool `tfsdk:"supports_elastic_disk" tf:"optional"` } +func (newState *NodeType) SyncEffectiveFieldsDuringCreateOrUpdate(plan NodeType) { +} + +func (newState *NodeType) SyncEffectiveFieldsDuringRead(existingState NodeType) { +} + type PendingInstanceError struct { InstanceId types.String `tfsdk:"instance_id" tf:"optional"` Message types.String `tfsdk:"message" tf:"optional"` } +func (newState *PendingInstanceError) SyncEffectiveFieldsDuringCreateOrUpdate(plan PendingInstanceError) { +} + +func (newState *PendingInstanceError) SyncEffectiveFieldsDuringRead(existingState PendingInstanceError) { +} + type PermanentDeleteCluster struct { // The cluster to be deleted. ClusterId types.String `tfsdk:"cluster_id" tf:""` } +func (newState *PermanentDeleteCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan PermanentDeleteCluster) { +} + +func (newState *PermanentDeleteCluster) SyncEffectiveFieldsDuringRead(existingState PermanentDeleteCluster) { +} + type PermanentDeleteClusterResponse struct { } +func (newState *PermanentDeleteClusterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PermanentDeleteClusterResponse) { +} + +func (newState *PermanentDeleteClusterResponse) SyncEffectiveFieldsDuringRead(existingState PermanentDeleteClusterResponse) { +} + type PinCluster struct { // ClusterId types.String `tfsdk:"cluster_id" tf:""` } +func (newState *PinCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan PinCluster) { +} + +func (newState *PinCluster) SyncEffectiveFieldsDuringRead(existingState PinCluster) { +} + type PinClusterResponse struct { } +func (newState *PinClusterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PinClusterResponse) { +} + +func (newState *PinClusterResponse) SyncEffectiveFieldsDuringRead(existingState PinClusterResponse) { +} + // Describes a Cluster Policy entity. type Policy struct { // Creation time. The timestamp (in millisecond) when this Cluster Policy @@ -2665,6 +3565,12 @@ type Policy struct { PolicyId types.String `tfsdk:"policy_id" tf:"optional"` } +func (newState *Policy) SyncEffectiveFieldsDuringCreateOrUpdate(plan Policy) { +} + +func (newState *Policy) SyncEffectiveFieldsDuringRead(existingState Policy) { +} + type PolicyFamily struct { // Policy definition document expressed in [Databricks Cluster Policy // Definition Language]. @@ -2679,6 +3585,12 @@ type PolicyFamily struct { PolicyFamilyId types.String `tfsdk:"policy_family_id" tf:"optional"` } +func (newState *PolicyFamily) SyncEffectiveFieldsDuringCreateOrUpdate(plan PolicyFamily) { +} + +func (newState *PolicyFamily) SyncEffectiveFieldsDuringRead(existingState PolicyFamily) { +} + type PythonPyPiLibrary struct { // The name of the pypi package to install. An optional exact version // specification is also supported. Examples: "simplejson" and @@ -2689,6 +3601,12 @@ type PythonPyPiLibrary struct { Repo types.String `tfsdk:"repo" tf:"optional"` } +func (newState *PythonPyPiLibrary) SyncEffectiveFieldsDuringCreateOrUpdate(plan PythonPyPiLibrary) { +} + +func (newState *PythonPyPiLibrary) SyncEffectiveFieldsDuringRead(existingState PythonPyPiLibrary) { +} + type RCranLibrary struct { // The name of the CRAN package to install. Package types.String `tfsdk:"package" tf:""` @@ -2697,14 +3615,32 @@ type RCranLibrary struct { Repo types.String `tfsdk:"repo" tf:"optional"` } +func (newState *RCranLibrary) SyncEffectiveFieldsDuringCreateOrUpdate(plan RCranLibrary) { +} + +func (newState *RCranLibrary) SyncEffectiveFieldsDuringRead(existingState RCranLibrary) { +} + type RemoveInstanceProfile struct { // The ARN of the instance profile to remove. This field is required. InstanceProfileArn types.String `tfsdk:"instance_profile_arn" tf:""` } +func (newState *RemoveInstanceProfile) SyncEffectiveFieldsDuringCreateOrUpdate(plan RemoveInstanceProfile) { +} + +func (newState *RemoveInstanceProfile) SyncEffectiveFieldsDuringRead(existingState RemoveInstanceProfile) { +} + type RemoveResponse struct { } +func (newState *RemoveResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RemoveResponse) { +} + +func (newState *RemoveResponse) SyncEffectiveFieldsDuringRead(existingState RemoveResponse) { +} + type ResizeCluster struct { // Parameters needed in order to automatically scale clusters up and down // based on load. Note: autoscaling works best with DB runtime versions 3.0 @@ -2725,9 +3661,21 @@ type ResizeCluster struct { NumWorkers types.Int64 `tfsdk:"num_workers" tf:"optional"` } +func (newState *ResizeCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResizeCluster) { +} + +func (newState *ResizeCluster) SyncEffectiveFieldsDuringRead(existingState ResizeCluster) { +} + type ResizeClusterResponse struct { } +func (newState *ResizeClusterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResizeClusterResponse) { +} + +func (newState *ResizeClusterResponse) SyncEffectiveFieldsDuringRead(existingState ResizeClusterResponse) { +} + type RestartCluster struct { // The cluster to be started. ClusterId types.String `tfsdk:"cluster_id" tf:""` @@ -2735,9 +3683,21 @@ type RestartCluster struct { RestartUser types.String `tfsdk:"restart_user" tf:"optional"` } +func (newState *RestartCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestartCluster) { +} + +func (newState *RestartCluster) SyncEffectiveFieldsDuringRead(existingState RestartCluster) { +} + type RestartClusterResponse struct { } +func (newState *RestartClusterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestartClusterResponse) { +} + +func (newState *RestartClusterResponse) SyncEffectiveFieldsDuringRead(existingState RestartClusterResponse) { +} + type Results struct { // The cause of the error Cause types.String `tfsdk:"cause" tf:"optional"` @@ -2762,6 +3722,12 @@ type Results struct { Truncated types.Bool `tfsdk:"truncated" tf:"optional"` } +func (newState *Results) SyncEffectiveFieldsDuringCreateOrUpdate(plan Results) { +} + +func (newState *Results) SyncEffectiveFieldsDuringRead(existingState Results) { +} + type S3StorageInfo struct { // (Optional) Set canned access control list for the logs, e.g. // `bucket-owner-full-control`. If `canned_cal` is set, please make sure the @@ -2795,6 +3761,12 @@ type S3StorageInfo struct { Region types.String `tfsdk:"region" tf:"optional"` } +func (newState *S3StorageInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan S3StorageInfo) { +} + +func (newState *S3StorageInfo) SyncEffectiveFieldsDuringRead(existingState S3StorageInfo) { +} + type SparkNode struct { // The private IP address of the host instance. HostPrivateIp types.String `tfsdk:"host_private_ip" tf:"optional"` @@ -2823,11 +3795,23 @@ type SparkNode struct { StartTimestamp types.Int64 `tfsdk:"start_timestamp" tf:"optional"` } +func (newState *SparkNode) SyncEffectiveFieldsDuringCreateOrUpdate(plan SparkNode) { +} + +func (newState *SparkNode) SyncEffectiveFieldsDuringRead(existingState SparkNode) { +} + type SparkNodeAwsAttributes struct { // Whether this node is on an Amazon spot instance. IsSpot types.Bool `tfsdk:"is_spot" tf:"optional"` } +func (newState *SparkNodeAwsAttributes) SyncEffectiveFieldsDuringCreateOrUpdate(plan SparkNodeAwsAttributes) { +} + +func (newState *SparkNodeAwsAttributes) SyncEffectiveFieldsDuringRead(existingState SparkNodeAwsAttributes) { +} + 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. @@ -2839,14 +3823,32 @@ type SparkVersion struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *SparkVersion) SyncEffectiveFieldsDuringCreateOrUpdate(plan SparkVersion) { +} + +func (newState *SparkVersion) SyncEffectiveFieldsDuringRead(existingState SparkVersion) { +} + type StartCluster struct { // The cluster to be started. ClusterId types.String `tfsdk:"cluster_id" tf:""` } +func (newState *StartCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan StartCluster) { +} + +func (newState *StartCluster) SyncEffectiveFieldsDuringRead(existingState StartCluster) { +} + type StartClusterResponse struct { } +func (newState *StartClusterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan StartClusterResponse) { +} + +func (newState *StartClusterResponse) SyncEffectiveFieldsDuringRead(existingState StartClusterResponse) { +} + type TerminationReason struct { // status code indicating why the cluster was terminated Code types.String `tfsdk:"code" tf:"optional"` @@ -2857,6 +3859,12 @@ type TerminationReason struct { Type types.String `tfsdk:"type" tf:"optional"` } +func (newState *TerminationReason) SyncEffectiveFieldsDuringCreateOrUpdate(plan TerminationReason) { +} + +func (newState *TerminationReason) SyncEffectiveFieldsDuringRead(existingState TerminationReason) { +} + type UninstallLibraries struct { // Unique identifier for the cluster on which to uninstall these libraries. ClusterId types.String `tfsdk:"cluster_id" tf:""` @@ -2864,17 +3872,41 @@ type UninstallLibraries struct { Libraries []Library `tfsdk:"libraries" tf:""` } +func (newState *UninstallLibraries) SyncEffectiveFieldsDuringCreateOrUpdate(plan UninstallLibraries) { +} + +func (newState *UninstallLibraries) SyncEffectiveFieldsDuringRead(existingState UninstallLibraries) { +} + type UninstallLibrariesResponse struct { } +func (newState *UninstallLibrariesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UninstallLibrariesResponse) { +} + +func (newState *UninstallLibrariesResponse) SyncEffectiveFieldsDuringRead(existingState UninstallLibrariesResponse) { +} + type UnpinCluster struct { // ClusterId types.String `tfsdk:"cluster_id" tf:""` } +func (newState *UnpinCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan UnpinCluster) { +} + +func (newState *UnpinCluster) SyncEffectiveFieldsDuringRead(existingState UnpinCluster) { +} + type UnpinClusterResponse struct { } +func (newState *UnpinClusterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UnpinClusterResponse) { +} + +func (newState *UnpinClusterResponse) SyncEffectiveFieldsDuringRead(existingState UnpinClusterResponse) { +} + type UpdateCluster struct { // The cluster to be updated. Cluster []UpdateClusterResource `tfsdk:"cluster" tf:"optional,object"` @@ -2888,6 +3920,12 @@ type UpdateCluster struct { UpdateMask types.String `tfsdk:"update_mask" tf:""` } +func (newState *UpdateCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateCluster) { +} + +func (newState *UpdateCluster) SyncEffectiveFieldsDuringRead(existingState UpdateCluster) { +} + type UpdateClusterResource struct { // Parameters needed in order to automatically scale clusters up and down // based on load. Note: autoscaling works best with DB runtime versions 3.0 @@ -3036,24 +4074,60 @@ type UpdateClusterResource struct { WorkloadType []WorkloadType `tfsdk:"workload_type" tf:"optional,object"` } +func (newState *UpdateClusterResource) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateClusterResource) { +} + +func (newState *UpdateClusterResource) SyncEffectiveFieldsDuringRead(existingState UpdateClusterResource) { +} + type UpdateClusterResponse struct { } +func (newState *UpdateClusterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateClusterResponse) { +} + +func (newState *UpdateClusterResponse) SyncEffectiveFieldsDuringRead(existingState UpdateClusterResponse) { +} + type UpdateResponse struct { } +func (newState *UpdateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateResponse) { +} + +func (newState *UpdateResponse) SyncEffectiveFieldsDuringRead(existingState UpdateResponse) { +} + type VolumesStorageInfo struct { // Unity Catalog Volumes file destination, e.g. `/Volumes/my-init.sh` Destination types.String `tfsdk:"destination" tf:""` } +func (newState *VolumesStorageInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan VolumesStorageInfo) { +} + +func (newState *VolumesStorageInfo) SyncEffectiveFieldsDuringRead(existingState VolumesStorageInfo) { +} + type WorkloadType struct { // defined what type of clients can use the cluster. E.g. Notebooks, Jobs Clients []ClientsTypes `tfsdk:"clients" tf:"object"` } +func (newState *WorkloadType) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkloadType) { +} + +func (newState *WorkloadType) SyncEffectiveFieldsDuringRead(existingState WorkloadType) { +} + type WorkspaceStorageInfo struct { // workspace files destination, e.g. // `/Users/user1@databricks.com/my-init.sh` Destination types.String `tfsdk:"destination" tf:""` } + +func (newState *WorkspaceStorageInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkspaceStorageInfo) { +} + +func (newState *WorkspaceStorageInfo) SyncEffectiveFieldsDuringRead(existingState WorkspaceStorageInfo) { +} diff --git a/internal/service/dashboards_tf/model.go b/internal/service/dashboards_tf/model.go index d0035a99d3..85023fe5e2 100755 --- a/internal/service/dashboards_tf/model.go +++ b/internal/service/dashboards_tf/model.go @@ -21,7 +21,8 @@ type CreateDashboardRequest struct { // The workspace path of the folder containing the dashboard. Includes // leading slash and no trailing slash. This field is excluded in List // Dashboards responses. - ParentPath types.String `tfsdk:"parent_path" tf:"optional"` + ParentPath types.String `tfsdk:"parent_path" tf:"optional"` + EffectiveParentPath types.String `tfsdk:"effective_parent_path" tf:"computed,optional"` // The contents of the dashboard in serialized string form. This field is // excluded in List Dashboards responses. Use the [get dashboard API] to // retrieve an example response, which includes the `serialized_dashboard` @@ -34,28 +35,69 @@ type CreateDashboardRequest struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *CreateDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateDashboardRequest) { + newState.EffectiveParentPath = newState.ParentPath + newState.ParentPath = plan.ParentPath +} + +func (newState *CreateDashboardRequest) SyncEffectiveFieldsDuringRead(existingState CreateDashboardRequest) { + if existingState.EffectiveParentPath.ValueString() == newState.ParentPath.ValueString() { + newState.ParentPath = existingState.ParentPath + } +} + type CreateScheduleRequest struct { // The cron expression describing the frequency of the periodic refresh for // this schedule. CronSchedule []CronSchedule `tfsdk:"cron_schedule" tf:"object"` // UUID identifying the dashboard to which the schedule belongs. - DashboardId types.String `tfsdk:"-"` + DashboardId types.String `tfsdk:"-"` + EffectiveDashboardId types.String `tfsdk:"-"` // The display name for schedule. DisplayName types.String `tfsdk:"display_name" tf:"optional"` // The status indicates whether this schedule is paused or not. PauseStatus types.String `tfsdk:"pause_status" tf:"optional"` } +func (newState *CreateScheduleRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateScheduleRequest) { + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId +} + +func (newState *CreateScheduleRequest) SyncEffectiveFieldsDuringRead(existingState CreateScheduleRequest) { + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } +} + type CreateSubscriptionRequest struct { // UUID identifying the dashboard to which the subscription belongs. - DashboardId types.String `tfsdk:"-"` + DashboardId types.String `tfsdk:"-"` + EffectiveDashboardId types.String `tfsdk:"-"` // UUID identifying the schedule to which the subscription belongs. - ScheduleId types.String `tfsdk:"-"` + ScheduleId types.String `tfsdk:"-"` + EffectiveScheduleId types.String `tfsdk:"-"` // Subscriber details for users and destinations to be added as subscribers // to the schedule. Subscriber []Subscriber `tfsdk:"subscriber" tf:"object"` } +func (newState *CreateSubscriptionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateSubscriptionRequest) { + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectiveScheduleId = newState.ScheduleId + newState.ScheduleId = plan.ScheduleId +} + +func (newState *CreateSubscriptionRequest) SyncEffectiveFieldsDuringRead(existingState CreateSubscriptionRequest) { + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectiveScheduleId.ValueString() == newState.ScheduleId.ValueString() { + newState.ScheduleId = existingState.ScheduleId + } +} + type CronSchedule struct { // A cron expression using quartz syntax. EX: `0 0 8 * * ?` represents // everyday at 8am. See [Cron Trigger] for details. @@ -69,27 +111,38 @@ type CronSchedule struct { TimezoneId types.String `tfsdk:"timezone_id" tf:""` } +func (newState *CronSchedule) SyncEffectiveFieldsDuringCreateOrUpdate(plan CronSchedule) { +} + +func (newState *CronSchedule) SyncEffectiveFieldsDuringRead(existingState CronSchedule) { +} + type Dashboard struct { // The timestamp of when the dashboard was created. - CreateTime types.String `tfsdk:"create_time" tf:"optional"` + CreateTime types.String `tfsdk:"create_time" tf:"optional"` + EffectiveCreateTime types.String `tfsdk:"effective_create_time" tf:"computed,optional"` // UUID identifying the dashboard. - DashboardId types.String `tfsdk:"dashboard_id" tf:"optional"` + DashboardId types.String `tfsdk:"dashboard_id" tf:"optional"` + EffectiveDashboardId types.String `tfsdk:"effective_dashboard_id" tf:"computed,optional"` // The display name of the dashboard. DisplayName types.String `tfsdk:"display_name" tf:"optional"` // The etag for the dashboard. Can be optionally provided on updates to // ensure that the dashboard has not been modified since the last read. This // field is excluded in List Dashboards responses. - Etag types.String `tfsdk:"etag" tf:"optional"` + Etag types.String `tfsdk:"etag" tf:"optional"` + EffectiveEtag types.String `tfsdk:"effective_etag" tf:"computed,optional"` // The state of the dashboard resource. Used for tracking trashed status. LifecycleState types.String `tfsdk:"lifecycle_state" tf:"optional"` // The workspace path of the folder containing the dashboard. Includes // leading slash and no trailing slash. This field is excluded in List // Dashboards responses. - ParentPath types.String `tfsdk:"parent_path" tf:"optional"` + ParentPath types.String `tfsdk:"parent_path" tf:"optional"` + EffectiveParentPath types.String `tfsdk:"effective_parent_path" tf:"computed,optional"` // The workspace path of the dashboard asset, including the file name. // Exported dashboards always have the file extension `.lvdash.json`. This // field is excluded in List Dashboards responses. - Path types.String `tfsdk:"path" tf:"optional"` + Path types.String `tfsdk:"path" tf:"optional"` + EffectivePath types.String `tfsdk:"effective_path" tf:"computed,optional"` // The contents of the dashboard in serialized string form. This field is // excluded in List Dashboards responses. Use the [get dashboard API] to // retrieve an example response, which includes the `serialized_dashboard` @@ -100,41 +153,144 @@ type Dashboard struct { SerializedDashboard types.String `tfsdk:"serialized_dashboard" tf:"optional"` // The timestamp of when the dashboard was last updated by the user. This // field is excluded in List Dashboards responses. - UpdateTime types.String `tfsdk:"update_time" tf:"optional"` + UpdateTime types.String `tfsdk:"update_time" tf:"optional"` + EffectiveUpdateTime types.String `tfsdk:"effective_update_time" tf:"computed,optional"` // The warehouse ID used to run the dashboard. WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *Dashboard) SyncEffectiveFieldsDuringCreateOrUpdate(plan Dashboard) { + newState.EffectiveCreateTime = newState.CreateTime + newState.CreateTime = plan.CreateTime + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectiveEtag = newState.Etag + newState.Etag = plan.Etag + newState.EffectiveParentPath = newState.ParentPath + newState.ParentPath = plan.ParentPath + newState.EffectivePath = newState.Path + newState.Path = plan.Path + newState.EffectiveUpdateTime = newState.UpdateTime + newState.UpdateTime = plan.UpdateTime +} + +func (newState *Dashboard) SyncEffectiveFieldsDuringRead(existingState Dashboard) { + if existingState.EffectiveCreateTime.ValueString() == newState.CreateTime.ValueString() { + newState.CreateTime = existingState.CreateTime + } + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectiveEtag.ValueString() == newState.Etag.ValueString() { + newState.Etag = existingState.Etag + } + if existingState.EffectiveParentPath.ValueString() == newState.ParentPath.ValueString() { + newState.ParentPath = existingState.ParentPath + } + if existingState.EffectivePath.ValueString() == newState.Path.ValueString() { + newState.Path = existingState.Path + } + if existingState.EffectiveUpdateTime.ValueString() == newState.UpdateTime.ValueString() { + newState.UpdateTime = existingState.UpdateTime + } +} + // Delete dashboard schedule type DeleteScheduleRequest struct { // UUID identifying the dashboard to which the schedule belongs. - DashboardId types.String `tfsdk:"-"` + DashboardId types.String `tfsdk:"-"` + EffectiveDashboardId types.String `tfsdk:"-"` // The etag for the schedule. Optionally, it can be provided to verify that // the schedule has not been modified from its last retrieval. - Etag types.String `tfsdk:"-"` + Etag types.String `tfsdk:"-"` + EffectiveEtag types.String `tfsdk:"-"` // UUID identifying the schedule. - ScheduleId types.String `tfsdk:"-"` + ScheduleId types.String `tfsdk:"-"` + EffectiveScheduleId types.String `tfsdk:"-"` +} + +func (newState *DeleteScheduleRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteScheduleRequest) { + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectiveEtag = newState.Etag + newState.Etag = plan.Etag + newState.EffectiveScheduleId = newState.ScheduleId + newState.ScheduleId = plan.ScheduleId +} + +func (newState *DeleteScheduleRequest) SyncEffectiveFieldsDuringRead(existingState DeleteScheduleRequest) { + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectiveEtag.ValueString() == newState.Etag.ValueString() { + newState.Etag = existingState.Etag + } + if existingState.EffectiveScheduleId.ValueString() == newState.ScheduleId.ValueString() { + newState.ScheduleId = existingState.ScheduleId + } } type DeleteScheduleResponse struct { } +func (newState *DeleteScheduleResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteScheduleResponse) { +} + +func (newState *DeleteScheduleResponse) SyncEffectiveFieldsDuringRead(existingState DeleteScheduleResponse) { +} + // Delete schedule subscription type DeleteSubscriptionRequest struct { // UUID identifying the dashboard which the subscription belongs. - DashboardId types.String `tfsdk:"-"` + DashboardId types.String `tfsdk:"-"` + EffectiveDashboardId types.String `tfsdk:"-"` // The etag for the subscription. Can be optionally provided to ensure that // the subscription has not been modified since the last read. - Etag types.String `tfsdk:"-"` + Etag types.String `tfsdk:"-"` + EffectiveEtag types.String `tfsdk:"-"` // UUID identifying the schedule which the subscription belongs. - ScheduleId types.String `tfsdk:"-"` + ScheduleId types.String `tfsdk:"-"` + EffectiveScheduleId types.String `tfsdk:"-"` // UUID identifying the subscription. - SubscriptionId types.String `tfsdk:"-"` + SubscriptionId types.String `tfsdk:"-"` + EffectiveSubscriptionId types.String `tfsdk:"-"` +} + +func (newState *DeleteSubscriptionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteSubscriptionRequest) { + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectiveEtag = newState.Etag + newState.Etag = plan.Etag + newState.EffectiveScheduleId = newState.ScheduleId + newState.ScheduleId = plan.ScheduleId + newState.EffectiveSubscriptionId = newState.SubscriptionId + newState.SubscriptionId = plan.SubscriptionId +} + +func (newState *DeleteSubscriptionRequest) SyncEffectiveFieldsDuringRead(existingState DeleteSubscriptionRequest) { + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectiveEtag.ValueString() == newState.Etag.ValueString() { + newState.Etag = existingState.Etag + } + if existingState.EffectiveScheduleId.ValueString() == newState.ScheduleId.ValueString() { + newState.ScheduleId = existingState.ScheduleId + } + if existingState.EffectiveSubscriptionId.ValueString() == newState.SubscriptionId.ValueString() { + newState.SubscriptionId = existingState.SubscriptionId + } } type DeleteSubscriptionResponse struct { } +func (newState *DeleteSubscriptionResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteSubscriptionResponse) { +} + +func (newState *DeleteSubscriptionResponse) SyncEffectiveFieldsDuringRead(existingState DeleteSubscriptionResponse) { +} + // Execute SQL query in a conversation message type ExecuteMessageQueryRequest struct { // Conversation ID @@ -145,6 +301,12 @@ type ExecuteMessageQueryRequest struct { SpaceId types.String `tfsdk:"-"` } +func (newState *ExecuteMessageQueryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExecuteMessageQueryRequest) { +} + +func (newState *ExecuteMessageQueryRequest) SyncEffectiveFieldsDuringRead(existingState ExecuteMessageQueryRequest) { +} + // Genie AI Response type GenieAttachment struct { Query []QueryAttachment `tfsdk:"query" tf:"optional,object"` @@ -152,6 +314,12 @@ type GenieAttachment struct { Text []TextAttachment `tfsdk:"text" tf:"optional,object"` } +func (newState *GenieAttachment) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenieAttachment) { +} + +func (newState *GenieAttachment) SyncEffectiveFieldsDuringRead(existingState GenieAttachment) { +} + type GenieConversation struct { // Timestamp when the message was created CreatedTimestamp types.Int64 `tfsdk:"created_timestamp" tf:"optional"` @@ -167,6 +335,12 @@ type GenieConversation struct { UserId types.Int64 `tfsdk:"user_id" tf:""` } +func (newState *GenieConversation) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenieConversation) { +} + +func (newState *GenieConversation) SyncEffectiveFieldsDuringRead(existingState GenieConversation) { +} + type GenieCreateConversationMessageRequest struct { // User message content. Content types.String `tfsdk:"content" tf:""` @@ -176,6 +350,12 @@ type GenieCreateConversationMessageRequest struct { SpaceId types.String `tfsdk:"-"` } +func (newState *GenieCreateConversationMessageRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenieCreateConversationMessageRequest) { +} + +func (newState *GenieCreateConversationMessageRequest) SyncEffectiveFieldsDuringRead(existingState GenieCreateConversationMessageRequest) { +} + // Get conversation message type GenieGetConversationMessageRequest struct { // The ID associated with the target conversation. @@ -188,6 +368,12 @@ type GenieGetConversationMessageRequest struct { SpaceId types.String `tfsdk:"-"` } +func (newState *GenieGetConversationMessageRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenieGetConversationMessageRequest) { +} + +func (newState *GenieGetConversationMessageRequest) SyncEffectiveFieldsDuringRead(existingState GenieGetConversationMessageRequest) { +} + // Get conversation message SQL query result type GenieGetMessageQueryResultRequest struct { // Conversation ID @@ -198,12 +384,24 @@ type GenieGetMessageQueryResultRequest struct { SpaceId types.String `tfsdk:"-"` } +func (newState *GenieGetMessageQueryResultRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenieGetMessageQueryResultRequest) { +} + +func (newState *GenieGetMessageQueryResultRequest) SyncEffectiveFieldsDuringRead(existingState GenieGetMessageQueryResultRequest) { +} + type GenieGetMessageQueryResultResponse struct { // SQL Statement Execution response. See [Get status, manifest, and result // first chunk](:method:statementexecution/getstatement) for more details. StatementResponse sql.StatementResponse `tfsdk:"statement_response" tf:"optional,object"` } +func (newState *GenieGetMessageQueryResultResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenieGetMessageQueryResultResponse) { +} + +func (newState *GenieGetMessageQueryResultResponse) SyncEffectiveFieldsDuringRead(existingState GenieGetMessageQueryResultResponse) { +} + type GenieMessage struct { // AI produced response to the message Attachments []GenieAttachment `tfsdk:"attachments" tf:"optional"` @@ -244,6 +442,12 @@ type GenieMessage struct { UserId types.Int64 `tfsdk:"user_id" tf:"optional"` } +func (newState *GenieMessage) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenieMessage) { +} + +func (newState *GenieMessage) SyncEffectiveFieldsDuringRead(existingState GenieMessage) { +} + type GenieStartConversationMessageRequest struct { // The text of the message that starts the conversation. Content types.String `tfsdk:"content" tf:""` @@ -252,6 +456,12 @@ type GenieStartConversationMessageRequest struct { SpaceId types.String `tfsdk:"-"` } +func (newState *GenieStartConversationMessageRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenieStartConversationMessageRequest) { +} + +func (newState *GenieStartConversationMessageRequest) SyncEffectiveFieldsDuringRead(existingState GenieStartConversationMessageRequest) { +} + type GenieStartConversationResponse struct { Conversation []GenieConversation `tfsdk:"conversation" tf:"optional,object"` // Conversation ID @@ -262,34 +472,94 @@ type GenieStartConversationResponse struct { MessageId types.String `tfsdk:"message_id" tf:""` } +func (newState *GenieStartConversationResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenieStartConversationResponse) { +} + +func (newState *GenieStartConversationResponse) SyncEffectiveFieldsDuringRead(existingState GenieStartConversationResponse) { +} + // Get dashboard type GetDashboardRequest struct { // UUID identifying the dashboard. DashboardId types.String `tfsdk:"-"` } +func (newState *GetDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetDashboardRequest) { +} + +func (newState *GetDashboardRequest) SyncEffectiveFieldsDuringRead(existingState GetDashboardRequest) { +} + // Get published dashboard type GetPublishedDashboardRequest struct { // UUID identifying the dashboard to be published. DashboardId types.String `tfsdk:"-"` } +func (newState *GetPublishedDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPublishedDashboardRequest) { +} + +func (newState *GetPublishedDashboardRequest) SyncEffectiveFieldsDuringRead(existingState GetPublishedDashboardRequest) { +} + // Get dashboard schedule type GetScheduleRequest struct { // UUID identifying the dashboard to which the schedule belongs. - DashboardId types.String `tfsdk:"-"` + DashboardId types.String `tfsdk:"-"` + EffectiveDashboardId types.String `tfsdk:"-"` // UUID identifying the schedule. - ScheduleId types.String `tfsdk:"-"` + ScheduleId types.String `tfsdk:"-"` + EffectiveScheduleId types.String `tfsdk:"-"` +} + +func (newState *GetScheduleRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetScheduleRequest) { + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectiveScheduleId = newState.ScheduleId + newState.ScheduleId = plan.ScheduleId +} + +func (newState *GetScheduleRequest) SyncEffectiveFieldsDuringRead(existingState GetScheduleRequest) { + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectiveScheduleId.ValueString() == newState.ScheduleId.ValueString() { + newState.ScheduleId = existingState.ScheduleId + } } // Get schedule subscription type GetSubscriptionRequest struct { // UUID identifying the dashboard which the subscription belongs. - DashboardId types.String `tfsdk:"-"` + DashboardId types.String `tfsdk:"-"` + EffectiveDashboardId types.String `tfsdk:"-"` // UUID identifying the schedule which the subscription belongs. - ScheduleId types.String `tfsdk:"-"` + ScheduleId types.String `tfsdk:"-"` + EffectiveScheduleId types.String `tfsdk:"-"` // UUID identifying the subscription. - SubscriptionId types.String `tfsdk:"-"` + SubscriptionId types.String `tfsdk:"-"` + EffectiveSubscriptionId types.String `tfsdk:"-"` +} + +func (newState *GetSubscriptionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetSubscriptionRequest) { + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectiveScheduleId = newState.ScheduleId + newState.ScheduleId = plan.ScheduleId + newState.EffectiveSubscriptionId = newState.SubscriptionId + newState.SubscriptionId = plan.SubscriptionId +} + +func (newState *GetSubscriptionRequest) SyncEffectiveFieldsDuringRead(existingState GetSubscriptionRequest) { + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectiveScheduleId.ValueString() == newState.ScheduleId.ValueString() { + newState.ScheduleId = existingState.ScheduleId + } + if existingState.EffectiveSubscriptionId.ValueString() == newState.SubscriptionId.ValueString() { + newState.SubscriptionId = existingState.SubscriptionId + } } // List dashboards @@ -298,7 +568,8 @@ type ListDashboardsRequest struct { PageSize types.Int64 `tfsdk:"-"` // A page token, received from a previous `ListDashboards` call. This token // can be used to retrieve the subsequent page. - PageToken types.String `tfsdk:"-"` + PageToken types.String `tfsdk:"-"` + EffectivePageToken types.String `tfsdk:"-"` // The flag to include dashboards located in the trash. If unspecified, only // active dashboards will be returned. ShowTrashed types.Bool `tfsdk:"-"` @@ -306,61 +577,156 @@ type ListDashboardsRequest struct { View types.String `tfsdk:"-"` } +func (newState *ListDashboardsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListDashboardsRequest) { + newState.EffectivePageToken = newState.PageToken + newState.PageToken = plan.PageToken +} + +func (newState *ListDashboardsRequest) SyncEffectiveFieldsDuringRead(existingState ListDashboardsRequest) { + if existingState.EffectivePageToken.ValueString() == newState.PageToken.ValueString() { + newState.PageToken = existingState.PageToken + } +} + type ListDashboardsResponse struct { Dashboards []Dashboard `tfsdk:"dashboards" tf:"optional"` // A token, which can be sent as `page_token` to retrieve the next page. If // this field is omitted, there are no subsequent dashboards. - NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` + NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` + EffectiveNextPageToken types.String `tfsdk:"effective_next_page_token" tf:"computed,optional"` +} + +func (newState *ListDashboardsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListDashboardsResponse) { + newState.EffectiveNextPageToken = newState.NextPageToken + newState.NextPageToken = plan.NextPageToken +} + +func (newState *ListDashboardsResponse) SyncEffectiveFieldsDuringRead(existingState ListDashboardsResponse) { + if existingState.EffectiveNextPageToken.ValueString() == newState.NextPageToken.ValueString() { + newState.NextPageToken = existingState.NextPageToken + } } // List dashboard schedules type ListSchedulesRequest struct { // UUID identifying the dashboard to which the schedule belongs. - DashboardId types.String `tfsdk:"-"` + DashboardId types.String `tfsdk:"-"` + EffectiveDashboardId types.String `tfsdk:"-"` // The number of schedules to return per page. PageSize types.Int64 `tfsdk:"-"` // A page token, received from a previous `ListSchedules` call. Use this to // retrieve the subsequent page. - PageToken types.String `tfsdk:"-"` + PageToken types.String `tfsdk:"-"` + EffectivePageToken types.String `tfsdk:"-"` +} + +func (newState *ListSchedulesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSchedulesRequest) { + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectivePageToken = newState.PageToken + newState.PageToken = plan.PageToken +} + +func (newState *ListSchedulesRequest) SyncEffectiveFieldsDuringRead(existingState ListSchedulesRequest) { + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectivePageToken.ValueString() == newState.PageToken.ValueString() { + newState.PageToken = existingState.PageToken + } } type ListSchedulesResponse struct { // A token that can be used as a `page_token` in subsequent requests to // retrieve the next page of results. If this field is omitted, there are no // subsequent schedules. - NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` + NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` + EffectiveNextPageToken types.String `tfsdk:"effective_next_page_token" tf:"computed,optional"` Schedules []Schedule `tfsdk:"schedules" tf:"optional"` } +func (newState *ListSchedulesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSchedulesResponse) { + newState.EffectiveNextPageToken = newState.NextPageToken + newState.NextPageToken = plan.NextPageToken +} + +func (newState *ListSchedulesResponse) SyncEffectiveFieldsDuringRead(existingState ListSchedulesResponse) { + if existingState.EffectiveNextPageToken.ValueString() == newState.NextPageToken.ValueString() { + newState.NextPageToken = existingState.NextPageToken + } +} + // List schedule subscriptions type ListSubscriptionsRequest struct { // UUID identifying the dashboard to which the subscription belongs. - DashboardId types.String `tfsdk:"-"` + DashboardId types.String `tfsdk:"-"` + EffectiveDashboardId types.String `tfsdk:"-"` // The number of subscriptions to return per page. PageSize types.Int64 `tfsdk:"-"` // A page token, received from a previous `ListSubscriptions` call. Use this // to retrieve the subsequent page. - PageToken types.String `tfsdk:"-"` + PageToken types.String `tfsdk:"-"` + EffectivePageToken types.String `tfsdk:"-"` // UUID identifying the schedule to which the subscription belongs. - ScheduleId types.String `tfsdk:"-"` + ScheduleId types.String `tfsdk:"-"` + EffectiveScheduleId types.String `tfsdk:"-"` +} + +func (newState *ListSubscriptionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSubscriptionsRequest) { + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectivePageToken = newState.PageToken + newState.PageToken = plan.PageToken + newState.EffectiveScheduleId = newState.ScheduleId + newState.ScheduleId = plan.ScheduleId +} + +func (newState *ListSubscriptionsRequest) SyncEffectiveFieldsDuringRead(existingState ListSubscriptionsRequest) { + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectivePageToken.ValueString() == newState.PageToken.ValueString() { + newState.PageToken = existingState.PageToken + } + if existingState.EffectiveScheduleId.ValueString() == newState.ScheduleId.ValueString() { + newState.ScheduleId = existingState.ScheduleId + } } type ListSubscriptionsResponse struct { // A token that can be used as a `page_token` in subsequent requests to // retrieve the next page of results. If this field is omitted, there are no // subsequent subscriptions. - NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` + NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` + EffectiveNextPageToken types.String `tfsdk:"effective_next_page_token" tf:"computed,optional"` Subscriptions []Subscription `tfsdk:"subscriptions" tf:"optional"` } +func (newState *ListSubscriptionsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSubscriptionsResponse) { + newState.EffectiveNextPageToken = newState.NextPageToken + newState.NextPageToken = plan.NextPageToken +} + +func (newState *ListSubscriptionsResponse) SyncEffectiveFieldsDuringRead(existingState ListSubscriptionsResponse) { + if existingState.EffectiveNextPageToken.ValueString() == newState.NextPageToken.ValueString() { + newState.NextPageToken = existingState.NextPageToken + } +} + type MessageError struct { Error types.String `tfsdk:"error" tf:"optional"` Type types.String `tfsdk:"type" tf:"optional"` } +func (newState *MessageError) SyncEffectiveFieldsDuringCreateOrUpdate(plan MessageError) { +} + +func (newState *MessageError) SyncEffectiveFieldsDuringRead(existingState MessageError) { +} + type MigrateDashboardRequest struct { // Display name for the new Lakeview dashboard. DisplayName types.String `tfsdk:"display_name" tf:"optional"` @@ -371,6 +737,12 @@ type MigrateDashboardRequest struct { SourceDashboardId types.String `tfsdk:"source_dashboard_id" tf:""` } +func (newState *MigrateDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan MigrateDashboardRequest) { +} + +func (newState *MigrateDashboardRequest) SyncEffectiveFieldsDuringRead(existingState MigrateDashboardRequest) { +} + type PublishRequest struct { // UUID identifying the dashboard to be published. DashboardId types.String `tfsdk:"-"` @@ -383,17 +755,41 @@ type PublishRequest struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *PublishRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan PublishRequest) { +} + +func (newState *PublishRequest) SyncEffectiveFieldsDuringRead(existingState PublishRequest) { +} + type PublishedDashboard struct { // The display name of the published dashboard. - DisplayName types.String `tfsdk:"display_name" tf:"optional"` + DisplayName types.String `tfsdk:"display_name" tf:"optional"` + EffectiveDisplayName types.String `tfsdk:"effective_display_name" tf:"computed,optional"` // Indicates whether credentials are embedded in the published dashboard. EmbedCredentials types.Bool `tfsdk:"embed_credentials" tf:"optional"` // The timestamp of when the published dashboard was last revised. - RevisionCreateTime types.String `tfsdk:"revision_create_time" tf:"optional"` + RevisionCreateTime types.String `tfsdk:"revision_create_time" tf:"optional"` + EffectiveRevisionCreateTime types.String `tfsdk:"effective_revision_create_time" tf:"computed,optional"` // The warehouse ID used to run the published dashboard. WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *PublishedDashboard) SyncEffectiveFieldsDuringCreateOrUpdate(plan PublishedDashboard) { + newState.EffectiveDisplayName = newState.DisplayName + newState.DisplayName = plan.DisplayName + newState.EffectiveRevisionCreateTime = newState.RevisionCreateTime + newState.RevisionCreateTime = plan.RevisionCreateTime +} + +func (newState *PublishedDashboard) SyncEffectiveFieldsDuringRead(existingState PublishedDashboard) { + if existingState.EffectiveDisplayName.ValueString() == newState.DisplayName.ValueString() { + newState.DisplayName = existingState.DisplayName + } + if existingState.EffectiveRevisionCreateTime.ValueString() == newState.RevisionCreateTime.ValueString() { + newState.RevisionCreateTime = existingState.RevisionCreateTime + } +} + type QueryAttachment struct { // Description of the query Description types.String `tfsdk:"description" tf:"optional"` @@ -413,7 +809,15 @@ type QueryAttachment struct { Title types.String `tfsdk:"title" tf:"optional"` } +func (newState *QueryAttachment) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryAttachment) { +} + +func (newState *QueryAttachment) SyncEffectiveFieldsDuringRead(existingState QueryAttachment) { +} + type Result struct { + // If result is truncated + IsTruncated types.Bool `tfsdk:"is_truncated" tf:"optional"` // Row count of the result RowCount types.Int64 `tfsdk:"row_count" tf:"optional"` // Statement Execution API statement id. Use [Get status, manifest, and @@ -422,26 +826,68 @@ type Result struct { StatementId types.String `tfsdk:"statement_id" tf:"optional"` } +func (newState *Result) SyncEffectiveFieldsDuringCreateOrUpdate(plan Result) { +} + +func (newState *Result) SyncEffectiveFieldsDuringRead(existingState Result) { +} + type Schedule struct { // A timestamp indicating when the schedule was created. - CreateTime types.String `tfsdk:"create_time" tf:"optional"` + CreateTime types.String `tfsdk:"create_time" tf:"optional"` + EffectiveCreateTime types.String `tfsdk:"effective_create_time" tf:"computed,optional"` // The cron expression describing the frequency of the periodic refresh for // this schedule. CronSchedule []CronSchedule `tfsdk:"cron_schedule" tf:"object"` // UUID identifying the dashboard to which the schedule belongs. - DashboardId types.String `tfsdk:"dashboard_id" tf:"optional"` + DashboardId types.String `tfsdk:"dashboard_id" tf:"optional"` + EffectiveDashboardId types.String `tfsdk:"effective_dashboard_id" tf:"computed,optional"` // The display name for schedule. DisplayName types.String `tfsdk:"display_name" tf:"optional"` // The etag for the schedule. Must be left empty on create, must be provided // on updates to ensure that the schedule has not been modified since the // last read, and can be optionally provided on delete. - Etag types.String `tfsdk:"etag" tf:"optional"` + Etag types.String `tfsdk:"etag" tf:"optional"` + EffectiveEtag types.String `tfsdk:"effective_etag" tf:"computed,optional"` // The status indicates whether this schedule is paused or not. PauseStatus types.String `tfsdk:"pause_status" tf:"optional"` // UUID identifying the schedule. - ScheduleId types.String `tfsdk:"schedule_id" tf:"optional"` + ScheduleId types.String `tfsdk:"schedule_id" tf:"optional"` + EffectiveScheduleId types.String `tfsdk:"effective_schedule_id" tf:"computed,optional"` // A timestamp indicating when the schedule was last updated. - UpdateTime types.String `tfsdk:"update_time" tf:"optional"` + UpdateTime types.String `tfsdk:"update_time" tf:"optional"` + EffectiveUpdateTime types.String `tfsdk:"effective_update_time" tf:"computed,optional"` +} + +func (newState *Schedule) SyncEffectiveFieldsDuringCreateOrUpdate(plan Schedule) { + newState.EffectiveCreateTime = newState.CreateTime + newState.CreateTime = plan.CreateTime + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectiveEtag = newState.Etag + newState.Etag = plan.Etag + newState.EffectiveScheduleId = newState.ScheduleId + newState.ScheduleId = plan.ScheduleId + newState.EffectiveUpdateTime = newState.UpdateTime + newState.UpdateTime = plan.UpdateTime +} + +func (newState *Schedule) SyncEffectiveFieldsDuringRead(existingState Schedule) { + if existingState.EffectiveCreateTime.ValueString() == newState.CreateTime.ValueString() { + newState.CreateTime = existingState.CreateTime + } + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectiveEtag.ValueString() == newState.Etag.ValueString() { + newState.Etag = existingState.Etag + } + if existingState.EffectiveScheduleId.ValueString() == newState.ScheduleId.ValueString() { + newState.ScheduleId = existingState.ScheduleId + } + if existingState.EffectiveUpdateTime.ValueString() == newState.UpdateTime.ValueString() { + newState.UpdateTime = existingState.UpdateTime + } } type Subscriber struct { @@ -453,38 +899,116 @@ type Subscriber struct { UserSubscriber []SubscriptionSubscriberUser `tfsdk:"user_subscriber" tf:"optional,object"` } +func (newState *Subscriber) SyncEffectiveFieldsDuringCreateOrUpdate(plan Subscriber) { +} + +func (newState *Subscriber) SyncEffectiveFieldsDuringRead(existingState Subscriber) { +} + type Subscription struct { // A timestamp indicating when the subscription was created. - CreateTime types.String `tfsdk:"create_time" tf:"optional"` + CreateTime types.String `tfsdk:"create_time" tf:"optional"` + EffectiveCreateTime types.String `tfsdk:"effective_create_time" tf:"computed,optional"` // UserId of the user who adds subscribers (users or notification // destinations) to the dashboard's schedule. - CreatedByUserId types.Int64 `tfsdk:"created_by_user_id" tf:"optional"` + CreatedByUserId types.Int64 `tfsdk:"created_by_user_id" tf:"optional"` + EffectiveCreatedByUserId types.Int64 `tfsdk:"effective_created_by_user_id" tf:"computed,optional"` // UUID identifying the dashboard to which the subscription belongs. - DashboardId types.String `tfsdk:"dashboard_id" tf:"optional"` + DashboardId types.String `tfsdk:"dashboard_id" tf:"optional"` + EffectiveDashboardId types.String `tfsdk:"effective_dashboard_id" tf:"computed,optional"` // The etag for the subscription. Must be left empty on create, can be // optionally provided on delete to ensure that the subscription has not // been deleted since the last read. - Etag types.String `tfsdk:"etag" tf:"optional"` + Etag types.String `tfsdk:"etag" tf:"optional"` + EffectiveEtag types.String `tfsdk:"effective_etag" tf:"computed,optional"` // UUID identifying the schedule to which the subscription belongs. - ScheduleId types.String `tfsdk:"schedule_id" tf:"optional"` + ScheduleId types.String `tfsdk:"schedule_id" tf:"optional"` + EffectiveScheduleId types.String `tfsdk:"effective_schedule_id" tf:"computed,optional"` // Subscriber details for users and destinations to be added as subscribers // to the schedule. Subscriber []Subscriber `tfsdk:"subscriber" tf:"object"` // UUID identifying the subscription. - SubscriptionId types.String `tfsdk:"subscription_id" tf:"optional"` + SubscriptionId types.String `tfsdk:"subscription_id" tf:"optional"` + EffectiveSubscriptionId types.String `tfsdk:"effective_subscription_id" tf:"computed,optional"` // A timestamp indicating when the subscription was last updated. - UpdateTime types.String `tfsdk:"update_time" tf:"optional"` + UpdateTime types.String `tfsdk:"update_time" tf:"optional"` + EffectiveUpdateTime types.String `tfsdk:"effective_update_time" tf:"computed,optional"` +} + +func (newState *Subscription) SyncEffectiveFieldsDuringCreateOrUpdate(plan Subscription) { + newState.EffectiveCreateTime = newState.CreateTime + newState.CreateTime = plan.CreateTime + newState.EffectiveCreatedByUserId = newState.CreatedByUserId + newState.CreatedByUserId = plan.CreatedByUserId + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectiveEtag = newState.Etag + newState.Etag = plan.Etag + newState.EffectiveScheduleId = newState.ScheduleId + newState.ScheduleId = plan.ScheduleId + newState.EffectiveSubscriptionId = newState.SubscriptionId + newState.SubscriptionId = plan.SubscriptionId + newState.EffectiveUpdateTime = newState.UpdateTime + newState.UpdateTime = plan.UpdateTime +} + +func (newState *Subscription) SyncEffectiveFieldsDuringRead(existingState Subscription) { + if existingState.EffectiveCreateTime.ValueString() == newState.CreateTime.ValueString() { + newState.CreateTime = existingState.CreateTime + } + if existingState.EffectiveCreatedByUserId.ValueInt64() == newState.CreatedByUserId.ValueInt64() { + newState.CreatedByUserId = existingState.CreatedByUserId + } + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectiveEtag.ValueString() == newState.Etag.ValueString() { + newState.Etag = existingState.Etag + } + if existingState.EffectiveScheduleId.ValueString() == newState.ScheduleId.ValueString() { + newState.ScheduleId = existingState.ScheduleId + } + if existingState.EffectiveSubscriptionId.ValueString() == newState.SubscriptionId.ValueString() { + newState.SubscriptionId = existingState.SubscriptionId + } + if existingState.EffectiveUpdateTime.ValueString() == newState.UpdateTime.ValueString() { + newState.UpdateTime = existingState.UpdateTime + } } type SubscriptionSubscriberDestination struct { // The canonical identifier of the destination to receive email // notification. - DestinationId types.String `tfsdk:"destination_id" tf:""` + DestinationId types.String `tfsdk:"destination_id" tf:""` + EffectiveDestinationId types.String `tfsdk:"effective_destination_id" tf:"computed,optional"` +} + +func (newState *SubscriptionSubscriberDestination) SyncEffectiveFieldsDuringCreateOrUpdate(plan SubscriptionSubscriberDestination) { + newState.EffectiveDestinationId = newState.DestinationId + newState.DestinationId = plan.DestinationId +} + +func (newState *SubscriptionSubscriberDestination) SyncEffectiveFieldsDuringRead(existingState SubscriptionSubscriberDestination) { + if existingState.EffectiveDestinationId.ValueString() == newState.DestinationId.ValueString() { + newState.DestinationId = existingState.DestinationId + } } type SubscriptionSubscriberUser struct { // UserId of the subscriber. - UserId types.Int64 `tfsdk:"user_id" tf:""` + UserId types.Int64 `tfsdk:"user_id" tf:""` + EffectiveUserId types.Int64 `tfsdk:"effective_user_id" tf:"computed,optional"` +} + +func (newState *SubscriptionSubscriberUser) SyncEffectiveFieldsDuringCreateOrUpdate(plan SubscriptionSubscriberUser) { + newState.EffectiveUserId = newState.UserId + newState.UserId = plan.UserId +} + +func (newState *SubscriptionSubscriberUser) SyncEffectiveFieldsDuringRead(existingState SubscriptionSubscriberUser) { + if existingState.EffectiveUserId.ValueInt64() == newState.UserId.ValueInt64() { + newState.UserId = existingState.UserId + } } type TextAttachment struct { @@ -494,24 +1018,54 @@ type TextAttachment struct { Id types.String `tfsdk:"id" tf:"optional"` } +func (newState *TextAttachment) SyncEffectiveFieldsDuringCreateOrUpdate(plan TextAttachment) { +} + +func (newState *TextAttachment) SyncEffectiveFieldsDuringRead(existingState TextAttachment) { +} + // Trash dashboard type TrashDashboardRequest struct { // UUID identifying the dashboard. DashboardId types.String `tfsdk:"-"` } +func (newState *TrashDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan TrashDashboardRequest) { +} + +func (newState *TrashDashboardRequest) SyncEffectiveFieldsDuringRead(existingState TrashDashboardRequest) { +} + type TrashDashboardResponse struct { } +func (newState *TrashDashboardResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan TrashDashboardResponse) { +} + +func (newState *TrashDashboardResponse) SyncEffectiveFieldsDuringRead(existingState TrashDashboardResponse) { +} + // Unpublish dashboard type UnpublishDashboardRequest struct { // UUID identifying the dashboard to be published. DashboardId types.String `tfsdk:"-"` } +func (newState *UnpublishDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UnpublishDashboardRequest) { +} + +func (newState *UnpublishDashboardRequest) SyncEffectiveFieldsDuringRead(existingState UnpublishDashboardRequest) { +} + type UnpublishDashboardResponse struct { } +func (newState *UnpublishDashboardResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UnpublishDashboardResponse) { +} + +func (newState *UnpublishDashboardResponse) SyncEffectiveFieldsDuringRead(existingState UnpublishDashboardResponse) { +} + type UpdateDashboardRequest struct { // UUID identifying the dashboard. DashboardId types.String `tfsdk:"-"` @@ -520,7 +1074,8 @@ type UpdateDashboardRequest struct { // The etag for the dashboard. Can be optionally provided on updates to // ensure that the dashboard has not been modified since the last read. This // field is excluded in List Dashboards responses. - Etag types.String `tfsdk:"etag" tf:"optional"` + Etag types.String `tfsdk:"etag" tf:"optional"` + EffectiveEtag types.String `tfsdk:"effective_etag" tf:"computed,optional"` // The contents of the dashboard in serialized string form. This field is // excluded in List Dashboards responses. Use the [get dashboard API] to // retrieve an example response, which includes the `serialized_dashboard` @@ -533,20 +1088,55 @@ type UpdateDashboardRequest struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *UpdateDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateDashboardRequest) { + newState.EffectiveEtag = newState.Etag + newState.Etag = plan.Etag +} + +func (newState *UpdateDashboardRequest) SyncEffectiveFieldsDuringRead(existingState UpdateDashboardRequest) { + if existingState.EffectiveEtag.ValueString() == newState.Etag.ValueString() { + newState.Etag = existingState.Etag + } +} + type UpdateScheduleRequest struct { // The cron expression describing the frequency of the periodic refresh for // this schedule. CronSchedule []CronSchedule `tfsdk:"cron_schedule" tf:"object"` // UUID identifying the dashboard to which the schedule belongs. - DashboardId types.String `tfsdk:"-"` + DashboardId types.String `tfsdk:"-"` + EffectiveDashboardId types.String `tfsdk:"-"` // The display name for schedule. DisplayName types.String `tfsdk:"display_name" tf:"optional"` // The etag for the schedule. Must be left empty on create, must be provided // on updates to ensure that the schedule has not been modified since the // last read, and can be optionally provided on delete. - Etag types.String `tfsdk:"etag" tf:"optional"` + Etag types.String `tfsdk:"etag" tf:"optional"` + EffectiveEtag types.String `tfsdk:"effective_etag" tf:"computed,optional"` // The status indicates whether this schedule is paused or not. PauseStatus types.String `tfsdk:"pause_status" tf:"optional"` // UUID identifying the schedule. - ScheduleId types.String `tfsdk:"-"` + ScheduleId types.String `tfsdk:"-"` + EffectiveScheduleId types.String `tfsdk:"-"` +} + +func (newState *UpdateScheduleRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateScheduleRequest) { + newState.EffectiveDashboardId = newState.DashboardId + newState.DashboardId = plan.DashboardId + newState.EffectiveEtag = newState.Etag + newState.Etag = plan.Etag + newState.EffectiveScheduleId = newState.ScheduleId + newState.ScheduleId = plan.ScheduleId +} + +func (newState *UpdateScheduleRequest) SyncEffectiveFieldsDuringRead(existingState UpdateScheduleRequest) { + if existingState.EffectiveDashboardId.ValueString() == newState.DashboardId.ValueString() { + newState.DashboardId = existingState.DashboardId + } + if existingState.EffectiveEtag.ValueString() == newState.Etag.ValueString() { + newState.Etag = existingState.Etag + } + if existingState.EffectiveScheduleId.ValueString() == newState.ScheduleId.ValueString() { + newState.ScheduleId = existingState.ScheduleId + } } diff --git a/internal/service/files_tf/model.go b/internal/service/files_tf/model.go index e3e67e9961..d2296d76ee 100755 --- a/internal/service/files_tf/model.go +++ b/internal/service/files_tf/model.go @@ -24,17 +24,41 @@ type AddBlock struct { Handle types.Int64 `tfsdk:"handle" tf:""` } +func (newState *AddBlock) SyncEffectiveFieldsDuringCreateOrUpdate(plan AddBlock) { +} + +func (newState *AddBlock) SyncEffectiveFieldsDuringRead(existingState AddBlock) { +} + type AddBlockResponse struct { } +func (newState *AddBlockResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan AddBlockResponse) { +} + +func (newState *AddBlockResponse) SyncEffectiveFieldsDuringRead(existingState AddBlockResponse) { +} + type Close struct { // The handle on an open stream. Handle types.Int64 `tfsdk:"handle" tf:""` } +func (newState *Close) SyncEffectiveFieldsDuringCreateOrUpdate(plan Close) { +} + +func (newState *Close) SyncEffectiveFieldsDuringRead(existingState Close) { +} + type CloseResponse struct { } +func (newState *CloseResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CloseResponse) { +} + +func (newState *CloseResponse) SyncEffectiveFieldsDuringRead(existingState CloseResponse) { +} + type Create struct { // The flag that specifies whether to overwrite existing file/files. Overwrite types.Bool `tfsdk:"overwrite" tf:"optional"` @@ -42,21 +66,45 @@ type Create struct { Path types.String `tfsdk:"path" tf:""` } +func (newState *Create) SyncEffectiveFieldsDuringCreateOrUpdate(plan Create) { +} + +func (newState *Create) SyncEffectiveFieldsDuringRead(existingState Create) { +} + // Create a directory type CreateDirectoryRequest struct { // The absolute path of a directory. DirectoryPath types.String `tfsdk:"-"` } +func (newState *CreateDirectoryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateDirectoryRequest) { +} + +func (newState *CreateDirectoryRequest) SyncEffectiveFieldsDuringRead(existingState CreateDirectoryRequest) { +} + type CreateDirectoryResponse struct { } +func (newState *CreateDirectoryResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateDirectoryResponse) { +} + +func (newState *CreateDirectoryResponse) SyncEffectiveFieldsDuringRead(existingState CreateDirectoryResponse) { +} + type CreateResponse struct { // Handle which should subsequently be passed into the AddBlock and Close // calls when writing to a file through a stream. Handle types.Int64 `tfsdk:"handle" tf:"optional"` } +func (newState *CreateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateResponse) { +} + +func (newState *CreateResponse) SyncEffectiveFieldsDuringRead(existingState CreateResponse) { +} + type Delete struct { // The path of the file or directory to delete. The path should be the // absolute DBFS path. @@ -66,24 +114,54 @@ type Delete struct { Recursive types.Bool `tfsdk:"recursive" tf:"optional"` } +func (newState *Delete) SyncEffectiveFieldsDuringCreateOrUpdate(plan Delete) { +} + +func (newState *Delete) SyncEffectiveFieldsDuringRead(existingState Delete) { +} + // Delete a directory type DeleteDirectoryRequest struct { // The absolute path of a directory. DirectoryPath types.String `tfsdk:"-"` } +func (newState *DeleteDirectoryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDirectoryRequest) { +} + +func (newState *DeleteDirectoryRequest) SyncEffectiveFieldsDuringRead(existingState DeleteDirectoryRequest) { +} + type DeleteDirectoryResponse struct { } +func (newState *DeleteDirectoryResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDirectoryResponse) { +} + +func (newState *DeleteDirectoryResponse) SyncEffectiveFieldsDuringRead(existingState DeleteDirectoryResponse) { +} + // Delete a file type DeleteFileRequest struct { // The absolute path of the file. FilePath types.String `tfsdk:"-"` } +func (newState *DeleteFileRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteFileRequest) { +} + +func (newState *DeleteFileRequest) SyncEffectiveFieldsDuringRead(existingState DeleteFileRequest) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + type DirectoryEntry struct { // The length of the file in bytes. This field is omitted for directories. FileSize types.Int64 `tfsdk:"file_size" tf:"optional"` @@ -98,12 +176,24 @@ type DirectoryEntry struct { Path types.String `tfsdk:"path" tf:"optional"` } +func (newState *DirectoryEntry) SyncEffectiveFieldsDuringCreateOrUpdate(plan DirectoryEntry) { +} + +func (newState *DirectoryEntry) SyncEffectiveFieldsDuringRead(existingState DirectoryEntry) { +} + // Download a file type DownloadRequest struct { // The absolute path of the file. FilePath types.String `tfsdk:"-"` } +func (newState *DownloadRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DownloadRequest) { +} + +func (newState *DownloadRequest) SyncEffectiveFieldsDuringRead(existingState DownloadRequest) { +} + type DownloadResponse struct { ContentLength types.Int64 `tfsdk:"-"` @@ -114,6 +204,12 @@ type DownloadResponse struct { LastModified types.String `tfsdk:"-"` } +func (newState *DownloadResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DownloadResponse) { +} + +func (newState *DownloadResponse) SyncEffectiveFieldsDuringRead(existingState DownloadResponse) { +} + type FileInfo struct { // The length of the file in bytes. This field is omitted for directories. FileSize types.Int64 `tfsdk:"file_size" tf:"optional"` @@ -125,21 +221,45 @@ type FileInfo struct { Path types.String `tfsdk:"path" tf:"optional"` } +func (newState *FileInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan FileInfo) { +} + +func (newState *FileInfo) SyncEffectiveFieldsDuringRead(existingState FileInfo) { +} + // Get directory metadata type GetDirectoryMetadataRequest struct { // The absolute path of a directory. DirectoryPath types.String `tfsdk:"-"` } +func (newState *GetDirectoryMetadataRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetDirectoryMetadataRequest) { +} + +func (newState *GetDirectoryMetadataRequest) SyncEffectiveFieldsDuringRead(existingState GetDirectoryMetadataRequest) { +} + type GetDirectoryMetadataResponse struct { } +func (newState *GetDirectoryMetadataResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetDirectoryMetadataResponse) { +} + +func (newState *GetDirectoryMetadataResponse) SyncEffectiveFieldsDuringRead(existingState GetDirectoryMetadataResponse) { +} + // Get file metadata type GetMetadataRequest struct { // The absolute path of the file. FilePath types.String `tfsdk:"-"` } +func (newState *GetMetadataRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetMetadataRequest) { +} + +func (newState *GetMetadataRequest) SyncEffectiveFieldsDuringRead(existingState GetMetadataRequest) { +} + type GetMetadataResponse struct { ContentLength types.Int64 `tfsdk:"-"` @@ -148,6 +268,12 @@ type GetMetadataResponse struct { LastModified types.String `tfsdk:"-"` } +func (newState *GetMetadataResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetMetadataResponse) { +} + +func (newState *GetMetadataResponse) SyncEffectiveFieldsDuringRead(existingState GetMetadataResponse) { +} + // Get the information of a file or directory type GetStatusRequest struct { // The path of the file or directory. The path should be the absolute DBFS @@ -155,6 +281,12 @@ type GetStatusRequest struct { Path types.String `tfsdk:"-"` } +func (newState *GetStatusRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetStatusRequest) { +} + +func (newState *GetStatusRequest) SyncEffectiveFieldsDuringRead(existingState GetStatusRequest) { +} + // List directory contents or file details type ListDbfsRequest struct { // The path of the file or directory. The path should be the absolute DBFS @@ -162,6 +294,12 @@ type ListDbfsRequest struct { Path types.String `tfsdk:"-"` } +func (newState *ListDbfsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListDbfsRequest) { +} + +func (newState *ListDbfsRequest) SyncEffectiveFieldsDuringRead(existingState ListDbfsRequest) { +} + // List directory contents type ListDirectoryContentsRequest struct { // The absolute path of a directory. @@ -188,6 +326,12 @@ type ListDirectoryContentsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListDirectoryContentsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListDirectoryContentsRequest) { +} + +func (newState *ListDirectoryContentsRequest) SyncEffectiveFieldsDuringRead(existingState ListDirectoryContentsRequest) { +} + type ListDirectoryResponse struct { // Array of DirectoryEntry. Contents []DirectoryEntry `tfsdk:"contents" tf:"optional"` @@ -195,20 +339,44 @@ type ListDirectoryResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListDirectoryResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListDirectoryResponse) { +} + +func (newState *ListDirectoryResponse) SyncEffectiveFieldsDuringRead(existingState ListDirectoryResponse) { +} + type ListStatusResponse struct { // A list of FileInfo's that describe contents of directory or file. See // example above. Files []FileInfo `tfsdk:"files" tf:"optional"` } +func (newState *ListStatusResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListStatusResponse) { +} + +func (newState *ListStatusResponse) SyncEffectiveFieldsDuringRead(existingState ListStatusResponse) { +} + type MkDirs struct { // The path of the new directory. The path should be the absolute DBFS path. Path types.String `tfsdk:"path" tf:""` } +func (newState *MkDirs) SyncEffectiveFieldsDuringCreateOrUpdate(plan MkDirs) { +} + +func (newState *MkDirs) SyncEffectiveFieldsDuringRead(existingState MkDirs) { +} + type MkDirsResponse struct { } +func (newState *MkDirsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan MkDirsResponse) { +} + +func (newState *MkDirsResponse) SyncEffectiveFieldsDuringRead(existingState MkDirsResponse) { +} + type Move struct { // The destination path of the file or directory. The path should be the // absolute DBFS path. @@ -218,9 +386,21 @@ type Move struct { SourcePath types.String `tfsdk:"source_path" tf:""` } +func (newState *Move) SyncEffectiveFieldsDuringCreateOrUpdate(plan Move) { +} + +func (newState *Move) SyncEffectiveFieldsDuringRead(existingState Move) { +} + type MoveResponse struct { } +func (newState *MoveResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan MoveResponse) { +} + +func (newState *MoveResponse) SyncEffectiveFieldsDuringRead(existingState MoveResponse) { +} + type Put struct { // This parameter might be absent, and instead a posted file will be used. Contents types.String `tfsdk:"contents" tf:"optional"` @@ -230,9 +410,21 @@ type Put struct { Path types.String `tfsdk:"path" tf:""` } +func (newState *Put) SyncEffectiveFieldsDuringCreateOrUpdate(plan Put) { +} + +func (newState *Put) SyncEffectiveFieldsDuringRead(existingState Put) { +} + type PutResponse struct { } +func (newState *PutResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PutResponse) { +} + +func (newState *PutResponse) SyncEffectiveFieldsDuringRead(existingState PutResponse) { +} + // Get the contents of a file type ReadDbfsRequest struct { // The number of bytes to read starting from the offset. This has a limit of @@ -244,6 +436,12 @@ type ReadDbfsRequest struct { Path types.String `tfsdk:"-"` } +func (newState *ReadDbfsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ReadDbfsRequest) { +} + +func (newState *ReadDbfsRequest) SyncEffectiveFieldsDuringRead(existingState ReadDbfsRequest) { +} + type ReadResponse struct { // The number of bytes read (could be less than ``length`` if we hit end of // file). This refers to number of bytes read in unencoded version (response @@ -253,6 +451,12 @@ type ReadResponse struct { Data types.String `tfsdk:"data" tf:"optional"` } +func (newState *ReadResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ReadResponse) { +} + +func (newState *ReadResponse) SyncEffectiveFieldsDuringRead(existingState ReadResponse) { +} + // Upload a file type UploadRequest struct { Contents io.ReadCloser `tfsdk:"-"` @@ -262,5 +466,17 @@ type UploadRequest struct { Overwrite types.Bool `tfsdk:"-"` } +func (newState *UploadRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UploadRequest) { +} + +func (newState *UploadRequest) SyncEffectiveFieldsDuringRead(existingState UploadRequest) { +} + type UploadResponse struct { } + +func (newState *UploadResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UploadResponse) { +} + +func (newState *UploadResponse) SyncEffectiveFieldsDuringRead(existingState UploadResponse) { +} diff --git a/internal/service/iam_tf/model.go b/internal/service/iam_tf/model.go index 7eee548409..f4541fec02 100755 --- a/internal/service/iam_tf/model.go +++ b/internal/service/iam_tf/model.go @@ -25,6 +25,12 @@ type AccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *AccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccessControlRequest) { +} + +func (newState *AccessControlRequest) SyncEffectiveFieldsDuringRead(existingState AccessControlRequest) { +} + type AccessControlResponse struct { // All permissions. AllPermissions []Permission `tfsdk:"all_permissions" tf:"optional"` @@ -38,6 +44,12 @@ type AccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *AccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccessControlResponse) { +} + +func (newState *AccessControlResponse) SyncEffectiveFieldsDuringRead(existingState AccessControlResponse) { +} + type ComplexValue struct { Display types.String `tfsdk:"display" tf:"optional"` @@ -50,45 +62,93 @@ type ComplexValue struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *ComplexValue) SyncEffectiveFieldsDuringCreateOrUpdate(plan ComplexValue) { +} + +func (newState *ComplexValue) SyncEffectiveFieldsDuringRead(existingState ComplexValue) { +} + // Delete a group type DeleteAccountGroupRequest struct { // Unique ID for a group in the Databricks account. Id types.String `tfsdk:"-"` } +func (newState *DeleteAccountGroupRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAccountGroupRequest) { +} + +func (newState *DeleteAccountGroupRequest) SyncEffectiveFieldsDuringRead(existingState DeleteAccountGroupRequest) { +} + // Delete a service principal type DeleteAccountServicePrincipalRequest struct { // Unique ID for a service principal in the Databricks account. Id types.String `tfsdk:"-"` } +func (newState *DeleteAccountServicePrincipalRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAccountServicePrincipalRequest) { +} + +func (newState *DeleteAccountServicePrincipalRequest) SyncEffectiveFieldsDuringRead(existingState DeleteAccountServicePrincipalRequest) { +} + // Delete a user type DeleteAccountUserRequest struct { // Unique ID for a user in the Databricks account. Id types.String `tfsdk:"-"` } +func (newState *DeleteAccountUserRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAccountUserRequest) { +} + +func (newState *DeleteAccountUserRequest) SyncEffectiveFieldsDuringRead(existingState DeleteAccountUserRequest) { +} + // Delete a group type DeleteGroupRequest struct { // Unique ID for a group in the Databricks workspace. Id types.String `tfsdk:"-"` } +func (newState *DeleteGroupRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteGroupRequest) { +} + +func (newState *DeleteGroupRequest) SyncEffectiveFieldsDuringRead(existingState DeleteGroupRequest) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + // Delete a service principal type DeleteServicePrincipalRequest struct { // Unique ID for a service principal in the Databricks workspace. Id types.String `tfsdk:"-"` } +func (newState *DeleteServicePrincipalRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteServicePrincipalRequest) { +} + +func (newState *DeleteServicePrincipalRequest) SyncEffectiveFieldsDuringRead(existingState DeleteServicePrincipalRequest) { +} + // Delete a user type DeleteUserRequest struct { // Unique ID for a user in the Databricks workspace. Id types.String `tfsdk:"-"` } +func (newState *DeleteUserRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteUserRequest) { +} + +func (newState *DeleteUserRequest) SyncEffectiveFieldsDuringRead(existingState DeleteUserRequest) { +} + // Delete permissions assignment type DeleteWorkspaceAssignmentRequest struct { // The ID of the user, service principal, or group. @@ -97,21 +157,45 @@ type DeleteWorkspaceAssignmentRequest struct { WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *DeleteWorkspaceAssignmentRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteWorkspaceAssignmentRequest) { +} + +func (newState *DeleteWorkspaceAssignmentRequest) SyncEffectiveFieldsDuringRead(existingState DeleteWorkspaceAssignmentRequest) { +} + type DeleteWorkspacePermissionAssignmentResponse struct { } +func (newState *DeleteWorkspacePermissionAssignmentResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteWorkspacePermissionAssignmentResponse) { +} + +func (newState *DeleteWorkspacePermissionAssignmentResponse) SyncEffectiveFieldsDuringRead(existingState DeleteWorkspacePermissionAssignmentResponse) { +} + // Get group details type GetAccountGroupRequest struct { // Unique ID for a group in the Databricks account. Id types.String `tfsdk:"-"` } +func (newState *GetAccountGroupRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAccountGroupRequest) { +} + +func (newState *GetAccountGroupRequest) SyncEffectiveFieldsDuringRead(existingState GetAccountGroupRequest) { +} + // Get service principal details type GetAccountServicePrincipalRequest struct { // Unique ID for a service principal in the Databricks account. Id types.String `tfsdk:"-"` } +func (newState *GetAccountServicePrincipalRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAccountServicePrincipalRequest) { +} + +func (newState *GetAccountServicePrincipalRequest) SyncEffectiveFieldsDuringRead(existingState GetAccountServicePrincipalRequest) { +} + // Get user details type GetAccountUserRequest struct { // Comma-separated list of attributes to return in response. @@ -139,27 +223,57 @@ type GetAccountUserRequest struct { StartIndex types.Int64 `tfsdk:"-"` } +func (newState *GetAccountUserRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAccountUserRequest) { +} + +func (newState *GetAccountUserRequest) SyncEffectiveFieldsDuringRead(existingState GetAccountUserRequest) { +} + // Get assignable roles for a resource type GetAssignableRolesForResourceRequest struct { // The resource name for which assignable roles will be listed. Resource types.String `tfsdk:"-"` } +func (newState *GetAssignableRolesForResourceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAssignableRolesForResourceRequest) { +} + +func (newState *GetAssignableRolesForResourceRequest) SyncEffectiveFieldsDuringRead(existingState GetAssignableRolesForResourceRequest) { +} + type GetAssignableRolesForResourceResponse struct { Roles []Role `tfsdk:"roles" tf:"optional"` } +func (newState *GetAssignableRolesForResourceResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAssignableRolesForResourceResponse) { +} + +func (newState *GetAssignableRolesForResourceResponse) SyncEffectiveFieldsDuringRead(existingState GetAssignableRolesForResourceResponse) { +} + // Get group details type GetGroupRequest struct { // Unique ID for a group in the Databricks workspace. Id types.String `tfsdk:"-"` } +func (newState *GetGroupRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetGroupRequest) { +} + +func (newState *GetGroupRequest) SyncEffectiveFieldsDuringRead(existingState GetGroupRequest) { +} + type GetPasswordPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []PasswordPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetPasswordPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPasswordPermissionLevelsResponse) { +} + +func (newState *GetPasswordPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetPasswordPermissionLevelsResponse) { +} + // Get object permission levels type GetPermissionLevelsRequest struct { // @@ -168,11 +282,23 @@ type GetPermissionLevelsRequest struct { RequestObjectType types.String `tfsdk:"-"` } +func (newState *GetPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPermissionLevelsRequest) { +} + +func (newState *GetPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetPermissionLevelsRequest) { +} + type GetPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []PermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPermissionLevelsResponse) { +} + +func (newState *GetPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetPermissionLevelsResponse) { +} + // Get object permissions type GetPermissionRequest struct { // The id of the request object. @@ -185,6 +311,12 @@ type GetPermissionRequest struct { RequestObjectType types.String `tfsdk:"-"` } +func (newState *GetPermissionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPermissionRequest) { +} + +func (newState *GetPermissionRequest) SyncEffectiveFieldsDuringRead(existingState GetPermissionRequest) { +} + // Get a rule set type GetRuleSetRequest struct { // Etag used for versioning. The response is at least as fresh as the eTag @@ -200,12 +332,24 @@ type GetRuleSetRequest struct { Name types.String `tfsdk:"-"` } +func (newState *GetRuleSetRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRuleSetRequest) { +} + +func (newState *GetRuleSetRequest) SyncEffectiveFieldsDuringRead(existingState GetRuleSetRequest) { +} + // Get service principal details type GetServicePrincipalRequest struct { // Unique ID for a service principal in the Databricks workspace. Id types.String `tfsdk:"-"` } +func (newState *GetServicePrincipalRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetServicePrincipalRequest) { +} + +func (newState *GetServicePrincipalRequest) SyncEffectiveFieldsDuringRead(existingState GetServicePrincipalRequest) { +} + // Get user details type GetUserRequest struct { // Comma-separated list of attributes to return in response. @@ -233,12 +377,24 @@ type GetUserRequest struct { StartIndex types.Int64 `tfsdk:"-"` } +func (newState *GetUserRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetUserRequest) { +} + +func (newState *GetUserRequest) SyncEffectiveFieldsDuringRead(existingState GetUserRequest) { +} + // List workspace permissions type GetWorkspaceAssignmentRequest struct { // The workspace ID. WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *GetWorkspaceAssignmentRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWorkspaceAssignmentRequest) { +} + +func (newState *GetWorkspaceAssignmentRequest) SyncEffectiveFieldsDuringRead(existingState GetWorkspaceAssignmentRequest) { +} + type GrantRule struct { // Principals this grant rule applies to. Principals []types.String `tfsdk:"principals" tf:"optional"` @@ -246,6 +402,12 @@ type GrantRule struct { Role types.String `tfsdk:"role" tf:""` } +func (newState *GrantRule) SyncEffectiveFieldsDuringCreateOrUpdate(plan GrantRule) { +} + +func (newState *GrantRule) SyncEffectiveFieldsDuringRead(existingState GrantRule) { +} + type Group struct { // String that represents a human-readable group name DisplayName types.String `tfsdk:"displayName" tf:"optional"` @@ -270,6 +432,12 @@ type Group struct { Schemas []types.String `tfsdk:"schemas" tf:"optional"` } +func (newState *Group) SyncEffectiveFieldsDuringCreateOrUpdate(plan Group) { +} + +func (newState *Group) SyncEffectiveFieldsDuringRead(existingState Group) { +} + // List group details type ListAccountGroupsRequest struct { // Comma-separated list of attributes to return in response. @@ -294,6 +462,12 @@ type ListAccountGroupsRequest struct { StartIndex types.Int64 `tfsdk:"-"` } +func (newState *ListAccountGroupsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAccountGroupsRequest) { +} + +func (newState *ListAccountGroupsRequest) SyncEffectiveFieldsDuringRead(existingState ListAccountGroupsRequest) { +} + // List service principals type ListAccountServicePrincipalsRequest struct { // Comma-separated list of attributes to return in response. @@ -318,6 +492,12 @@ type ListAccountServicePrincipalsRequest struct { StartIndex types.Int64 `tfsdk:"-"` } +func (newState *ListAccountServicePrincipalsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAccountServicePrincipalsRequest) { +} + +func (newState *ListAccountServicePrincipalsRequest) SyncEffectiveFieldsDuringRead(existingState ListAccountServicePrincipalsRequest) { +} + // List users type ListAccountUsersRequest struct { // Comma-separated list of attributes to return in response. @@ -343,6 +523,12 @@ type ListAccountUsersRequest struct { StartIndex types.Int64 `tfsdk:"-"` } +func (newState *ListAccountUsersRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAccountUsersRequest) { +} + +func (newState *ListAccountUsersRequest) SyncEffectiveFieldsDuringRead(existingState ListAccountUsersRequest) { +} + // List group details type ListGroupsRequest struct { // Comma-separated list of attributes to return in response. @@ -367,6 +553,12 @@ type ListGroupsRequest struct { StartIndex types.Int64 `tfsdk:"-"` } +func (newState *ListGroupsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListGroupsRequest) { +} + +func (newState *ListGroupsRequest) SyncEffectiveFieldsDuringRead(existingState ListGroupsRequest) { +} + type ListGroupsResponse struct { // Total results returned in the response. ItemsPerPage types.Int64 `tfsdk:"itemsPerPage" tf:"optional"` @@ -381,6 +573,12 @@ type ListGroupsResponse struct { TotalResults types.Int64 `tfsdk:"totalResults" tf:"optional"` } +func (newState *ListGroupsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListGroupsResponse) { +} + +func (newState *ListGroupsResponse) SyncEffectiveFieldsDuringRead(existingState ListGroupsResponse) { +} + type ListServicePrincipalResponse struct { // Total results returned in the response. ItemsPerPage types.Int64 `tfsdk:"itemsPerPage" tf:"optional"` @@ -395,6 +593,12 @@ type ListServicePrincipalResponse struct { TotalResults types.Int64 `tfsdk:"totalResults" tf:"optional"` } +func (newState *ListServicePrincipalResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListServicePrincipalResponse) { +} + +func (newState *ListServicePrincipalResponse) SyncEffectiveFieldsDuringRead(existingState ListServicePrincipalResponse) { +} + // List service principals type ListServicePrincipalsRequest struct { // Comma-separated list of attributes to return in response. @@ -419,6 +623,12 @@ type ListServicePrincipalsRequest struct { StartIndex types.Int64 `tfsdk:"-"` } +func (newState *ListServicePrincipalsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListServicePrincipalsRequest) { +} + +func (newState *ListServicePrincipalsRequest) SyncEffectiveFieldsDuringRead(existingState ListServicePrincipalsRequest) { +} + // List users type ListUsersRequest struct { // Comma-separated list of attributes to return in response. @@ -444,6 +654,12 @@ type ListUsersRequest struct { StartIndex types.Int64 `tfsdk:"-"` } +func (newState *ListUsersRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListUsersRequest) { +} + +func (newState *ListUsersRequest) SyncEffectiveFieldsDuringRead(existingState ListUsersRequest) { +} + type ListUsersResponse struct { // Total results returned in the response. ItemsPerPage types.Int64 `tfsdk:"itemsPerPage" tf:"optional"` @@ -458,12 +674,24 @@ type ListUsersResponse struct { TotalResults types.Int64 `tfsdk:"totalResults" tf:"optional"` } +func (newState *ListUsersResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListUsersResponse) { +} + +func (newState *ListUsersResponse) SyncEffectiveFieldsDuringRead(existingState ListUsersResponse) { +} + // Get permission assignments type ListWorkspaceAssignmentRequest struct { // The workspace ID for the account. WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *ListWorkspaceAssignmentRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListWorkspaceAssignmentRequest) { +} + +func (newState *ListWorkspaceAssignmentRequest) SyncEffectiveFieldsDuringRead(existingState ListWorkspaceAssignmentRequest) { +} + type MigratePermissionsRequest struct { // The name of the workspace group that permissions will be migrated from. FromWorkspaceGroupName types.String `tfsdk:"from_workspace_group_name" tf:""` @@ -476,11 +704,23 @@ type MigratePermissionsRequest struct { WorkspaceId types.Int64 `tfsdk:"workspace_id" tf:""` } +func (newState *MigratePermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan MigratePermissionsRequest) { +} + +func (newState *MigratePermissionsRequest) SyncEffectiveFieldsDuringRead(existingState MigratePermissionsRequest) { +} + type MigratePermissionsResponse struct { // Number of permissions migrated. PermissionsMigrated types.Int64 `tfsdk:"permissions_migrated" tf:"optional"` } +func (newState *MigratePermissionsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan MigratePermissionsResponse) { +} + +func (newState *MigratePermissionsResponse) SyncEffectiveFieldsDuringRead(existingState MigratePermissionsResponse) { +} + type Name struct { // Family name of the Databricks user. FamilyName types.String `tfsdk:"familyName" tf:"optional"` @@ -488,6 +728,12 @@ type Name struct { GivenName types.String `tfsdk:"givenName" tf:"optional"` } +func (newState *Name) SyncEffectiveFieldsDuringCreateOrUpdate(plan Name) { +} + +func (newState *Name) SyncEffectiveFieldsDuringRead(existingState Name) { +} + type ObjectPermissions struct { AccessControlList []AccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -496,6 +742,12 @@ type ObjectPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *ObjectPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan ObjectPermissions) { +} + +func (newState *ObjectPermissions) SyncEffectiveFieldsDuringRead(existingState ObjectPermissions) { +} + type PartialUpdate struct { // Unique ID for a user in the Databricks workspace. Id types.String `tfsdk:"-"` @@ -506,6 +758,12 @@ type PartialUpdate struct { Schemas []types.String `tfsdk:"schemas" tf:"optional"` } +func (newState *PartialUpdate) SyncEffectiveFieldsDuringCreateOrUpdate(plan PartialUpdate) { +} + +func (newState *PartialUpdate) SyncEffectiveFieldsDuringRead(existingState PartialUpdate) { +} + type PasswordAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -517,6 +775,12 @@ type PasswordAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *PasswordAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan PasswordAccessControlRequest) { +} + +func (newState *PasswordAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState PasswordAccessControlRequest) { +} + type PasswordAccessControlResponse struct { // All permissions. AllPermissions []PasswordPermission `tfsdk:"all_permissions" tf:"optional"` @@ -530,6 +794,12 @@ type PasswordAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *PasswordAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PasswordAccessControlResponse) { +} + +func (newState *PasswordAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState PasswordAccessControlResponse) { +} + type PasswordPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -538,6 +808,12 @@ type PasswordPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *PasswordPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan PasswordPermission) { +} + +func (newState *PasswordPermission) SyncEffectiveFieldsDuringRead(existingState PasswordPermission) { +} + type PasswordPermissions struct { AccessControlList []PasswordAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -546,16 +822,34 @@ type PasswordPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *PasswordPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan PasswordPermissions) { +} + +func (newState *PasswordPermissions) SyncEffectiveFieldsDuringRead(existingState PasswordPermissions) { +} + type PasswordPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *PasswordPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan PasswordPermissionsDescription) { +} + +func (newState *PasswordPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState PasswordPermissionsDescription) { +} + type PasswordPermissionsRequest struct { AccessControlList []PasswordAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` } +func (newState *PasswordPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan PasswordPermissionsRequest) { +} + +func (newState *PasswordPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState PasswordPermissionsRequest) { +} + type Patch struct { // Type of patch operation. Op types.String `tfsdk:"op" tf:"optional"` @@ -565,9 +859,21 @@ type Patch struct { Value any `tfsdk:"value" tf:"optional"` } +func (newState *Patch) SyncEffectiveFieldsDuringCreateOrUpdate(plan Patch) { +} + +func (newState *Patch) SyncEffectiveFieldsDuringRead(existingState Patch) { +} + type PatchResponse struct { } +func (newState *PatchResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PatchResponse) { +} + +func (newState *PatchResponse) SyncEffectiveFieldsDuringRead(existingState PatchResponse) { +} + type Permission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -576,6 +882,12 @@ type Permission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *Permission) SyncEffectiveFieldsDuringCreateOrUpdate(plan Permission) { +} + +func (newState *Permission) SyncEffectiveFieldsDuringRead(existingState Permission) { +} + // The output format for existing workspace PermissionAssignment records, which // contains some info for user consumption. type PermissionAssignment struct { @@ -587,11 +899,23 @@ type PermissionAssignment struct { Principal []PrincipalOutput `tfsdk:"principal" tf:"optional,object"` } +func (newState *PermissionAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan PermissionAssignment) { +} + +func (newState *PermissionAssignment) SyncEffectiveFieldsDuringRead(existingState PermissionAssignment) { +} + type PermissionAssignments struct { // Array of permissions assignments defined for a workspace. PermissionAssignments []PermissionAssignment `tfsdk:"permission_assignments" tf:"optional"` } +func (newState *PermissionAssignments) SyncEffectiveFieldsDuringCreateOrUpdate(plan PermissionAssignments) { +} + +func (newState *PermissionAssignments) SyncEffectiveFieldsDuringRead(existingState PermissionAssignments) { +} + type PermissionOutput struct { // The results of a permissions query. Description types.String `tfsdk:"description" tf:"optional"` @@ -599,12 +923,24 @@ type PermissionOutput struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *PermissionOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan PermissionOutput) { +} + +func (newState *PermissionOutput) SyncEffectiveFieldsDuringRead(existingState PermissionOutput) { +} + type PermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *PermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan PermissionsDescription) { +} + +func (newState *PermissionsDescription) SyncEffectiveFieldsDuringRead(existingState PermissionsDescription) { +} + type PermissionsRequest struct { AccessControlList []AccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The id of the request object. @@ -617,6 +953,12 @@ type PermissionsRequest struct { RequestObjectType types.String `tfsdk:"-"` } +func (newState *PermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan PermissionsRequest) { +} + +func (newState *PermissionsRequest) SyncEffectiveFieldsDuringRead(existingState PermissionsRequest) { +} + // Information about the principal assigned to the workspace. type PrincipalOutput struct { // The display name of the principal. @@ -632,17 +974,35 @@ type PrincipalOutput struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *PrincipalOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan PrincipalOutput) { +} + +func (newState *PrincipalOutput) SyncEffectiveFieldsDuringRead(existingState PrincipalOutput) { +} + type ResourceMeta struct { // Identifier for group type. Can be local workspace group // (`WorkspaceGroup`) or account group (`Group`). ResourceType types.String `tfsdk:"resourceType" tf:"optional"` } +func (newState *ResourceMeta) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResourceMeta) { +} + +func (newState *ResourceMeta) SyncEffectiveFieldsDuringRead(existingState ResourceMeta) { +} + type Role struct { // Role to assign to a principal or a list of principals on a resource. Name types.String `tfsdk:"name" tf:""` } +func (newState *Role) SyncEffectiveFieldsDuringCreateOrUpdate(plan Role) { +} + +func (newState *Role) SyncEffectiveFieldsDuringRead(existingState Role) { +} + type RuleSetResponse struct { // Identifies the version of the rule set returned. Etag types.String `tfsdk:"etag" tf:"optional"` @@ -652,6 +1012,12 @@ type RuleSetResponse struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *RuleSetResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RuleSetResponse) { +} + +func (newState *RuleSetResponse) SyncEffectiveFieldsDuringRead(existingState RuleSetResponse) { +} + type RuleSetUpdateRequest struct { // The expected etag of the rule set to update. The update will fail if the // value does not match the value that is stored in account access control @@ -663,6 +1029,12 @@ type RuleSetUpdateRequest struct { Name types.String `tfsdk:"name" tf:""` } +func (newState *RuleSetUpdateRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RuleSetUpdateRequest) { +} + +func (newState *RuleSetUpdateRequest) SyncEffectiveFieldsDuringRead(existingState RuleSetUpdateRequest) { +} + type ServicePrincipal struct { // If this user is active Active types.Bool `tfsdk:"active" tf:"optional"` @@ -687,9 +1059,21 @@ type ServicePrincipal struct { Schemas []types.String `tfsdk:"schemas" tf:"optional"` } +func (newState *ServicePrincipal) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServicePrincipal) { +} + +func (newState *ServicePrincipal) SyncEffectiveFieldsDuringRead(existingState ServicePrincipal) { +} + type UpdateResponse struct { } +func (newState *UpdateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateResponse) { +} + +func (newState *UpdateResponse) SyncEffectiveFieldsDuringRead(existingState UpdateResponse) { +} + type UpdateRuleSetRequest struct { // Name of the rule set. Name types.String `tfsdk:"name" tf:""` @@ -697,6 +1081,12 @@ type UpdateRuleSetRequest struct { RuleSet []RuleSetUpdateRequest `tfsdk:"rule_set" tf:"object"` } +func (newState *UpdateRuleSetRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateRuleSetRequest) { +} + +func (newState *UpdateRuleSetRequest) SyncEffectiveFieldsDuringRead(existingState UpdateRuleSetRequest) { +} + type UpdateWorkspaceAssignments struct { // Array of permissions assignments to update on the workspace. Valid values // are "USER" and "ADMIN" (case-sensitive). If both "USER" and "ADMIN" are @@ -711,6 +1101,12 @@ type UpdateWorkspaceAssignments struct { WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *UpdateWorkspaceAssignments) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateWorkspaceAssignments) { +} + +func (newState *UpdateWorkspaceAssignments) SyncEffectiveFieldsDuringRead(existingState UpdateWorkspaceAssignments) { +} + type User struct { // If this user is active Active types.Bool `tfsdk:"active" tf:"optional"` @@ -745,7 +1141,19 @@ type User struct { UserName types.String `tfsdk:"userName" tf:"optional"` } +func (newState *User) SyncEffectiveFieldsDuringCreateOrUpdate(plan User) { +} + +func (newState *User) SyncEffectiveFieldsDuringRead(existingState User) { +} + type WorkspacePermissions struct { // Array of permissions defined for a workspace. Permissions []PermissionOutput `tfsdk:"permissions" tf:"optional"` } + +func (newState *WorkspacePermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkspacePermissions) { +} + +func (newState *WorkspacePermissions) SyncEffectiveFieldsDuringRead(existingState WorkspacePermissions) { +} diff --git a/internal/service/jobs_tf/model.go b/internal/service/jobs_tf/model.go index d2544ac0d0..35f110fbe2 100755 --- a/internal/service/jobs_tf/model.go +++ b/internal/service/jobs_tf/model.go @@ -22,6 +22,14 @@ type BaseJob struct { // The creator user name. This field won’t be included in the response if // the user has already been deleted. CreatorUserName types.String `tfsdk:"creator_user_name" tf:"optional"` + // The id of the budget policy used by this job for cost attribution + // purposes. This may be set through (in order of precedence): 1. Budget + // admins through the account or workspace console 2. Jobs UI in the job + // details page and Jobs API using `budget_policy_id` 3. Inferred default + // based on accessible budget policies of the run_as identity on job + // creation or modification. + EffectiveBudgetPolicyId types.String `tfsdk:"effective_budget_policy_id" tf:"optional"` + EffectiveEffectiveBudgetPolicyId types.String `tfsdk:"effective_effective_budget_policy_id" tf:"computed,optional"` // The canonical identifier for this job. JobId types.Int64 `tfsdk:"job_id" tf:"optional"` // Settings for this job and all of its runs. These settings can be updated @@ -29,6 +37,17 @@ type BaseJob struct { Settings []JobSettings `tfsdk:"settings" tf:"optional,object"` } +func (newState *BaseJob) SyncEffectiveFieldsDuringCreateOrUpdate(plan BaseJob) { + newState.EffectiveEffectiveBudgetPolicyId = newState.EffectiveBudgetPolicyId + newState.EffectiveBudgetPolicyId = plan.EffectiveBudgetPolicyId +} + +func (newState *BaseJob) SyncEffectiveFieldsDuringRead(existingState BaseJob) { + if existingState.EffectiveEffectiveBudgetPolicyId.ValueString() == newState.EffectiveBudgetPolicyId.ValueString() { + newState.EffectiveBudgetPolicyId = existingState.EffectiveBudgetPolicyId + } +} + type BaseRun struct { // The sequence number of this run attempt for a triggered job run. The // initial attempt of a run has an attempt_number of 0. If the initial run @@ -159,6 +178,12 @@ type BaseRun struct { TriggerInfo []TriggerInfo `tfsdk:"trigger_info" tf:"optional,object"` } +func (newState *BaseRun) SyncEffectiveFieldsDuringCreateOrUpdate(plan BaseRun) { +} + +func (newState *BaseRun) SyncEffectiveFieldsDuringRead(existingState BaseRun) { +} + type CancelAllRuns struct { // Optional boolean parameter to cancel all queued runs. If no job_id is // provided, all queued runs in the workspace are canceled. @@ -167,17 +192,41 @@ type CancelAllRuns struct { JobId types.Int64 `tfsdk:"job_id" tf:"optional"` } +func (newState *CancelAllRuns) SyncEffectiveFieldsDuringCreateOrUpdate(plan CancelAllRuns) { +} + +func (newState *CancelAllRuns) SyncEffectiveFieldsDuringRead(existingState CancelAllRuns) { +} + type CancelAllRunsResponse struct { } +func (newState *CancelAllRunsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CancelAllRunsResponse) { +} + +func (newState *CancelAllRunsResponse) SyncEffectiveFieldsDuringRead(existingState CancelAllRunsResponse) { +} + type CancelRun struct { // This field is required. RunId types.Int64 `tfsdk:"run_id" tf:""` } +func (newState *CancelRun) SyncEffectiveFieldsDuringCreateOrUpdate(plan CancelRun) { +} + +func (newState *CancelRun) SyncEffectiveFieldsDuringRead(existingState CancelRun) { +} + type CancelRunResponse struct { } +func (newState *CancelRunResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CancelRunResponse) { +} + +func (newState *CancelRunResponse) SyncEffectiveFieldsDuringRead(existingState CancelRunResponse) { +} + type ClusterInstance struct { // The canonical identifier for the cluster used by a run. This field is // always available for runs on existing clusters. For runs on new clusters, @@ -199,6 +248,12 @@ type ClusterInstance struct { SparkContextId types.String `tfsdk:"spark_context_id" tf:"optional"` } +func (newState *ClusterInstance) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterInstance) { +} + +func (newState *ClusterInstance) SyncEffectiveFieldsDuringRead(existingState ClusterInstance) { +} + type ClusterSpec struct { // If existing_cluster_id, the ID of an existing cluster that is used for // all runs. When running jobs or tasks on an existing cluster, you may need @@ -216,6 +271,12 @@ type ClusterSpec struct { NewCluster compute.ClusterSpec `tfsdk:"new_cluster" tf:"optional,object"` } +func (newState *ClusterSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterSpec) { +} + +func (newState *ClusterSpec) SyncEffectiveFieldsDuringRead(existingState ClusterSpec) { +} + type ConditionTask struct { // The left operand of the condition task. Can be either a string value or a // job state or parameter reference. @@ -236,15 +297,32 @@ type ConditionTask struct { Right types.String `tfsdk:"right" tf:""` } +func (newState *ConditionTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan ConditionTask) { +} + +func (newState *ConditionTask) SyncEffectiveFieldsDuringRead(existingState ConditionTask) { +} + type Continuous struct { // Indicate whether the continuous execution of the job is paused or not. // Defaults to UNPAUSED. PauseStatus types.String `tfsdk:"pause_status" tf:"optional"` } +func (newState *Continuous) SyncEffectiveFieldsDuringCreateOrUpdate(plan Continuous) { +} + +func (newState *Continuous) SyncEffectiveFieldsDuringRead(existingState Continuous) { +} + type CreateJob struct { // List of permissions to set on the job. AccessControlList []JobAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` + // The id of the user specified budget policy to use for this job. If not + // specified, a default budget policy may be applied when creating or + // modifying the job. See `effective_budget_policy_id` for the budget policy + // used by this workload. + BudgetPolicyId types.String `tfsdk:"budget_policy_id" tf:"optional"` // An optional continuous property for this job. The continuous property // will ensure that there is always one run executing. Only one of // `schedule` and `continuous` can be used. @@ -343,12 +421,24 @@ type CreateJob struct { WebhookNotifications []WebhookNotifications `tfsdk:"webhook_notifications" tf:"optional,object"` } +func (newState *CreateJob) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateJob) { +} + +func (newState *CreateJob) SyncEffectiveFieldsDuringRead(existingState CreateJob) { +} + // Job was created successfully type CreateResponse struct { // The canonical identifier for the newly created job. JobId types.Int64 `tfsdk:"job_id" tf:"optional"` } +func (newState *CreateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateResponse) { +} + +func (newState *CreateResponse) SyncEffectiveFieldsDuringRead(existingState CreateResponse) { +} + type CronSchedule struct { // Indicate whether this schedule is paused or not. PauseStatus types.String `tfsdk:"pause_status" tf:"optional"` @@ -364,6 +454,12 @@ type CronSchedule struct { TimezoneId types.String `tfsdk:"timezone_id" tf:""` } +func (newState *CronSchedule) SyncEffectiveFieldsDuringCreateOrUpdate(plan CronSchedule) { +} + +func (newState *CronSchedule) SyncEffectiveFieldsDuringRead(existingState CronSchedule) { +} + type DbtOutput struct { // An optional map of headers to send when retrieving the artifact from the // `artifacts_link`. @@ -374,6 +470,12 @@ type DbtOutput struct { ArtifactsLink types.String `tfsdk:"artifacts_link" tf:"optional"` } +func (newState *DbtOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan DbtOutput) { +} + +func (newState *DbtOutput) SyncEffectiveFieldsDuringRead(existingState DbtOutput) { +} + type DbtTask struct { // Optional name of the catalog to use. The value is the top level in the // 3-level namespace of Unity Catalog (catalog / schema / relation). The @@ -411,22 +513,52 @@ type DbtTask struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *DbtTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan DbtTask) { +} + +func (newState *DbtTask) SyncEffectiveFieldsDuringRead(existingState DbtTask) { +} + type DeleteJob struct { // The canonical identifier of the job to delete. This field is required. JobId types.Int64 `tfsdk:"job_id" tf:""` } +func (newState *DeleteJob) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteJob) { +} + +func (newState *DeleteJob) SyncEffectiveFieldsDuringRead(existingState DeleteJob) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + type DeleteRun struct { // ID of the run to delete. RunId types.Int64 `tfsdk:"run_id" tf:""` } +func (newState *DeleteRun) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRun) { +} + +func (newState *DeleteRun) SyncEffectiveFieldsDuringRead(existingState DeleteRun) { +} + type DeleteRunResponse struct { } +func (newState *DeleteRunResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRunResponse) { +} + +func (newState *DeleteRunResponse) SyncEffectiveFieldsDuringRead(existingState DeleteRunResponse) { +} + // Represents a change to the job cluster's settings that would be required for // the job clusters to become compliant with their policies. type EnforcePolicyComplianceForJobResponseJobClusterSettingsChange struct { @@ -445,6 +577,12 @@ type EnforcePolicyComplianceForJobResponseJobClusterSettingsChange struct { PreviousValue types.String `tfsdk:"previous_value" tf:"optional"` } +func (newState *EnforcePolicyComplianceForJobResponseJobClusterSettingsChange) SyncEffectiveFieldsDuringCreateOrUpdate(plan EnforcePolicyComplianceForJobResponseJobClusterSettingsChange) { +} + +func (newState *EnforcePolicyComplianceForJobResponseJobClusterSettingsChange) SyncEffectiveFieldsDuringRead(existingState EnforcePolicyComplianceForJobResponseJobClusterSettingsChange) { +} + type EnforcePolicyComplianceRequest struct { // The ID of the job you want to enforce policy compliance on. JobId types.Int64 `tfsdk:"job_id" tf:""` @@ -453,6 +591,12 @@ type EnforcePolicyComplianceRequest struct { ValidateOnly types.Bool `tfsdk:"validate_only" tf:"optional"` } +func (newState *EnforcePolicyComplianceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan EnforcePolicyComplianceRequest) { +} + +func (newState *EnforcePolicyComplianceRequest) SyncEffectiveFieldsDuringRead(existingState EnforcePolicyComplianceRequest) { +} + type EnforcePolicyComplianceResponse struct { // Whether any changes have been made to the job cluster settings for the // job to become compliant with its policies. @@ -470,6 +614,12 @@ type EnforcePolicyComplianceResponse struct { Settings []JobSettings `tfsdk:"settings" tf:"optional,object"` } +func (newState *EnforcePolicyComplianceResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan EnforcePolicyComplianceResponse) { +} + +func (newState *EnforcePolicyComplianceResponse) SyncEffectiveFieldsDuringRead(existingState EnforcePolicyComplianceResponse) { +} + // Run was exported successfully. type ExportRunOutput struct { // The exported content in HTML format (one for every view item). To extract @@ -480,6 +630,12 @@ type ExportRunOutput struct { Views []ViewItem `tfsdk:"views" tf:"optional"` } +func (newState *ExportRunOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExportRunOutput) { +} + +func (newState *ExportRunOutput) SyncEffectiveFieldsDuringRead(existingState ExportRunOutput) { +} + // Export and retrieve a job run type ExportRunRequest struct { // The canonical identifier for the run. This field is required. @@ -488,6 +644,12 @@ type ExportRunRequest struct { ViewsToExport types.String `tfsdk:"-"` } +func (newState *ExportRunRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExportRunRequest) { +} + +func (newState *ExportRunRequest) SyncEffectiveFieldsDuringRead(existingState ExportRunRequest) { +} + type FileArrivalTriggerConfiguration struct { // If set, the trigger starts a run only after the specified amount of time // passed since the last time the trigger fired. The minimum allowed value @@ -503,6 +665,12 @@ type FileArrivalTriggerConfiguration struct { WaitAfterLastChangeSeconds types.Int64 `tfsdk:"wait_after_last_change_seconds" tf:"optional"` } +func (newState *FileArrivalTriggerConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan FileArrivalTriggerConfiguration) { +} + +func (newState *FileArrivalTriggerConfiguration) SyncEffectiveFieldsDuringRead(existingState FileArrivalTriggerConfiguration) { +} + type ForEachStats struct { // Sample of 3 most common error messages occurred during the iteration. ErrorMessageStats []ForEachTaskErrorMessageStats `tfsdk:"error_message_stats" tf:"optional"` @@ -510,6 +678,12 @@ type ForEachStats struct { TaskRunStats []ForEachTaskTaskRunStats `tfsdk:"task_run_stats" tf:"optional,object"` } +func (newState *ForEachStats) SyncEffectiveFieldsDuringCreateOrUpdate(plan ForEachStats) { +} + +func (newState *ForEachStats) SyncEffectiveFieldsDuringRead(existingState ForEachStats) { +} + type ForEachTask struct { // An optional maximum allowed number of concurrent runs of the task. Set // this value if you want to be able to execute multiple runs of the task @@ -522,6 +696,12 @@ type ForEachTask struct { Task []Task `tfsdk:"task" tf:"object"` } +func (newState *ForEachTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan ForEachTask) { +} + +func (newState *ForEachTask) SyncEffectiveFieldsDuringRead(existingState ForEachTask) { +} + type ForEachTaskErrorMessageStats struct { // Describes the count of such error message encountered during the // iterations. @@ -532,6 +712,12 @@ type ForEachTaskErrorMessageStats struct { TerminationCategory types.String `tfsdk:"termination_category" tf:"optional"` } +func (newState *ForEachTaskErrorMessageStats) SyncEffectiveFieldsDuringCreateOrUpdate(plan ForEachTaskErrorMessageStats) { +} + +func (newState *ForEachTaskErrorMessageStats) SyncEffectiveFieldsDuringRead(existingState ForEachTaskErrorMessageStats) { +} + type ForEachTaskTaskRunStats struct { // Describes the iteration runs having an active lifecycle state or an // active run sub state. @@ -548,23 +734,47 @@ type ForEachTaskTaskRunStats struct { TotalIterations types.Int64 `tfsdk:"total_iterations" tf:"optional"` } +func (newState *ForEachTaskTaskRunStats) SyncEffectiveFieldsDuringCreateOrUpdate(plan ForEachTaskTaskRunStats) { +} + +func (newState *ForEachTaskTaskRunStats) SyncEffectiveFieldsDuringRead(existingState ForEachTaskTaskRunStats) { +} + // Get job permission levels type GetJobPermissionLevelsRequest struct { // The job for which to get or manage permissions. JobId types.String `tfsdk:"-"` } +func (newState *GetJobPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetJobPermissionLevelsRequest) { +} + +func (newState *GetJobPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetJobPermissionLevelsRequest) { +} + type GetJobPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []JobPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetJobPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetJobPermissionLevelsResponse) { +} + +func (newState *GetJobPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetJobPermissionLevelsResponse) { +} + // Get job permissions type GetJobPermissionsRequest struct { // The job for which to get or manage permissions. JobId types.String `tfsdk:"-"` } +func (newState *GetJobPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetJobPermissionsRequest) { +} + +func (newState *GetJobPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetJobPermissionsRequest) { +} + // Get a single job type GetJobRequest struct { // The canonical identifier of the job to retrieve information about. This @@ -572,12 +782,24 @@ type GetJobRequest struct { JobId types.Int64 `tfsdk:"-"` } +func (newState *GetJobRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetJobRequest) { +} + +func (newState *GetJobRequest) SyncEffectiveFieldsDuringRead(existingState GetJobRequest) { +} + // Get job policy compliance type GetPolicyComplianceRequest struct { // The ID of the job whose compliance status you are requesting. JobId types.Int64 `tfsdk:"-"` } +func (newState *GetPolicyComplianceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPolicyComplianceRequest) { +} + +func (newState *GetPolicyComplianceRequest) SyncEffectiveFieldsDuringRead(existingState GetPolicyComplianceRequest) { +} + type GetPolicyComplianceResponse struct { // Whether the job is compliant with its policies or not. Jobs could be out // of compliance if a policy they are using was updated after the job was @@ -592,12 +814,24 @@ type GetPolicyComplianceResponse struct { Violations map[string]types.String `tfsdk:"violations" tf:"optional"` } +func (newState *GetPolicyComplianceResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPolicyComplianceResponse) { +} + +func (newState *GetPolicyComplianceResponse) SyncEffectiveFieldsDuringRead(existingState GetPolicyComplianceResponse) { +} + // Get the output for a single run type GetRunOutputRequest struct { // The canonical identifier for the run. RunId types.Int64 `tfsdk:"-"` } +func (newState *GetRunOutputRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRunOutputRequest) { +} + +func (newState *GetRunOutputRequest) SyncEffectiveFieldsDuringRead(existingState GetRunOutputRequest) { +} + // Get a single job run type GetRunRequest struct { // Whether to include the repair history in the response. @@ -613,6 +847,12 @@ type GetRunRequest struct { RunId types.Int64 `tfsdk:"-"` } +func (newState *GetRunRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRunRequest) { +} + +func (newState *GetRunRequest) SyncEffectiveFieldsDuringRead(existingState GetRunRequest) { +} + // Read-only state of the remote repository at the time the job was run. This // field is only included on job runs. type GitSnapshot struct { @@ -622,6 +862,12 @@ type GitSnapshot struct { UsedCommit types.String `tfsdk:"used_commit" tf:"optional"` } +func (newState *GitSnapshot) SyncEffectiveFieldsDuringCreateOrUpdate(plan GitSnapshot) { +} + +func (newState *GitSnapshot) SyncEffectiveFieldsDuringRead(existingState GitSnapshot) { +} + // An optional specification for a remote Git repository containing the source // code used by tasks. Version-controlled source code is supported by notebook, // dbt, Python script, and SQL File tasks. @@ -655,6 +901,12 @@ type GitSource struct { JobSource []JobSource `tfsdk:"job_source" tf:"optional,object"` } +func (newState *GitSource) SyncEffectiveFieldsDuringCreateOrUpdate(plan GitSource) { +} + +func (newState *GitSource) SyncEffectiveFieldsDuringRead(existingState GitSource) { +} + // Job was retrieved successfully. type Job struct { // The time at which this job was created in epoch milliseconds @@ -663,6 +915,14 @@ type Job struct { // The creator user name. This field won’t be included in the response if // the user has already been deleted. CreatorUserName types.String `tfsdk:"creator_user_name" tf:"optional"` + // The id of the budget policy used by this job for cost attribution + // purposes. This may be set through (in order of precedence): 1. Budget + // admins through the account or workspace console 2. Jobs UI in the job + // details page and Jobs API using `budget_policy_id` 3. Inferred default + // based on accessible budget policies of the run_as identity on job + // creation or modification. + EffectiveBudgetPolicyId types.String `tfsdk:"effective_budget_policy_id" tf:"optional"` + EffectiveEffectiveBudgetPolicyId types.String `tfsdk:"effective_effective_budget_policy_id" tf:"computed,optional"` // The canonical identifier for this job. JobId types.Int64 `tfsdk:"job_id" tf:"optional"` // The email of an active workspace user or the application ID of a service @@ -678,6 +938,17 @@ type Job struct { Settings []JobSettings `tfsdk:"settings" tf:"optional,object"` } +func (newState *Job) SyncEffectiveFieldsDuringCreateOrUpdate(plan Job) { + newState.EffectiveEffectiveBudgetPolicyId = newState.EffectiveBudgetPolicyId + newState.EffectiveBudgetPolicyId = plan.EffectiveBudgetPolicyId +} + +func (newState *Job) SyncEffectiveFieldsDuringRead(existingState Job) { + if existingState.EffectiveEffectiveBudgetPolicyId.ValueString() == newState.EffectiveBudgetPolicyId.ValueString() { + newState.EffectiveBudgetPolicyId = existingState.EffectiveBudgetPolicyId + } +} + type JobAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -689,6 +960,12 @@ type JobAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *JobAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobAccessControlRequest) { +} + +func (newState *JobAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState JobAccessControlRequest) { +} + type JobAccessControlResponse struct { // All permissions. AllPermissions []JobPermission `tfsdk:"all_permissions" tf:"optional"` @@ -702,6 +979,12 @@ type JobAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *JobAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobAccessControlResponse) { +} + +func (newState *JobAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState JobAccessControlResponse) { +} + type JobCluster struct { // A unique name for the job cluster. This field is required and must be // unique within the job. `JobTaskSettings` may refer to this field to @@ -711,6 +994,12 @@ type JobCluster struct { NewCluster compute.ClusterSpec `tfsdk:"new_cluster" tf:"object"` } +func (newState *JobCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobCluster) { +} + +func (newState *JobCluster) SyncEffectiveFieldsDuringRead(existingState JobCluster) { +} + type JobCompliance struct { // Whether this job is in compliance with the latest version of its policy. IsCompliant types.Bool `tfsdk:"is_compliant" tf:"optional"` @@ -724,6 +1013,12 @@ type JobCompliance struct { Violations map[string]types.String `tfsdk:"violations" tf:"optional"` } +func (newState *JobCompliance) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobCompliance) { +} + +func (newState *JobCompliance) SyncEffectiveFieldsDuringRead(existingState JobCompliance) { +} + type JobDeployment struct { // The kind of deployment that manages the job. // @@ -733,6 +1028,12 @@ type JobDeployment struct { MetadataFilePath types.String `tfsdk:"metadata_file_path" tf:"optional"` } +func (newState *JobDeployment) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobDeployment) { +} + +func (newState *JobDeployment) SyncEffectiveFieldsDuringRead(existingState JobDeployment) { +} + type JobEmailNotifications struct { // If true, do not send email to recipients specified in `on_failure` if the // run is skipped. This field is `deprecated`. Please use the @@ -769,6 +1070,12 @@ type JobEmailNotifications struct { OnSuccess []types.String `tfsdk:"on_success" tf:"optional"` } +func (newState *JobEmailNotifications) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobEmailNotifications) { +} + +func (newState *JobEmailNotifications) SyncEffectiveFieldsDuringRead(existingState JobEmailNotifications) { +} + type JobEnvironment struct { // The key of an environment. It has to be unique within a job. EnvironmentKey types.String `tfsdk:"environment_key" tf:""` @@ -778,6 +1085,12 @@ type JobEnvironment struct { Spec compute.Environment `tfsdk:"spec" tf:"optional,object"` } +func (newState *JobEnvironment) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobEnvironment) { +} + +func (newState *JobEnvironment) SyncEffectiveFieldsDuringRead(existingState JobEnvironment) { +} + type JobNotificationSettings struct { // If true, do not send notifications to recipients specified in // `on_failure` if the run is canceled. @@ -787,6 +1100,12 @@ type JobNotificationSettings struct { NoAlertForSkippedRuns types.Bool `tfsdk:"no_alert_for_skipped_runs" tf:"optional"` } +func (newState *JobNotificationSettings) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobNotificationSettings) { +} + +func (newState *JobNotificationSettings) SyncEffectiveFieldsDuringRead(existingState JobNotificationSettings) { +} + type JobParameter struct { // The optional default value of the parameter Default types.String `tfsdk:"default" tf:"optional"` @@ -796,6 +1115,12 @@ type JobParameter struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *JobParameter) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobParameter) { +} + +func (newState *JobParameter) SyncEffectiveFieldsDuringRead(existingState JobParameter) { +} + type JobParameterDefinition struct { // Default value of the parameter. Default types.String `tfsdk:"default" tf:""` @@ -804,6 +1129,12 @@ type JobParameterDefinition struct { Name types.String `tfsdk:"name" tf:""` } +func (newState *JobParameterDefinition) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobParameterDefinition) { +} + +func (newState *JobParameterDefinition) SyncEffectiveFieldsDuringRead(existingState JobParameterDefinition) { +} + type JobPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -812,6 +1143,12 @@ type JobPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *JobPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobPermission) { +} + +func (newState *JobPermission) SyncEffectiveFieldsDuringRead(existingState JobPermission) { +} + type JobPermissions struct { AccessControlList []JobAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -820,18 +1157,36 @@ type JobPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *JobPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobPermissions) { +} + +func (newState *JobPermissions) SyncEffectiveFieldsDuringRead(existingState JobPermissions) { +} + type JobPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *JobPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobPermissionsDescription) { +} + +func (newState *JobPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState JobPermissionsDescription) { +} + type JobPermissionsRequest struct { AccessControlList []JobAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The job for which to get or manage permissions. JobId types.String `tfsdk:"-"` } +func (newState *JobPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobPermissionsRequest) { +} + +func (newState *JobPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState JobPermissionsRequest) { +} + // Write-only setting. Specifies the user, service principal or group that the // job/pipeline runs as. If not specified, the job/pipeline runs as the user who // created the job/pipeline. @@ -847,7 +1202,18 @@ type JobRunAs struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *JobRunAs) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobRunAs) { +} + +func (newState *JobRunAs) SyncEffectiveFieldsDuringRead(existingState JobRunAs) { +} + type JobSettings struct { + // The id of the user specified budget policy to use for this job. If not + // specified, a default budget policy may be applied when creating or + // modifying the job. See `effective_budget_policy_id` for the budget policy + // used by this workload. + BudgetPolicyId types.String `tfsdk:"budget_policy_id" tf:"optional"` // An optional continuous property for this job. The continuous property // will ensure that there is always one run executing. Only one of // `schedule` and `continuous` can be used. @@ -946,6 +1312,12 @@ type JobSettings struct { WebhookNotifications []WebhookNotifications `tfsdk:"webhook_notifications" tf:"optional,object"` } +func (newState *JobSettings) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobSettings) { +} + +func (newState *JobSettings) SyncEffectiveFieldsDuringRead(existingState JobSettings) { +} + // The source of the job specification in the remote repository when the job is // source controlled. type JobSource struct { @@ -965,6 +1337,12 @@ type JobSource struct { JobConfigPath types.String `tfsdk:"job_config_path" tf:""` } +func (newState *JobSource) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobSource) { +} + +func (newState *JobSource) SyncEffectiveFieldsDuringRead(existingState JobSource) { +} + type JobsHealthRule struct { // Specifies the health metric that is being evaluated for a particular // health rule. @@ -987,11 +1365,23 @@ type JobsHealthRule struct { Value types.Int64 `tfsdk:"value" tf:""` } +func (newState *JobsHealthRule) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobsHealthRule) { +} + +func (newState *JobsHealthRule) SyncEffectiveFieldsDuringRead(existingState JobsHealthRule) { +} + // An optional set of health rules that can be defined for this job. type JobsHealthRules struct { Rules []JobsHealthRule `tfsdk:"rules" tf:"optional"` } +func (newState *JobsHealthRules) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobsHealthRules) { +} + +func (newState *JobsHealthRules) SyncEffectiveFieldsDuringRead(existingState JobsHealthRules) { +} + type ListJobComplianceForPolicyResponse struct { // A list of jobs and their policy compliance statuses. Jobs []JobCompliance `tfsdk:"jobs" tf:"optional"` @@ -1005,6 +1395,12 @@ type ListJobComplianceForPolicyResponse struct { PrevPageToken types.String `tfsdk:"prev_page_token" tf:"optional"` } +func (newState *ListJobComplianceForPolicyResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListJobComplianceForPolicyResponse) { +} + +func (newState *ListJobComplianceForPolicyResponse) SyncEffectiveFieldsDuringRead(existingState ListJobComplianceForPolicyResponse) { +} + // List job policy compliance type ListJobComplianceRequest struct { // Use this field to specify the maximum number of results to be returned by @@ -1018,6 +1414,12 @@ type ListJobComplianceRequest struct { PolicyId types.String `tfsdk:"-"` } +func (newState *ListJobComplianceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListJobComplianceRequest) { +} + +func (newState *ListJobComplianceRequest) SyncEffectiveFieldsDuringRead(existingState ListJobComplianceRequest) { +} + // List jobs type ListJobsRequest struct { // Whether to include task and cluster details in the response. @@ -1036,6 +1438,12 @@ type ListJobsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListJobsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListJobsRequest) { +} + +func (newState *ListJobsRequest) SyncEffectiveFieldsDuringRead(existingState ListJobsRequest) { +} + // List of jobs was retrieved successfully. type ListJobsResponse struct { // If true, additional jobs matching the provided filter are available for @@ -1051,6 +1459,12 @@ type ListJobsResponse struct { PrevPageToken types.String `tfsdk:"prev_page_token" tf:"optional"` } +func (newState *ListJobsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListJobsResponse) { +} + +func (newState *ListJobsResponse) SyncEffectiveFieldsDuringRead(existingState ListJobsResponse) { +} + // List job runs type ListRunsRequest struct { // If active_only is `true`, only active runs are included in the results; @@ -1091,6 +1505,12 @@ type ListRunsRequest struct { StartTimeTo types.Int64 `tfsdk:"-"` } +func (newState *ListRunsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListRunsRequest) { +} + +func (newState *ListRunsRequest) SyncEffectiveFieldsDuringRead(existingState ListRunsRequest) { +} + // List of runs was retrieved successfully. type ListRunsResponse struct { // If true, additional runs matching the provided filter are available for @@ -1106,6 +1526,12 @@ type ListRunsResponse struct { Runs []BaseRun `tfsdk:"runs" tf:"optional"` } +func (newState *ListRunsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListRunsResponse) { +} + +func (newState *ListRunsResponse) SyncEffectiveFieldsDuringRead(existingState ListRunsResponse) { +} + type NotebookOutput struct { // The value passed to // [dbutils.notebook.exit()](/notebooks/notebook-workflows.html#notebook-workflows-exit). @@ -1118,6 +1544,12 @@ type NotebookOutput struct { Truncated types.Bool `tfsdk:"truncated" tf:"optional"` } +func (newState *NotebookOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan NotebookOutput) { +} + +func (newState *NotebookOutput) SyncEffectiveFieldsDuringRead(existingState NotebookOutput) { +} + type NotebookTask struct { // Base parameters to be used for each run of this job. If the run is // initiated by a call to :method:jobs/run Now with parameters specified, @@ -1159,6 +1591,12 @@ type NotebookTask struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *NotebookTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan NotebookTask) { +} + +func (newState *NotebookTask) SyncEffectiveFieldsDuringRead(existingState NotebookTask) { +} + type PeriodicTriggerConfiguration struct { // The interval at which the trigger should run. Interval types.Int64 `tfsdk:"interval" tf:""` @@ -1166,11 +1604,23 @@ type PeriodicTriggerConfiguration struct { Unit types.String `tfsdk:"unit" tf:""` } +func (newState *PeriodicTriggerConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan PeriodicTriggerConfiguration) { +} + +func (newState *PeriodicTriggerConfiguration) SyncEffectiveFieldsDuringRead(existingState PeriodicTriggerConfiguration) { +} + type PipelineParams struct { // If true, triggers a full refresh on the delta live table. FullRefresh types.Bool `tfsdk:"full_refresh" tf:"optional"` } +func (newState *PipelineParams) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineParams) { +} + +func (newState *PipelineParams) SyncEffectiveFieldsDuringRead(existingState PipelineParams) { +} + type PipelineTask struct { // If true, triggers a full refresh on the delta live table. FullRefresh types.Bool `tfsdk:"full_refresh" tf:"optional"` @@ -1178,6 +1628,12 @@ type PipelineTask struct { PipelineId types.String `tfsdk:"pipeline_id" tf:""` } +func (newState *PipelineTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineTask) { +} + +func (newState *PipelineTask) SyncEffectiveFieldsDuringRead(existingState PipelineTask) { +} + type PythonWheelTask struct { // Named entry point to use, if it does not exist in the metadata of the // package it executes the function from the package directly using @@ -1194,6 +1650,12 @@ type PythonWheelTask struct { Parameters []types.String `tfsdk:"parameters" tf:"optional"` } +func (newState *PythonWheelTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan PythonWheelTask) { +} + +func (newState *PythonWheelTask) SyncEffectiveFieldsDuringRead(existingState PythonWheelTask) { +} + type QueueDetails struct { // The reason for queuing the run. * `ACTIVE_RUNS_LIMIT_REACHED`: The run // was queued due to reaching the workspace limit of active task runs. * @@ -1207,11 +1669,23 @@ type QueueDetails struct { Message types.String `tfsdk:"message" tf:"optional"` } +func (newState *QueueDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueueDetails) { +} + +func (newState *QueueDetails) SyncEffectiveFieldsDuringRead(existingState QueueDetails) { +} + type QueueSettings struct { // If true, enable queueing for the job. This is a required field. Enabled types.Bool `tfsdk:"enabled" tf:""` } +func (newState *QueueSettings) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueueSettings) { +} + +func (newState *QueueSettings) SyncEffectiveFieldsDuringRead(existingState QueueSettings) { +} + type RepairHistoryItem struct { // The end time of the (repaired) run. EndTime types.Int64 `tfsdk:"end_time" tf:"optional"` @@ -1232,6 +1706,12 @@ type RepairHistoryItem struct { Type types.String `tfsdk:"type" tf:"optional"` } +func (newState *RepairHistoryItem) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepairHistoryItem) { +} + +func (newState *RepairHistoryItem) SyncEffectiveFieldsDuringRead(existingState RepairHistoryItem) { +} + type RepairRun struct { // An array of commands to execute for jobs with the dbt task, for example // `"dbt_commands": ["dbt deps", "dbt seed", "dbt deps", "dbt seed", "dbt @@ -1333,6 +1813,12 @@ type RepairRun struct { SqlParams map[string]types.String `tfsdk:"sql_params" tf:"optional"` } +func (newState *RepairRun) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepairRun) { +} + +func (newState *RepairRun) SyncEffectiveFieldsDuringRead(existingState RepairRun) { +} + // Run repair was initiated. type RepairRunResponse struct { // The ID of the repair. Must be provided in subsequent repairs using the @@ -1340,6 +1826,12 @@ type RepairRunResponse struct { RepairId types.Int64 `tfsdk:"repair_id" tf:"optional"` } +func (newState *RepairRunResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepairRunResponse) { +} + +func (newState *RepairRunResponse) SyncEffectiveFieldsDuringRead(existingState RepairRunResponse) { +} + type ResetJob struct { // The canonical identifier of the job to reset. This field is required. JobId types.Int64 `tfsdk:"job_id" tf:""` @@ -1351,43 +1843,97 @@ type ResetJob struct { NewSettings []JobSettings `tfsdk:"new_settings" tf:"object"` } +func (newState *ResetJob) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResetJob) { +} + +func (newState *ResetJob) SyncEffectiveFieldsDuringRead(existingState ResetJob) { +} + type ResetResponse struct { } +func (newState *ResetResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResetResponse) { +} + +func (newState *ResetResponse) SyncEffectiveFieldsDuringRead(existingState ResetResponse) { +} + type ResolvedConditionTaskValues struct { Left types.String `tfsdk:"left" tf:"optional"` Right types.String `tfsdk:"right" tf:"optional"` } +func (newState *ResolvedConditionTaskValues) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResolvedConditionTaskValues) { +} + +func (newState *ResolvedConditionTaskValues) SyncEffectiveFieldsDuringRead(existingState ResolvedConditionTaskValues) { +} + type ResolvedDbtTaskValues struct { Commands []types.String `tfsdk:"commands" tf:"optional"` } +func (newState *ResolvedDbtTaskValues) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResolvedDbtTaskValues) { +} + +func (newState *ResolvedDbtTaskValues) SyncEffectiveFieldsDuringRead(existingState ResolvedDbtTaskValues) { +} + type ResolvedNotebookTaskValues struct { BaseParameters map[string]types.String `tfsdk:"base_parameters" tf:"optional"` } +func (newState *ResolvedNotebookTaskValues) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResolvedNotebookTaskValues) { +} + +func (newState *ResolvedNotebookTaskValues) SyncEffectiveFieldsDuringRead(existingState ResolvedNotebookTaskValues) { +} + type ResolvedParamPairValues struct { Parameters map[string]types.String `tfsdk:"parameters" tf:"optional"` } +func (newState *ResolvedParamPairValues) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResolvedParamPairValues) { +} + +func (newState *ResolvedParamPairValues) SyncEffectiveFieldsDuringRead(existingState ResolvedParamPairValues) { +} + type ResolvedPythonWheelTaskValues struct { NamedParameters map[string]types.String `tfsdk:"named_parameters" tf:"optional"` Parameters []types.String `tfsdk:"parameters" tf:"optional"` } +func (newState *ResolvedPythonWheelTaskValues) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResolvedPythonWheelTaskValues) { +} + +func (newState *ResolvedPythonWheelTaskValues) SyncEffectiveFieldsDuringRead(existingState ResolvedPythonWheelTaskValues) { +} + type ResolvedRunJobTaskValues struct { JobParameters map[string]types.String `tfsdk:"job_parameters" tf:"optional"` Parameters map[string]types.String `tfsdk:"parameters" tf:"optional"` } +func (newState *ResolvedRunJobTaskValues) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResolvedRunJobTaskValues) { +} + +func (newState *ResolvedRunJobTaskValues) SyncEffectiveFieldsDuringRead(existingState ResolvedRunJobTaskValues) { +} + type ResolvedStringParamsValues struct { Parameters []types.String `tfsdk:"parameters" tf:"optional"` } +func (newState *ResolvedStringParamsValues) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResolvedStringParamsValues) { +} + +func (newState *ResolvedStringParamsValues) SyncEffectiveFieldsDuringRead(existingState ResolvedStringParamsValues) { +} + type ResolvedValues struct { ConditionTask []ResolvedConditionTaskValues `tfsdk:"condition_task" tf:"optional,object"` @@ -1410,6 +1956,12 @@ type ResolvedValues struct { SqlTask []ResolvedParamPairValues `tfsdk:"sql_task" tf:"optional,object"` } +func (newState *ResolvedValues) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResolvedValues) { +} + +func (newState *ResolvedValues) SyncEffectiveFieldsDuringRead(existingState ResolvedValues) { +} + // Run was retrieved successfully type Run struct { // The sequence number of this run attempt for a triggered job run. The @@ -1548,6 +2100,12 @@ type Run struct { TriggerInfo []TriggerInfo `tfsdk:"trigger_info" tf:"optional,object"` } +func (newState *Run) SyncEffectiveFieldsDuringCreateOrUpdate(plan Run) { +} + +func (newState *Run) SyncEffectiveFieldsDuringRead(existingState Run) { +} + type RunConditionTask struct { // The left operand of the condition task. Can be either a string value or a // job state or parameter reference. @@ -1571,6 +2129,12 @@ type RunConditionTask struct { Right types.String `tfsdk:"right" tf:""` } +func (newState *RunConditionTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunConditionTask) { +} + +func (newState *RunConditionTask) SyncEffectiveFieldsDuringRead(existingState RunConditionTask) { +} + type RunForEachTask struct { // An optional maximum allowed number of concurrent runs of the task. Set // this value if you want to be able to execute multiple runs of the task @@ -1586,11 +2150,23 @@ type RunForEachTask struct { Task []Task `tfsdk:"task" tf:"object"` } +func (newState *RunForEachTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunForEachTask) { +} + +func (newState *RunForEachTask) SyncEffectiveFieldsDuringRead(existingState RunForEachTask) { +} + type RunJobOutput struct { // The run id of the triggered job run RunId types.Int64 `tfsdk:"run_id" tf:"optional"` } +func (newState *RunJobOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunJobOutput) { +} + +func (newState *RunJobOutput) SyncEffectiveFieldsDuringRead(existingState RunJobOutput) { +} + type RunJobTask struct { // An array of commands to execute for jobs with the dbt task, for example // `"dbt_commands": ["dbt deps", "dbt seed", "dbt deps", "dbt seed", "dbt @@ -1678,6 +2254,12 @@ type RunJobTask struct { SqlParams map[string]types.String `tfsdk:"sql_params" tf:"optional"` } +func (newState *RunJobTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunJobTask) { +} + +func (newState *RunJobTask) SyncEffectiveFieldsDuringRead(existingState RunJobTask) { +} + type RunNow struct { // An array of commands to execute for jobs with the dbt task, for example // `"dbt_commands": ["dbt deps", "dbt seed", "dbt deps", "dbt seed", "dbt @@ -1783,6 +2365,12 @@ type RunNow struct { SqlParams map[string]types.String `tfsdk:"sql_params" tf:"optional"` } +func (newState *RunNow) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunNow) { +} + +func (newState *RunNow) SyncEffectiveFieldsDuringRead(existingState RunNow) { +} + // Run was started successfully. type RunNowResponse struct { // A unique identifier for this job run. This is set to the same value as @@ -1792,6 +2380,12 @@ type RunNowResponse struct { RunId types.Int64 `tfsdk:"run_id" tf:"optional"` } +func (newState *RunNowResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunNowResponse) { +} + +func (newState *RunNowResponse) SyncEffectiveFieldsDuringRead(existingState RunNowResponse) { +} + // Run output was retrieved successfully. type RunOutput struct { // The output of a dbt task, if available. @@ -1832,6 +2426,12 @@ type RunOutput struct { SqlOutput []SqlOutput `tfsdk:"sql_output" tf:"optional,object"` } +func (newState *RunOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunOutput) { +} + +func (newState *RunOutput) SyncEffectiveFieldsDuringRead(existingState RunOutput) { +} + type RunParameters struct { // An array of commands to execute for jobs with the dbt task, for example // `"dbt_commands": ["dbt deps", "dbt seed", "dbt deps", "dbt seed", "dbt @@ -1915,6 +2515,12 @@ type RunParameters struct { SqlParams map[string]types.String `tfsdk:"sql_params" tf:"optional"` } +func (newState *RunParameters) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunParameters) { +} + +func (newState *RunParameters) SyncEffectiveFieldsDuringRead(existingState RunParameters) { +} + // The current state of the run. type RunState struct { // A value indicating the run's current lifecycle state. This field is @@ -1933,6 +2539,12 @@ type RunState struct { UserCancelledOrTimedout types.Bool `tfsdk:"user_cancelled_or_timedout" tf:"optional"` } +func (newState *RunState) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunState) { +} + +func (newState *RunState) SyncEffectiveFieldsDuringRead(existingState RunState) { +} + // The current status of the run type RunStatus struct { // If the run was queued, details about the reason for queuing the run. @@ -1944,6 +2556,12 @@ type RunStatus struct { TerminationDetails []TerminationDetails `tfsdk:"termination_details" tf:"optional,object"` } +func (newState *RunStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunStatus) { +} + +func (newState *RunStatus) SyncEffectiveFieldsDuringRead(existingState RunStatus) { +} + // Used when outputting a child run, in GetRun or ListRuns. type RunTask struct { // The sequence number of this run attempt for a triggered job run. The @@ -2107,6 +2725,12 @@ type RunTask struct { WebhookNotifications []WebhookNotifications `tfsdk:"webhook_notifications" tf:"optional,object"` } +func (newState *RunTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunTask) { +} + +func (newState *RunTask) SyncEffectiveFieldsDuringRead(existingState RunTask) { +} + type SparkJarTask struct { // Deprecated since 04/2016. Provide a `jar` through the `libraries` field // instead. For an example, see :method:jobs/create. @@ -2126,6 +2750,12 @@ type SparkJarTask struct { Parameters []types.String `tfsdk:"parameters" tf:"optional"` } +func (newState *SparkJarTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan SparkJarTask) { +} + +func (newState *SparkJarTask) SyncEffectiveFieldsDuringRead(existingState SparkJarTask) { +} + type SparkPythonTask struct { // Command line parameters passed to the Python file. // @@ -2152,6 +2782,12 @@ type SparkPythonTask struct { Source types.String `tfsdk:"source" tf:"optional"` } +func (newState *SparkPythonTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan SparkPythonTask) { +} + +func (newState *SparkPythonTask) SyncEffectiveFieldsDuringRead(existingState SparkPythonTask) { +} + type SparkSubmitTask struct { // Command-line parameters passed to spark submit. // @@ -2162,6 +2798,12 @@ type SparkSubmitTask struct { Parameters []types.String `tfsdk:"parameters" tf:"optional"` } +func (newState *SparkSubmitTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan SparkSubmitTask) { +} + +func (newState *SparkSubmitTask) SyncEffectiveFieldsDuringRead(existingState SparkSubmitTask) { +} + type SqlAlertOutput struct { // The state of the SQL alert. // @@ -2180,6 +2822,12 @@ type SqlAlertOutput struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *SqlAlertOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlAlertOutput) { +} + +func (newState *SqlAlertOutput) SyncEffectiveFieldsDuringRead(existingState SqlAlertOutput) { +} + type SqlDashboardOutput struct { // The canonical identifier of the SQL warehouse. WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` @@ -2187,6 +2835,12 @@ type SqlDashboardOutput struct { Widgets []SqlDashboardWidgetOutput `tfsdk:"widgets" tf:"optional"` } +func (newState *SqlDashboardOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlDashboardOutput) { +} + +func (newState *SqlDashboardOutput) SyncEffectiveFieldsDuringRead(existingState SqlDashboardOutput) { +} + type SqlDashboardWidgetOutput struct { // Time (in epoch milliseconds) when execution of the SQL widget ends. EndTime types.Int64 `tfsdk:"end_time" tf:"optional"` @@ -2204,6 +2858,12 @@ type SqlDashboardWidgetOutput struct { WidgetTitle types.String `tfsdk:"widget_title" tf:"optional"` } +func (newState *SqlDashboardWidgetOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlDashboardWidgetOutput) { +} + +func (newState *SqlDashboardWidgetOutput) SyncEffectiveFieldsDuringRead(existingState SqlDashboardWidgetOutput) { +} + type SqlOutput struct { // The output of a SQL alert task, if available. AlertOutput []SqlAlertOutput `tfsdk:"alert_output" tf:"optional,object"` @@ -2213,11 +2873,23 @@ type SqlOutput struct { QueryOutput []SqlQueryOutput `tfsdk:"query_output" tf:"optional,object"` } +func (newState *SqlOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlOutput) { +} + +func (newState *SqlOutput) SyncEffectiveFieldsDuringRead(existingState SqlOutput) { +} + type SqlOutputError struct { // The error message when execution fails. Message types.String `tfsdk:"message" tf:"optional"` } +func (newState *SqlOutputError) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlOutputError) { +} + +func (newState *SqlOutputError) SyncEffectiveFieldsDuringRead(existingState SqlOutputError) { +} + type SqlQueryOutput struct { EndpointId types.String `tfsdk:"endpoint_id" tf:"optional"` // The link to find the output results. @@ -2231,11 +2903,23 @@ type SqlQueryOutput struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *SqlQueryOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlQueryOutput) { +} + +func (newState *SqlQueryOutput) SyncEffectiveFieldsDuringRead(existingState SqlQueryOutput) { +} + type SqlStatementOutput struct { // A key that can be used to look up query details. LookupKey types.String `tfsdk:"lookup_key" tf:"optional"` } +func (newState *SqlStatementOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlStatementOutput) { +} + +func (newState *SqlStatementOutput) SyncEffectiveFieldsDuringRead(existingState SqlStatementOutput) { +} + type SqlTask struct { // If alert, indicates that this job must refresh a SQL alert. Alert []SqlTaskAlert `tfsdk:"alert" tf:"optional,object"` @@ -2256,6 +2940,12 @@ type SqlTask struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:""` } +func (newState *SqlTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlTask) { +} + +func (newState *SqlTask) SyncEffectiveFieldsDuringRead(existingState SqlTask) { +} + type SqlTaskAlert struct { // The canonical identifier of the SQL alert. AlertId types.String `tfsdk:"alert_id" tf:""` @@ -2265,6 +2955,12 @@ type SqlTaskAlert struct { Subscriptions []SqlTaskSubscription `tfsdk:"subscriptions" tf:"optional"` } +func (newState *SqlTaskAlert) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlTaskAlert) { +} + +func (newState *SqlTaskAlert) SyncEffectiveFieldsDuringRead(existingState SqlTaskAlert) { +} + type SqlTaskDashboard struct { // Subject of the email sent to subscribers of this task. CustomSubject types.String `tfsdk:"custom_subject" tf:"optional"` @@ -2277,6 +2973,12 @@ type SqlTaskDashboard struct { Subscriptions []SqlTaskSubscription `tfsdk:"subscriptions" tf:"optional"` } +func (newState *SqlTaskDashboard) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlTaskDashboard) { +} + +func (newState *SqlTaskDashboard) SyncEffectiveFieldsDuringRead(existingState SqlTaskDashboard) { +} + type SqlTaskFile struct { // Path of the SQL file. Must be relative if the source is a remote Git // repository and absolute for workspace paths. @@ -2292,11 +2994,23 @@ type SqlTaskFile struct { Source types.String `tfsdk:"source" tf:"optional"` } +func (newState *SqlTaskFile) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlTaskFile) { +} + +func (newState *SqlTaskFile) SyncEffectiveFieldsDuringRead(existingState SqlTaskFile) { +} + type SqlTaskQuery struct { // The canonical identifier of the SQL query. QueryId types.String `tfsdk:"query_id" tf:""` } +func (newState *SqlTaskQuery) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlTaskQuery) { +} + +func (newState *SqlTaskQuery) SyncEffectiveFieldsDuringRead(existingState SqlTaskQuery) { +} + type SqlTaskSubscription struct { // The canonical identifier of the destination to receive email // notification. This parameter is mutually exclusive with user_name. You @@ -2309,9 +3023,18 @@ type SqlTaskSubscription struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *SqlTaskSubscription) SyncEffectiveFieldsDuringCreateOrUpdate(plan SqlTaskSubscription) { +} + +func (newState *SqlTaskSubscription) SyncEffectiveFieldsDuringRead(existingState SqlTaskSubscription) { +} + type SubmitRun struct { // List of permissions to set on the job. AccessControlList []JobAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` + // The user specified id of the budget policy to use for this one-time run. + // If not specified, the run will be not be attributed to any budget policy. + BudgetPolicyId types.String `tfsdk:"budget_policy_id" tf:"optional"` // An optional set of email addresses notified when the run begins or // completes. EmailNotifications []JobEmailNotifications `tfsdk:"email_notifications" tf:"optional,object"` @@ -2368,12 +3091,24 @@ type SubmitRun struct { WebhookNotifications []WebhookNotifications `tfsdk:"webhook_notifications" tf:"optional,object"` } +func (newState *SubmitRun) SyncEffectiveFieldsDuringCreateOrUpdate(plan SubmitRun) { +} + +func (newState *SubmitRun) SyncEffectiveFieldsDuringRead(existingState SubmitRun) { +} + // Run was created and started successfully. type SubmitRunResponse struct { // The canonical identifier for the newly submitted run. RunId types.Int64 `tfsdk:"run_id" tf:"optional"` } +func (newState *SubmitRunResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SubmitRunResponse) { +} + +func (newState *SubmitRunResponse) SyncEffectiveFieldsDuringRead(existingState SubmitRunResponse) { +} + type SubmitTask struct { // If condition_task, specifies a condition with an outcome that can be used // to control the execution of other tasks. Does not require a cluster to @@ -2469,6 +3204,12 @@ type SubmitTask struct { WebhookNotifications []WebhookNotifications `tfsdk:"webhook_notifications" tf:"optional,object"` } +func (newState *SubmitTask) SyncEffectiveFieldsDuringCreateOrUpdate(plan SubmitTask) { +} + +func (newState *SubmitTask) SyncEffectiveFieldsDuringRead(existingState SubmitTask) { +} + type TableUpdateTriggerConfiguration struct { // The table(s) condition based on which to trigger a job run. Condition types.String `tfsdk:"condition" tf:"optional"` @@ -2486,6 +3227,12 @@ type TableUpdateTriggerConfiguration struct { WaitAfterLastChangeSeconds types.Int64 `tfsdk:"wait_after_last_change_seconds" tf:"optional"` } +func (newState *TableUpdateTriggerConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan TableUpdateTriggerConfiguration) { +} + +func (newState *TableUpdateTriggerConfiguration) SyncEffectiveFieldsDuringRead(existingState TableUpdateTriggerConfiguration) { +} + type Task struct { // If condition_task, specifies a condition with an outcome that can be used // to control the execution of other tasks. Does not require a cluster to @@ -2604,6 +3351,12 @@ type Task struct { WebhookNotifications []WebhookNotifications `tfsdk:"webhook_notifications" tf:"optional,object"` } +func (newState *Task) SyncEffectiveFieldsDuringCreateOrUpdate(plan Task) { +} + +func (newState *Task) SyncEffectiveFieldsDuringRead(existingState Task) { +} + type TaskDependency struct { // Can only be specified on condition task dependencies. The outcome of the // dependent task that must be met for this task to run. @@ -2612,6 +3365,12 @@ type TaskDependency struct { TaskKey types.String `tfsdk:"task_key" tf:""` } +func (newState *TaskDependency) SyncEffectiveFieldsDuringCreateOrUpdate(plan TaskDependency) { +} + +func (newState *TaskDependency) SyncEffectiveFieldsDuringRead(existingState TaskDependency) { +} + type TaskEmailNotifications struct { // If true, do not send email to recipients specified in `on_failure` if the // run is skipped. This field is `deprecated`. Please use the @@ -2648,6 +3407,12 @@ type TaskEmailNotifications struct { OnSuccess []types.String `tfsdk:"on_success" tf:"optional"` } +func (newState *TaskEmailNotifications) SyncEffectiveFieldsDuringCreateOrUpdate(plan TaskEmailNotifications) { +} + +func (newState *TaskEmailNotifications) SyncEffectiveFieldsDuringRead(existingState TaskEmailNotifications) { +} + type TaskNotificationSettings struct { // If true, do not send notifications to recipients specified in `on_start` // for the retried runs and do not send notifications to recipients @@ -2661,6 +3426,12 @@ type TaskNotificationSettings struct { NoAlertForSkippedRuns types.Bool `tfsdk:"no_alert_for_skipped_runs" tf:"optional"` } +func (newState *TaskNotificationSettings) SyncEffectiveFieldsDuringCreateOrUpdate(plan TaskNotificationSettings) { +} + +func (newState *TaskNotificationSettings) SyncEffectiveFieldsDuringRead(existingState TaskNotificationSettings) { +} + type TerminationDetails struct { // The code indicates why the run was terminated. Additional codes might be // introduced in future releases. * `SUCCESS`: The run was completed @@ -2722,12 +3493,24 @@ type TerminationDetails struct { Type types.String `tfsdk:"type" tf:"optional"` } +func (newState *TerminationDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan TerminationDetails) { +} + +func (newState *TerminationDetails) SyncEffectiveFieldsDuringRead(existingState TerminationDetails) { +} + // Additional details about what triggered the run type TriggerInfo struct { // The run id of the Run Job task run RunId types.Int64 `tfsdk:"run_id" tf:"optional"` } +func (newState *TriggerInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan TriggerInfo) { +} + +func (newState *TriggerInfo) SyncEffectiveFieldsDuringRead(existingState TriggerInfo) { +} + type TriggerSettings struct { // File arrival trigger settings. FileArrival []FileArrivalTriggerConfiguration `tfsdk:"file_arrival" tf:"optional,object"` @@ -2741,6 +3524,12 @@ type TriggerSettings struct { TableUpdate []TableUpdateTriggerConfiguration `tfsdk:"table_update" tf:"optional,object"` } +func (newState *TriggerSettings) SyncEffectiveFieldsDuringCreateOrUpdate(plan TriggerSettings) { +} + +func (newState *TriggerSettings) SyncEffectiveFieldsDuringRead(existingState TriggerSettings) { +} + type UpdateJob struct { // Remove top-level fields in the job settings. Removing nested fields is // not supported, except for tasks and job clusters (`tasks/task_1`). This @@ -2762,9 +3551,21 @@ type UpdateJob struct { NewSettings []JobSettings `tfsdk:"new_settings" tf:"optional,object"` } +func (newState *UpdateJob) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateJob) { +} + +func (newState *UpdateJob) SyncEffectiveFieldsDuringRead(existingState UpdateJob) { +} + type UpdateResponse struct { } +func (newState *UpdateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateResponse) { +} + +func (newState *UpdateResponse) SyncEffectiveFieldsDuringRead(existingState UpdateResponse) { +} + type ViewItem struct { // Content of the view. Content types.String `tfsdk:"content" tf:"optional"` @@ -2776,10 +3577,22 @@ type ViewItem struct { Type types.String `tfsdk:"type" tf:"optional"` } +func (newState *ViewItem) SyncEffectiveFieldsDuringCreateOrUpdate(plan ViewItem) { +} + +func (newState *ViewItem) SyncEffectiveFieldsDuringRead(existingState ViewItem) { +} + type Webhook struct { Id types.String `tfsdk:"id" tf:""` } +func (newState *Webhook) SyncEffectiveFieldsDuringCreateOrUpdate(plan Webhook) { +} + +func (newState *Webhook) SyncEffectiveFieldsDuringRead(existingState Webhook) { +} + type WebhookNotifications struct { // An optional list of system notification IDs to call when the duration of // a run exceeds the threshold specified for the `RUN_DURATION_SECONDS` @@ -2806,3 +3619,9 @@ type WebhookNotifications struct { // the `on_success` property. OnSuccess []Webhook `tfsdk:"on_success" tf:"optional"` } + +func (newState *WebhookNotifications) SyncEffectiveFieldsDuringCreateOrUpdate(plan WebhookNotifications) { +} + +func (newState *WebhookNotifications) SyncEffectiveFieldsDuringRead(existingState WebhookNotifications) { +} diff --git a/internal/service/marketplace_tf/model.go b/internal/service/marketplace_tf/model.go index 40648fd8c2..125335b593 100755 --- a/internal/service/marketplace_tf/model.go +++ b/internal/service/marketplace_tf/model.go @@ -20,32 +20,74 @@ type AddExchangeForListingRequest struct { ListingId types.String `tfsdk:"listing_id" tf:""` } +func (newState *AddExchangeForListingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan AddExchangeForListingRequest) { +} + +func (newState *AddExchangeForListingRequest) SyncEffectiveFieldsDuringRead(existingState AddExchangeForListingRequest) { +} + type AddExchangeForListingResponse struct { ExchangeForListing []ExchangeListing `tfsdk:"exchange_for_listing" tf:"optional,object"` } +func (newState *AddExchangeForListingResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan AddExchangeForListingResponse) { +} + +func (newState *AddExchangeForListingResponse) SyncEffectiveFieldsDuringRead(existingState AddExchangeForListingResponse) { +} + // Get one batch of listings. One may specify up to 50 IDs per request. type BatchGetListingsRequest struct { Ids []types.String `tfsdk:"-"` } +func (newState *BatchGetListingsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan BatchGetListingsRequest) { +} + +func (newState *BatchGetListingsRequest) SyncEffectiveFieldsDuringRead(existingState BatchGetListingsRequest) { +} + type BatchGetListingsResponse struct { Listings []Listing `tfsdk:"listings" tf:"optional"` } +func (newState *BatchGetListingsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan BatchGetListingsResponse) { +} + +func (newState *BatchGetListingsResponse) SyncEffectiveFieldsDuringRead(existingState BatchGetListingsResponse) { +} + // Get one batch of providers. One may specify up to 50 IDs per request. type BatchGetProvidersRequest struct { Ids []types.String `tfsdk:"-"` } +func (newState *BatchGetProvidersRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan BatchGetProvidersRequest) { +} + +func (newState *BatchGetProvidersRequest) SyncEffectiveFieldsDuringRead(existingState BatchGetProvidersRequest) { +} + type BatchGetProvidersResponse struct { Providers []ProviderInfo `tfsdk:"providers" tf:"optional"` } +func (newState *BatchGetProvidersResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan BatchGetProvidersResponse) { +} + +func (newState *BatchGetProvidersResponse) SyncEffectiveFieldsDuringRead(existingState BatchGetProvidersResponse) { +} + type ConsumerTerms struct { Version types.String `tfsdk:"version" tf:""` } +func (newState *ConsumerTerms) SyncEffectiveFieldsDuringCreateOrUpdate(plan ConsumerTerms) { +} + +func (newState *ConsumerTerms) SyncEffectiveFieldsDuringRead(existingState ConsumerTerms) { +} + // contact info for the consumer requesting data or performing a listing // installation type ContactInfo struct { @@ -58,22 +100,52 @@ type ContactInfo struct { LastName types.String `tfsdk:"last_name" tf:"optional"` } +func (newState *ContactInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ContactInfo) { +} + +func (newState *ContactInfo) SyncEffectiveFieldsDuringRead(existingState ContactInfo) { +} + type CreateExchangeFilterRequest struct { Filter []ExchangeFilter `tfsdk:"filter" tf:"object"` } +func (newState *CreateExchangeFilterRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateExchangeFilterRequest) { +} + +func (newState *CreateExchangeFilterRequest) SyncEffectiveFieldsDuringRead(existingState CreateExchangeFilterRequest) { +} + type CreateExchangeFilterResponse struct { FilterId types.String `tfsdk:"filter_id" tf:"optional"` } +func (newState *CreateExchangeFilterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateExchangeFilterResponse) { +} + +func (newState *CreateExchangeFilterResponse) SyncEffectiveFieldsDuringRead(existingState CreateExchangeFilterResponse) { +} + type CreateExchangeRequest struct { Exchange []Exchange `tfsdk:"exchange" tf:"object"` } +func (newState *CreateExchangeRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateExchangeRequest) { +} + +func (newState *CreateExchangeRequest) SyncEffectiveFieldsDuringRead(existingState CreateExchangeRequest) { +} + type CreateExchangeResponse struct { ExchangeId types.String `tfsdk:"exchange_id" tf:"optional"` } +func (newState *CreateExchangeResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateExchangeResponse) { +} + +func (newState *CreateExchangeResponse) SyncEffectiveFieldsDuringRead(existingState CreateExchangeResponse) { +} + type CreateFileRequest struct { DisplayName types.String `tfsdk:"display_name" tf:"optional"` @@ -84,12 +156,24 @@ type CreateFileRequest struct { MimeType types.String `tfsdk:"mime_type" tf:""` } +func (newState *CreateFileRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateFileRequest) { +} + +func (newState *CreateFileRequest) SyncEffectiveFieldsDuringRead(existingState CreateFileRequest) { +} + type CreateFileResponse struct { FileInfo []FileInfo `tfsdk:"file_info" tf:"optional,object"` // Pre-signed POST URL to blob storage UploadUrl types.String `tfsdk:"upload_url" tf:"optional"` } +func (newState *CreateFileResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateFileResponse) { +} + +func (newState *CreateFileResponse) SyncEffectiveFieldsDuringRead(existingState CreateFileResponse) { +} + type CreateInstallationRequest struct { AcceptedConsumerTerms []ConsumerTerms `tfsdk:"accepted_consumer_terms" tf:"optional,object"` @@ -104,14 +188,32 @@ type CreateInstallationRequest struct { ShareName types.String `tfsdk:"share_name" tf:"optional"` } +func (newState *CreateInstallationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateInstallationRequest) { +} + +func (newState *CreateInstallationRequest) SyncEffectiveFieldsDuringRead(existingState CreateInstallationRequest) { +} + type CreateListingRequest struct { Listing []Listing `tfsdk:"listing" tf:"object"` } +func (newState *CreateListingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateListingRequest) { +} + +func (newState *CreateListingRequest) SyncEffectiveFieldsDuringRead(existingState CreateListingRequest) { +} + type CreateListingResponse struct { ListingId types.String `tfsdk:"listing_id" tf:"optional"` } +func (newState *CreateListingResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateListingResponse) { +} + +func (newState *CreateListingResponse) SyncEffectiveFieldsDuringRead(existingState CreateListingResponse) { +} + // Data request messages also creates a lead (maybe) type CreatePersonalizationRequest struct { AcceptedConsumerTerms []ConsumerTerms `tfsdk:"accepted_consumer_terms" tf:"object"` @@ -133,48 +235,114 @@ type CreatePersonalizationRequest struct { RecipientType types.String `tfsdk:"recipient_type" tf:"optional"` } +func (newState *CreatePersonalizationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreatePersonalizationRequest) { +} + +func (newState *CreatePersonalizationRequest) SyncEffectiveFieldsDuringRead(existingState CreatePersonalizationRequest) { +} + type CreatePersonalizationRequestResponse struct { Id types.String `tfsdk:"id" tf:"optional"` } +func (newState *CreatePersonalizationRequestResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreatePersonalizationRequestResponse) { +} + +func (newState *CreatePersonalizationRequestResponse) SyncEffectiveFieldsDuringRead(existingState CreatePersonalizationRequestResponse) { +} + type CreateProviderRequest struct { Provider []ProviderInfo `tfsdk:"provider" tf:"object"` } +func (newState *CreateProviderRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateProviderRequest) { +} + +func (newState *CreateProviderRequest) SyncEffectiveFieldsDuringRead(existingState CreateProviderRequest) { +} + type CreateProviderResponse struct { Id types.String `tfsdk:"id" tf:"optional"` } +func (newState *CreateProviderResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateProviderResponse) { +} + +func (newState *CreateProviderResponse) SyncEffectiveFieldsDuringRead(existingState CreateProviderResponse) { +} + type DataRefreshInfo struct { Interval types.Int64 `tfsdk:"interval" tf:""` Unit types.String `tfsdk:"unit" tf:""` } +func (newState *DataRefreshInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan DataRefreshInfo) { +} + +func (newState *DataRefreshInfo) SyncEffectiveFieldsDuringRead(existingState DataRefreshInfo) { +} + // Delete an exchange filter type DeleteExchangeFilterRequest struct { Id types.String `tfsdk:"-"` } +func (newState *DeleteExchangeFilterRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteExchangeFilterRequest) { +} + +func (newState *DeleteExchangeFilterRequest) SyncEffectiveFieldsDuringRead(existingState DeleteExchangeFilterRequest) { +} + type DeleteExchangeFilterResponse struct { } +func (newState *DeleteExchangeFilterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteExchangeFilterResponse) { +} + +func (newState *DeleteExchangeFilterResponse) SyncEffectiveFieldsDuringRead(existingState DeleteExchangeFilterResponse) { +} + // Delete an exchange type DeleteExchangeRequest struct { Id types.String `tfsdk:"-"` } +func (newState *DeleteExchangeRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteExchangeRequest) { +} + +func (newState *DeleteExchangeRequest) SyncEffectiveFieldsDuringRead(existingState DeleteExchangeRequest) { +} + type DeleteExchangeResponse struct { } +func (newState *DeleteExchangeResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteExchangeResponse) { +} + +func (newState *DeleteExchangeResponse) SyncEffectiveFieldsDuringRead(existingState DeleteExchangeResponse) { +} + // Delete a file type DeleteFileRequest struct { FileId types.String `tfsdk:"-"` } +func (newState *DeleteFileRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteFileRequest) { +} + +func (newState *DeleteFileRequest) SyncEffectiveFieldsDuringRead(existingState DeleteFileRequest) { +} + type DeleteFileResponse struct { } +func (newState *DeleteFileResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteFileResponse) { +} + +func (newState *DeleteFileResponse) SyncEffectiveFieldsDuringRead(existingState DeleteFileResponse) { +} + // Uninstall from a listing type DeleteInstallationRequest struct { InstallationId types.String `tfsdk:"-"` @@ -182,25 +350,61 @@ type DeleteInstallationRequest struct { ListingId types.String `tfsdk:"-"` } +func (newState *DeleteInstallationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteInstallationRequest) { +} + +func (newState *DeleteInstallationRequest) SyncEffectiveFieldsDuringRead(existingState DeleteInstallationRequest) { +} + type DeleteInstallationResponse struct { } +func (newState *DeleteInstallationResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteInstallationResponse) { +} + +func (newState *DeleteInstallationResponse) SyncEffectiveFieldsDuringRead(existingState DeleteInstallationResponse) { +} + // Delete a listing type DeleteListingRequest struct { Id types.String `tfsdk:"-"` } +func (newState *DeleteListingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteListingRequest) { +} + +func (newState *DeleteListingRequest) SyncEffectiveFieldsDuringRead(existingState DeleteListingRequest) { +} + type DeleteListingResponse struct { } +func (newState *DeleteListingResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteListingResponse) { +} + +func (newState *DeleteListingResponse) SyncEffectiveFieldsDuringRead(existingState DeleteListingResponse) { +} + // Delete provider type DeleteProviderRequest struct { Id types.String `tfsdk:"-"` } +func (newState *DeleteProviderRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteProviderRequest) { +} + +func (newState *DeleteProviderRequest) SyncEffectiveFieldsDuringRead(existingState DeleteProviderRequest) { +} + type DeleteProviderResponse struct { } +func (newState *DeleteProviderResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteProviderResponse) { +} + +func (newState *DeleteProviderResponse) SyncEffectiveFieldsDuringRead(existingState DeleteProviderResponse) { +} + type Exchange struct { Comment types.String `tfsdk:"comment" tf:"optional"` @@ -221,6 +425,12 @@ type Exchange struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *Exchange) SyncEffectiveFieldsDuringCreateOrUpdate(plan Exchange) { +} + +func (newState *Exchange) SyncEffectiveFieldsDuringRead(existingState Exchange) { +} + type ExchangeFilter struct { CreatedAt types.Int64 `tfsdk:"created_at" tf:"optional"` @@ -241,6 +451,12 @@ type ExchangeFilter struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *ExchangeFilter) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExchangeFilter) { +} + +func (newState *ExchangeFilter) SyncEffectiveFieldsDuringRead(existingState ExchangeFilter) { +} + type ExchangeListing struct { CreatedAt types.Int64 `tfsdk:"created_at" tf:"optional"` @@ -257,6 +473,12 @@ type ExchangeListing struct { ListingName types.String `tfsdk:"listing_name" tf:"optional"` } +func (newState *ExchangeListing) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExchangeListing) { +} + +func (newState *ExchangeListing) SyncEffectiveFieldsDuringRead(existingState ExchangeListing) { +} + type FileInfo struct { CreatedAt types.Int64 `tfsdk:"created_at" tf:"optional"` // Name displayed to users for applicable files, e.g. embedded notebooks @@ -280,35 +502,77 @@ type FileInfo struct { UpdatedAt types.Int64 `tfsdk:"updated_at" tf:"optional"` } +func (newState *FileInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan FileInfo) { +} + +func (newState *FileInfo) SyncEffectiveFieldsDuringRead(existingState FileInfo) { +} + type FileParent struct { FileParentType types.String `tfsdk:"file_parent_type" tf:"optional"` // TODO make the following fields required ParentId types.String `tfsdk:"parent_id" tf:"optional"` } +func (newState *FileParent) SyncEffectiveFieldsDuringCreateOrUpdate(plan FileParent) { +} + +func (newState *FileParent) SyncEffectiveFieldsDuringRead(existingState FileParent) { +} + // Get an exchange type GetExchangeRequest struct { Id types.String `tfsdk:"-"` } +func (newState *GetExchangeRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetExchangeRequest) { +} + +func (newState *GetExchangeRequest) SyncEffectiveFieldsDuringRead(existingState GetExchangeRequest) { +} + type GetExchangeResponse struct { Exchange []Exchange `tfsdk:"exchange" tf:"optional,object"` } +func (newState *GetExchangeResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetExchangeResponse) { +} + +func (newState *GetExchangeResponse) SyncEffectiveFieldsDuringRead(existingState GetExchangeResponse) { +} + // Get a file type GetFileRequest struct { FileId types.String `tfsdk:"-"` } +func (newState *GetFileRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetFileRequest) { +} + +func (newState *GetFileRequest) SyncEffectiveFieldsDuringRead(existingState GetFileRequest) { +} + type GetFileResponse struct { FileInfo []FileInfo `tfsdk:"file_info" tf:"optional,object"` } +func (newState *GetFileResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetFileResponse) { +} + +func (newState *GetFileResponse) SyncEffectiveFieldsDuringRead(existingState GetFileResponse) { +} + type GetLatestVersionProviderAnalyticsDashboardResponse struct { // version here is latest logical version of the dashboard template Version types.Int64 `tfsdk:"version" tf:"optional"` } +func (newState *GetLatestVersionProviderAnalyticsDashboardResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetLatestVersionProviderAnalyticsDashboardResponse) { +} + +func (newState *GetLatestVersionProviderAnalyticsDashboardResponse) SyncEffectiveFieldsDuringRead(existingState GetLatestVersionProviderAnalyticsDashboardResponse) { +} + // Get listing content metadata type GetListingContentMetadataRequest struct { ListingId types.String `tfsdk:"-"` @@ -318,21 +582,45 @@ type GetListingContentMetadataRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *GetListingContentMetadataRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetListingContentMetadataRequest) { +} + +func (newState *GetListingContentMetadataRequest) SyncEffectiveFieldsDuringRead(existingState GetListingContentMetadataRequest) { +} + type GetListingContentMetadataResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` SharedDataObjects []SharedDataObject `tfsdk:"shared_data_objects" tf:"optional"` } +func (newState *GetListingContentMetadataResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetListingContentMetadataResponse) { +} + +func (newState *GetListingContentMetadataResponse) SyncEffectiveFieldsDuringRead(existingState GetListingContentMetadataResponse) { +} + // Get listing type GetListingRequest struct { Id types.String `tfsdk:"-"` } +func (newState *GetListingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetListingRequest) { +} + +func (newState *GetListingRequest) SyncEffectiveFieldsDuringRead(existingState GetListingRequest) { +} + type GetListingResponse struct { Listing []Listing `tfsdk:"listing" tf:"optional,object"` } +func (newState *GetListingResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetListingResponse) { +} + +func (newState *GetListingResponse) SyncEffectiveFieldsDuringRead(existingState GetListingResponse) { +} + // List listings type GetListingsRequest struct { PageSize types.Int64 `tfsdk:"-"` @@ -340,34 +628,76 @@ type GetListingsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *GetListingsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetListingsRequest) { +} + +func (newState *GetListingsRequest) SyncEffectiveFieldsDuringRead(existingState GetListingsRequest) { +} + type GetListingsResponse struct { Listings []Listing `tfsdk:"listings" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *GetListingsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetListingsResponse) { +} + +func (newState *GetListingsResponse) SyncEffectiveFieldsDuringRead(existingState GetListingsResponse) { +} + // Get the personalization request for a listing type GetPersonalizationRequestRequest struct { ListingId types.String `tfsdk:"-"` } +func (newState *GetPersonalizationRequestRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPersonalizationRequestRequest) { +} + +func (newState *GetPersonalizationRequestRequest) SyncEffectiveFieldsDuringRead(existingState GetPersonalizationRequestRequest) { +} + type GetPersonalizationRequestResponse struct { PersonalizationRequests []PersonalizationRequest `tfsdk:"personalization_requests" tf:"optional"` } +func (newState *GetPersonalizationRequestResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPersonalizationRequestResponse) { +} + +func (newState *GetPersonalizationRequestResponse) SyncEffectiveFieldsDuringRead(existingState GetPersonalizationRequestResponse) { +} + // Get a provider type GetProviderRequest struct { Id types.String `tfsdk:"-"` } +func (newState *GetProviderRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetProviderRequest) { +} + +func (newState *GetProviderRequest) SyncEffectiveFieldsDuringRead(existingState GetProviderRequest) { +} + type GetProviderResponse struct { Provider []ProviderInfo `tfsdk:"provider" tf:"optional,object"` } +func (newState *GetProviderResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetProviderResponse) { +} + +func (newState *GetProviderResponse) SyncEffectiveFieldsDuringRead(existingState GetProviderResponse) { +} + type Installation struct { Installation []InstallationDetail `tfsdk:"installation" tf:"optional,object"` } +func (newState *Installation) SyncEffectiveFieldsDuringCreateOrUpdate(plan Installation) { +} + +func (newState *Installation) SyncEffectiveFieldsDuringRead(existingState Installation) { +} + type InstallationDetail struct { CatalogName types.String `tfsdk:"catalog_name" tf:"optional"` @@ -396,6 +726,12 @@ type InstallationDetail struct { Tokens []TokenInfo `tfsdk:"tokens" tf:"optional"` } +func (newState *InstallationDetail) SyncEffectiveFieldsDuringCreateOrUpdate(plan InstallationDetail) { +} + +func (newState *InstallationDetail) SyncEffectiveFieldsDuringRead(existingState InstallationDetail) { +} + // List all installations type ListAllInstallationsRequest struct { PageSize types.Int64 `tfsdk:"-"` @@ -403,12 +739,24 @@ type ListAllInstallationsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListAllInstallationsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAllInstallationsRequest) { +} + +func (newState *ListAllInstallationsRequest) SyncEffectiveFieldsDuringRead(existingState ListAllInstallationsRequest) { +} + type ListAllInstallationsResponse struct { Installations []InstallationDetail `tfsdk:"installations" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListAllInstallationsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAllInstallationsResponse) { +} + +func (newState *ListAllInstallationsResponse) SyncEffectiveFieldsDuringRead(existingState ListAllInstallationsResponse) { +} + // List all personalization requests type ListAllPersonalizationRequestsRequest struct { PageSize types.Int64 `tfsdk:"-"` @@ -416,12 +764,24 @@ type ListAllPersonalizationRequestsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListAllPersonalizationRequestsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAllPersonalizationRequestsRequest) { +} + +func (newState *ListAllPersonalizationRequestsRequest) SyncEffectiveFieldsDuringRead(existingState ListAllPersonalizationRequestsRequest) { +} + type ListAllPersonalizationRequestsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` PersonalizationRequests []PersonalizationRequest `tfsdk:"personalization_requests" tf:"optional"` } +func (newState *ListAllPersonalizationRequestsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAllPersonalizationRequestsResponse) { +} + +func (newState *ListAllPersonalizationRequestsResponse) SyncEffectiveFieldsDuringRead(existingState ListAllPersonalizationRequestsResponse) { +} + // List exchange filters type ListExchangeFiltersRequest struct { ExchangeId types.String `tfsdk:"-"` @@ -431,12 +791,24 @@ type ListExchangeFiltersRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListExchangeFiltersRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListExchangeFiltersRequest) { +} + +func (newState *ListExchangeFiltersRequest) SyncEffectiveFieldsDuringRead(existingState ListExchangeFiltersRequest) { +} + type ListExchangeFiltersResponse struct { Filters []ExchangeFilter `tfsdk:"filters" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListExchangeFiltersResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListExchangeFiltersResponse) { +} + +func (newState *ListExchangeFiltersResponse) SyncEffectiveFieldsDuringRead(existingState ListExchangeFiltersResponse) { +} + // List exchanges for listing type ListExchangesForListingRequest struct { ListingId types.String `tfsdk:"-"` @@ -446,12 +818,24 @@ type ListExchangesForListingRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListExchangesForListingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListExchangesForListingRequest) { +} + +func (newState *ListExchangesForListingRequest) SyncEffectiveFieldsDuringRead(existingState ListExchangesForListingRequest) { +} + type ListExchangesForListingResponse struct { ExchangeListing []ExchangeListing `tfsdk:"exchange_listing" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListExchangesForListingResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListExchangesForListingResponse) { +} + +func (newState *ListExchangesForListingResponse) SyncEffectiveFieldsDuringRead(existingState ListExchangesForListingResponse) { +} + // List exchanges type ListExchangesRequest struct { PageSize types.Int64 `tfsdk:"-"` @@ -459,12 +843,24 @@ type ListExchangesRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListExchangesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListExchangesRequest) { +} + +func (newState *ListExchangesRequest) SyncEffectiveFieldsDuringRead(existingState ListExchangesRequest) { +} + type ListExchangesResponse struct { Exchanges []Exchange `tfsdk:"exchanges" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListExchangesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListExchangesResponse) { +} + +func (newState *ListExchangesResponse) SyncEffectiveFieldsDuringRead(existingState ListExchangesResponse) { +} + // List files type ListFilesRequest struct { FileParent []FileParent `tfsdk:"-"` @@ -474,12 +870,24 @@ type ListFilesRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListFilesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListFilesRequest) { +} + +func (newState *ListFilesRequest) SyncEffectiveFieldsDuringRead(existingState ListFilesRequest) { +} + type ListFilesResponse struct { FileInfos []FileInfo `tfsdk:"file_infos" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListFilesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListFilesResponse) { +} + +func (newState *ListFilesResponse) SyncEffectiveFieldsDuringRead(existingState ListFilesResponse) { +} + // List all listing fulfillments type ListFulfillmentsRequest struct { ListingId types.String `tfsdk:"-"` @@ -489,12 +897,24 @@ type ListFulfillmentsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListFulfillmentsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListFulfillmentsRequest) { +} + +func (newState *ListFulfillmentsRequest) SyncEffectiveFieldsDuringRead(existingState ListFulfillmentsRequest) { +} + type ListFulfillmentsResponse struct { Fulfillments []ListingFulfillment `tfsdk:"fulfillments" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListFulfillmentsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListFulfillmentsResponse) { +} + +func (newState *ListFulfillmentsResponse) SyncEffectiveFieldsDuringRead(existingState ListFulfillmentsResponse) { +} + // List installations for a listing type ListInstallationsRequest struct { ListingId types.String `tfsdk:"-"` @@ -504,12 +924,24 @@ type ListInstallationsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListInstallationsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListInstallationsRequest) { +} + +func (newState *ListInstallationsRequest) SyncEffectiveFieldsDuringRead(existingState ListInstallationsRequest) { +} + type ListInstallationsResponse struct { Installations []InstallationDetail `tfsdk:"installations" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListInstallationsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListInstallationsResponse) { +} + +func (newState *ListInstallationsResponse) SyncEffectiveFieldsDuringRead(existingState ListInstallationsResponse) { +} + // List listings for exchange type ListListingsForExchangeRequest struct { ExchangeId types.String `tfsdk:"-"` @@ -519,12 +951,24 @@ type ListListingsForExchangeRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListListingsForExchangeRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListListingsForExchangeRequest) { +} + +func (newState *ListListingsForExchangeRequest) SyncEffectiveFieldsDuringRead(existingState ListListingsForExchangeRequest) { +} + type ListListingsForExchangeResponse struct { ExchangeListings []ExchangeListing `tfsdk:"exchange_listings" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListListingsForExchangeResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListListingsForExchangeResponse) { +} + +func (newState *ListListingsForExchangeResponse) SyncEffectiveFieldsDuringRead(existingState ListListingsForExchangeResponse) { +} + // List listings type ListListingsRequest struct { // Matches any of the following asset types @@ -547,12 +991,24 @@ type ListListingsRequest struct { Tags []ListingTag `tfsdk:"-"` } +func (newState *ListListingsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListListingsRequest) { +} + +func (newState *ListListingsRequest) SyncEffectiveFieldsDuringRead(existingState ListListingsRequest) { +} + type ListListingsResponse struct { Listings []Listing `tfsdk:"listings" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListListingsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListListingsResponse) { +} + +func (newState *ListListingsResponse) SyncEffectiveFieldsDuringRead(existingState ListListingsResponse) { +} + type ListProviderAnalyticsDashboardResponse struct { // dashboard_id will be used to open Lakeview dashboard. DashboardId types.String `tfsdk:"dashboard_id" tf:""` @@ -562,6 +1018,12 @@ type ListProviderAnalyticsDashboardResponse struct { Version types.Int64 `tfsdk:"version" tf:"optional"` } +func (newState *ListProviderAnalyticsDashboardResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListProviderAnalyticsDashboardResponse) { +} + +func (newState *ListProviderAnalyticsDashboardResponse) SyncEffectiveFieldsDuringRead(existingState ListProviderAnalyticsDashboardResponse) { +} + // List providers type ListProvidersRequest struct { IsFeatured types.Bool `tfsdk:"-"` @@ -571,12 +1033,24 @@ type ListProvidersRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListProvidersRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListProvidersRequest) { +} + +func (newState *ListProvidersRequest) SyncEffectiveFieldsDuringRead(existingState ListProvidersRequest) { +} + type ListProvidersResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` Providers []ProviderInfo `tfsdk:"providers" tf:"optional"` } +func (newState *ListProvidersResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListProvidersResponse) { +} + +func (newState *ListProvidersResponse) SyncEffectiveFieldsDuringRead(existingState ListProvidersResponse) { +} + type Listing struct { Detail []ListingDetail `tfsdk:"detail" tf:"optional,object"` @@ -585,6 +1059,12 @@ type Listing struct { Summary []ListingSummary `tfsdk:"summary" tf:"object"` } +func (newState *Listing) SyncEffectiveFieldsDuringCreateOrUpdate(plan Listing) { +} + +func (newState *Listing) SyncEffectiveFieldsDuringRead(existingState Listing) { +} + type ListingDetail struct { // Type of assets included in the listing. eg. GIT_REPO, DATA_TABLE, MODEL, // NOTEBOOK @@ -636,6 +1116,12 @@ type ListingDetail struct { UpdateFrequency []DataRefreshInfo `tfsdk:"update_frequency" tf:"optional,object"` } +func (newState *ListingDetail) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListingDetail) { +} + +func (newState *ListingDetail) SyncEffectiveFieldsDuringRead(existingState ListingDetail) { +} + type ListingFulfillment struct { FulfillmentType types.String `tfsdk:"fulfillment_type" tf:"optional"` @@ -648,10 +1134,22 @@ type ListingFulfillment struct { ShareInfo []ShareInfo `tfsdk:"share_info" tf:"optional,object"` } +func (newState *ListingFulfillment) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListingFulfillment) { +} + +func (newState *ListingFulfillment) SyncEffectiveFieldsDuringRead(existingState ListingFulfillment) { +} + type ListingSetting struct { Visibility types.String `tfsdk:"visibility" tf:"optional"` } +func (newState *ListingSetting) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListingSetting) { +} + +func (newState *ListingSetting) SyncEffectiveFieldsDuringRead(existingState ListingSetting) { +} + // Next Number: 26 type ListingSummary struct { Categories []types.String `tfsdk:"categories" tf:"optional"` @@ -694,6 +1192,12 @@ type ListingSummary struct { UpdatedById types.Int64 `tfsdk:"updated_by_id" tf:"optional"` } +func (newState *ListingSummary) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListingSummary) { +} + +func (newState *ListingSummary) SyncEffectiveFieldsDuringRead(existingState ListingSummary) { +} + type ListingTag struct { // Tag name (enum) TagName types.String `tfsdk:"tag_name" tf:"optional"` @@ -702,6 +1206,12 @@ type ListingTag struct { TagValues []types.String `tfsdk:"tag_values" tf:"optional"` } +func (newState *ListingTag) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListingTag) { +} + +func (newState *ListingTag) SyncEffectiveFieldsDuringRead(existingState ListingTag) { +} + type PersonalizationRequest struct { Comment types.String `tfsdk:"comment" tf:"optional"` @@ -737,10 +1247,22 @@ type PersonalizationRequest struct { UpdatedAt types.Int64 `tfsdk:"updated_at" tf:"optional"` } +func (newState *PersonalizationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan PersonalizationRequest) { +} + +func (newState *PersonalizationRequest) SyncEffectiveFieldsDuringRead(existingState PersonalizationRequest) { +} + type ProviderAnalyticsDashboard struct { Id types.String `tfsdk:"id" tf:""` } +func (newState *ProviderAnalyticsDashboard) SyncEffectiveFieldsDuringCreateOrUpdate(plan ProviderAnalyticsDashboard) { +} + +func (newState *ProviderAnalyticsDashboard) SyncEffectiveFieldsDuringRead(existingState ProviderAnalyticsDashboard) { +} + type ProviderInfo struct { BusinessContactEmail types.String `tfsdk:"business_contact_email" tf:""` @@ -771,25 +1293,55 @@ type ProviderInfo struct { TermOfServiceLink types.String `tfsdk:"term_of_service_link" tf:""` } +func (newState *ProviderInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ProviderInfo) { +} + +func (newState *ProviderInfo) SyncEffectiveFieldsDuringRead(existingState ProviderInfo) { +} + type RegionInfo struct { Cloud types.String `tfsdk:"cloud" tf:"optional"` Region types.String `tfsdk:"region" tf:"optional"` } +func (newState *RegionInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegionInfo) { +} + +func (newState *RegionInfo) SyncEffectiveFieldsDuringRead(existingState RegionInfo) { +} + // Remove an exchange for listing type RemoveExchangeForListingRequest struct { Id types.String `tfsdk:"-"` } +func (newState *RemoveExchangeForListingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RemoveExchangeForListingRequest) { +} + +func (newState *RemoveExchangeForListingRequest) SyncEffectiveFieldsDuringRead(existingState RemoveExchangeForListingRequest) { +} + type RemoveExchangeForListingResponse struct { } +func (newState *RemoveExchangeForListingResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RemoveExchangeForListingResponse) { +} + +func (newState *RemoveExchangeForListingResponse) SyncEffectiveFieldsDuringRead(existingState RemoveExchangeForListingResponse) { +} + type RepoInfo struct { // the git repo url e.g. https://github.com/databrickslabs/dolly.git GitRepoUrl types.String `tfsdk:"git_repo_url" tf:""` } +func (newState *RepoInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepoInfo) { +} + +func (newState *RepoInfo) SyncEffectiveFieldsDuringRead(existingState RepoInfo) { +} + type RepoInstallation struct { // the user-specified repo name for their installed git repo listing RepoName types.String `tfsdk:"repo_name" tf:""` @@ -799,6 +1351,12 @@ type RepoInstallation struct { RepoPath types.String `tfsdk:"repo_path" tf:""` } +func (newState *RepoInstallation) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepoInstallation) { +} + +func (newState *RepoInstallation) SyncEffectiveFieldsDuringRead(existingState RepoInstallation) { +} + // Search listings type SearchListingsRequest struct { // Matches any of the following asset types @@ -819,18 +1377,36 @@ type SearchListingsRequest struct { Query types.String `tfsdk:"-"` } +func (newState *SearchListingsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan SearchListingsRequest) { +} + +func (newState *SearchListingsRequest) SyncEffectiveFieldsDuringRead(existingState SearchListingsRequest) { +} + type SearchListingsResponse struct { Listings []Listing `tfsdk:"listings" tf:"optional"` NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *SearchListingsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SearchListingsResponse) { +} + +func (newState *SearchListingsResponse) SyncEffectiveFieldsDuringRead(existingState SearchListingsResponse) { +} + type ShareInfo struct { Name types.String `tfsdk:"name" tf:""` Type types.String `tfsdk:"type" tf:""` } +func (newState *ShareInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ShareInfo) { +} + +func (newState *ShareInfo) SyncEffectiveFieldsDuringRead(existingState ShareInfo) { +} + type SharedDataObject struct { // The type of the data object. Could be one of: TABLE, SCHEMA, // NOTEBOOK_FILE, MODEL, VOLUME @@ -839,6 +1415,12 @@ type SharedDataObject struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *SharedDataObject) SyncEffectiveFieldsDuringCreateOrUpdate(plan SharedDataObject) { +} + +func (newState *SharedDataObject) SyncEffectiveFieldsDuringRead(existingState SharedDataObject) { +} + type TokenDetail struct { BearerToken types.String `tfsdk:"bearerToken" tf:"optional"` @@ -851,6 +1433,12 @@ type TokenDetail struct { ShareCredentialsVersion types.Int64 `tfsdk:"shareCredentialsVersion" tf:"optional"` } +func (newState *TokenDetail) SyncEffectiveFieldsDuringCreateOrUpdate(plan TokenDetail) { +} + +func (newState *TokenDetail) SyncEffectiveFieldsDuringRead(existingState TokenDetail) { +} + type TokenInfo struct { // Full activation url to retrieve the access token. It will be empty if the // token is already retrieved. @@ -869,26 +1457,56 @@ type TokenInfo struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *TokenInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan TokenInfo) { +} + +func (newState *TokenInfo) SyncEffectiveFieldsDuringRead(existingState TokenInfo) { +} + type UpdateExchangeFilterRequest struct { Filter []ExchangeFilter `tfsdk:"filter" tf:"object"` Id types.String `tfsdk:"-"` } +func (newState *UpdateExchangeFilterRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateExchangeFilterRequest) { +} + +func (newState *UpdateExchangeFilterRequest) SyncEffectiveFieldsDuringRead(existingState UpdateExchangeFilterRequest) { +} + type UpdateExchangeFilterResponse struct { Filter []ExchangeFilter `tfsdk:"filter" tf:"optional,object"` } +func (newState *UpdateExchangeFilterResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateExchangeFilterResponse) { +} + +func (newState *UpdateExchangeFilterResponse) SyncEffectiveFieldsDuringRead(existingState UpdateExchangeFilterResponse) { +} + type UpdateExchangeRequest struct { Exchange []Exchange `tfsdk:"exchange" tf:"object"` Id types.String `tfsdk:"-"` } +func (newState *UpdateExchangeRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateExchangeRequest) { +} + +func (newState *UpdateExchangeRequest) SyncEffectiveFieldsDuringRead(existingState UpdateExchangeRequest) { +} + type UpdateExchangeResponse struct { Exchange []Exchange `tfsdk:"exchange" tf:"optional,object"` } +func (newState *UpdateExchangeResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateExchangeResponse) { +} + +func (newState *UpdateExchangeResponse) SyncEffectiveFieldsDuringRead(existingState UpdateExchangeResponse) { +} + type UpdateInstallationRequest struct { Installation []InstallationDetail `tfsdk:"installation" tf:"object"` @@ -899,20 +1517,44 @@ type UpdateInstallationRequest struct { RotateToken types.Bool `tfsdk:"rotate_token" tf:"optional"` } +func (newState *UpdateInstallationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateInstallationRequest) { +} + +func (newState *UpdateInstallationRequest) SyncEffectiveFieldsDuringRead(existingState UpdateInstallationRequest) { +} + type UpdateInstallationResponse struct { Installation []InstallationDetail `tfsdk:"installation" tf:"optional,object"` } +func (newState *UpdateInstallationResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateInstallationResponse) { +} + +func (newState *UpdateInstallationResponse) SyncEffectiveFieldsDuringRead(existingState UpdateInstallationResponse) { +} + type UpdateListingRequest struct { Id types.String `tfsdk:"-"` Listing []Listing `tfsdk:"listing" tf:"object"` } +func (newState *UpdateListingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateListingRequest) { +} + +func (newState *UpdateListingRequest) SyncEffectiveFieldsDuringRead(existingState UpdateListingRequest) { +} + type UpdateListingResponse struct { Listing []Listing `tfsdk:"listing" tf:"optional,object"` } +func (newState *UpdateListingResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateListingResponse) { +} + +func (newState *UpdateListingResponse) SyncEffectiveFieldsDuringRead(existingState UpdateListingResponse) { +} + type UpdatePersonalizationRequestRequest struct { ListingId types.String `tfsdk:"-"` @@ -925,10 +1567,22 @@ type UpdatePersonalizationRequestRequest struct { Status types.String `tfsdk:"status" tf:""` } +func (newState *UpdatePersonalizationRequestRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdatePersonalizationRequestRequest) { +} + +func (newState *UpdatePersonalizationRequestRequest) SyncEffectiveFieldsDuringRead(existingState UpdatePersonalizationRequestRequest) { +} + type UpdatePersonalizationRequestResponse struct { Request []PersonalizationRequest `tfsdk:"request" tf:"optional,object"` } +func (newState *UpdatePersonalizationRequestResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdatePersonalizationRequestResponse) { +} + +func (newState *UpdatePersonalizationRequestResponse) SyncEffectiveFieldsDuringRead(existingState UpdatePersonalizationRequestResponse) { +} + type UpdateProviderAnalyticsDashboardRequest struct { // id is immutable property and can't be updated. Id types.String `tfsdk:"-"` @@ -938,6 +1592,12 @@ type UpdateProviderAnalyticsDashboardRequest struct { Version types.Int64 `tfsdk:"version" tf:"optional"` } +func (newState *UpdateProviderAnalyticsDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateProviderAnalyticsDashboardRequest) { +} + +func (newState *UpdateProviderAnalyticsDashboardRequest) SyncEffectiveFieldsDuringRead(existingState UpdateProviderAnalyticsDashboardRequest) { +} + type UpdateProviderAnalyticsDashboardResponse struct { // this is newly created Lakeview dashboard for the user DashboardId types.String `tfsdk:"dashboard_id" tf:""` @@ -947,12 +1607,30 @@ type UpdateProviderAnalyticsDashboardResponse struct { Version types.Int64 `tfsdk:"version" tf:"optional"` } +func (newState *UpdateProviderAnalyticsDashboardResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateProviderAnalyticsDashboardResponse) { +} + +func (newState *UpdateProviderAnalyticsDashboardResponse) SyncEffectiveFieldsDuringRead(existingState UpdateProviderAnalyticsDashboardResponse) { +} + type UpdateProviderRequest struct { Id types.String `tfsdk:"-"` Provider []ProviderInfo `tfsdk:"provider" tf:"object"` } +func (newState *UpdateProviderRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateProviderRequest) { +} + +func (newState *UpdateProviderRequest) SyncEffectiveFieldsDuringRead(existingState UpdateProviderRequest) { +} + type UpdateProviderResponse struct { Provider []ProviderInfo `tfsdk:"provider" tf:"optional,object"` } + +func (newState *UpdateProviderResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateProviderResponse) { +} + +func (newState *UpdateProviderResponse) SyncEffectiveFieldsDuringRead(existingState UpdateProviderResponse) { +} diff --git a/internal/service/ml_tf/model.go b/internal/service/ml_tf/model.go index e3e52c78a5..c978e6a2c4 100755 --- a/internal/service/ml_tf/model.go +++ b/internal/service/ml_tf/model.go @@ -70,6 +70,12 @@ type Activity struct { UserId types.String `tfsdk:"user_id" tf:"optional"` } +func (newState *Activity) SyncEffectiveFieldsDuringCreateOrUpdate(plan Activity) { +} + +func (newState *Activity) SyncEffectiveFieldsDuringRead(existingState Activity) { +} + type ApproveTransitionRequest struct { // Specifies whether to archive all current model versions in the target // stage. @@ -92,11 +98,23 @@ type ApproveTransitionRequest struct { Version types.String `tfsdk:"version" tf:""` } +func (newState *ApproveTransitionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ApproveTransitionRequest) { +} + +func (newState *ApproveTransitionRequest) SyncEffectiveFieldsDuringRead(existingState ApproveTransitionRequest) { +} + type ApproveTransitionRequestResponse struct { // Activity recorded for the action. Activity []Activity `tfsdk:"activity" tf:"optional,object"` } +func (newState *ApproveTransitionRequestResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ApproveTransitionRequestResponse) { +} + +func (newState *ApproveTransitionRequestResponse) SyncEffectiveFieldsDuringRead(existingState ApproveTransitionRequestResponse) { +} + // Comment details. type CommentObject struct { // Array of actions on the activity allowed for the current viewer. @@ -113,6 +131,12 @@ type CommentObject struct { UserId types.String `tfsdk:"user_id" tf:"optional"` } +func (newState *CommentObject) SyncEffectiveFieldsDuringCreateOrUpdate(plan CommentObject) { +} + +func (newState *CommentObject) SyncEffectiveFieldsDuringRead(existingState CommentObject) { +} + type CreateComment struct { // User-provided comment on the action. Comment types.String `tfsdk:"comment" tf:""` @@ -122,11 +146,23 @@ type CreateComment struct { Version types.String `tfsdk:"version" tf:""` } +func (newState *CreateComment) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateComment) { +} + +func (newState *CreateComment) SyncEffectiveFieldsDuringRead(existingState CreateComment) { +} + type CreateCommentResponse struct { // Comment details. Comment []CommentObject `tfsdk:"comment" tf:"optional,object"` } +func (newState *CreateCommentResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCommentResponse) { +} + +func (newState *CreateCommentResponse) SyncEffectiveFieldsDuringRead(existingState CreateCommentResponse) { +} + type CreateExperiment struct { // Location where all artifacts for the experiment are stored. If not // provided, the remote server will select an appropriate default. @@ -141,11 +177,23 @@ type CreateExperiment struct { Tags []ExperimentTag `tfsdk:"tags" tf:"optional"` } +func (newState *CreateExperiment) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateExperiment) { +} + +func (newState *CreateExperiment) SyncEffectiveFieldsDuringRead(existingState CreateExperiment) { +} + type CreateExperimentResponse struct { // Unique identifier for the experiment. ExperimentId types.String `tfsdk:"experiment_id" tf:"optional"` } +func (newState *CreateExperimentResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateExperimentResponse) { +} + +func (newState *CreateExperimentResponse) SyncEffectiveFieldsDuringRead(existingState CreateExperimentResponse) { +} + type CreateModelRequest struct { // Optional description for registered model. Description types.String `tfsdk:"description" tf:"optional"` @@ -155,10 +203,22 @@ type CreateModelRequest struct { Tags []ModelTag `tfsdk:"tags" tf:"optional"` } +func (newState *CreateModelRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateModelRequest) { +} + +func (newState *CreateModelRequest) SyncEffectiveFieldsDuringRead(existingState CreateModelRequest) { +} + type CreateModelResponse struct { RegisteredModel []Model `tfsdk:"registered_model" tf:"optional,object"` } +func (newState *CreateModelResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateModelResponse) { +} + +func (newState *CreateModelResponse) SyncEffectiveFieldsDuringRead(existingState CreateModelResponse) { +} + type CreateModelVersionRequest struct { // Optional description for model version. Description types.String `tfsdk:"description" tf:"optional"` @@ -176,11 +236,23 @@ type CreateModelVersionRequest struct { Tags []ModelVersionTag `tfsdk:"tags" tf:"optional"` } +func (newState *CreateModelVersionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateModelVersionRequest) { +} + +func (newState *CreateModelVersionRequest) SyncEffectiveFieldsDuringRead(existingState CreateModelVersionRequest) { +} + type CreateModelVersionResponse struct { // Return new version number generated for this model in registry. ModelVersion []ModelVersion `tfsdk:"model_version" tf:"optional,object"` } +func (newState *CreateModelVersionResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateModelVersionResponse) { +} + +func (newState *CreateModelVersionResponse) SyncEffectiveFieldsDuringRead(existingState CreateModelVersionResponse) { +} + type CreateRegistryWebhook struct { // User-specified description for the webhook. Description types.String `tfsdk:"description" tf:"optional"` @@ -235,6 +307,12 @@ type CreateRegistryWebhook struct { Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *CreateRegistryWebhook) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateRegistryWebhook) { +} + +func (newState *CreateRegistryWebhook) SyncEffectiveFieldsDuringRead(existingState CreateRegistryWebhook) { +} + type CreateRun struct { // ID of the associated experiment. ExperimentId types.String `tfsdk:"experiment_id" tf:"optional"` @@ -248,11 +326,23 @@ type CreateRun struct { UserId types.String `tfsdk:"user_id" tf:"optional"` } +func (newState *CreateRun) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateRun) { +} + +func (newState *CreateRun) SyncEffectiveFieldsDuringRead(existingState CreateRun) { +} + type CreateRunResponse struct { // The newly created run. Run []Run `tfsdk:"run" tf:"optional,object"` } +func (newState *CreateRunResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateRunResponse) { +} + +func (newState *CreateRunResponse) SyncEffectiveFieldsDuringRead(existingState CreateRunResponse) { +} + type CreateTransitionRequest struct { // User-provided comment on the action. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -272,15 +362,33 @@ type CreateTransitionRequest struct { Version types.String `tfsdk:"version" tf:""` } +func (newState *CreateTransitionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateTransitionRequest) { +} + +func (newState *CreateTransitionRequest) SyncEffectiveFieldsDuringRead(existingState CreateTransitionRequest) { +} + type CreateTransitionRequestResponse struct { // Transition request details. Request []TransitionRequest `tfsdk:"request" tf:"optional,object"` } +func (newState *CreateTransitionRequestResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateTransitionRequestResponse) { +} + +func (newState *CreateTransitionRequestResponse) SyncEffectiveFieldsDuringRead(existingState CreateTransitionRequestResponse) { +} + type CreateWebhookResponse struct { Webhook []RegistryWebhook `tfsdk:"webhook" tf:"optional,object"` } +func (newState *CreateWebhookResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateWebhookResponse) { +} + +func (newState *CreateWebhookResponse) SyncEffectiveFieldsDuringRead(existingState CreateWebhookResponse) { +} + type Dataset struct { // Dataset digest, e.g. an md5 hash of the dataset that uniquely identifies // it within datasets of the same name. @@ -304,6 +412,12 @@ type Dataset struct { SourceType types.String `tfsdk:"source_type" tf:"optional"` } +func (newState *Dataset) SyncEffectiveFieldsDuringCreateOrUpdate(plan Dataset) { +} + +func (newState *Dataset) SyncEffectiveFieldsDuringRead(existingState Dataset) { +} + type DatasetInput struct { // The dataset being used as a Run input. Dataset []Dataset `tfsdk:"dataset" tf:"optional,object"` @@ -312,31 +426,73 @@ type DatasetInput struct { Tags []InputTag `tfsdk:"tags" tf:"optional"` } +func (newState *DatasetInput) SyncEffectiveFieldsDuringCreateOrUpdate(plan DatasetInput) { +} + +func (newState *DatasetInput) SyncEffectiveFieldsDuringRead(existingState DatasetInput) { +} + // Delete a comment type DeleteCommentRequest struct { Id types.String `tfsdk:"-"` } +func (newState *DeleteCommentRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteCommentRequest) { +} + +func (newState *DeleteCommentRequest) SyncEffectiveFieldsDuringRead(existingState DeleteCommentRequest) { +} + type DeleteCommentResponse struct { } +func (newState *DeleteCommentResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteCommentResponse) { +} + +func (newState *DeleteCommentResponse) SyncEffectiveFieldsDuringRead(existingState DeleteCommentResponse) { +} + type DeleteExperiment struct { // ID of the associated experiment. ExperimentId types.String `tfsdk:"experiment_id" tf:""` } +func (newState *DeleteExperiment) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteExperiment) { +} + +func (newState *DeleteExperiment) SyncEffectiveFieldsDuringRead(existingState DeleteExperiment) { +} + type DeleteExperimentResponse struct { } +func (newState *DeleteExperimentResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteExperimentResponse) { +} + +func (newState *DeleteExperimentResponse) SyncEffectiveFieldsDuringRead(existingState DeleteExperimentResponse) { +} + // Delete a model type DeleteModelRequest struct { // Registered model unique name identifier. Name types.String `tfsdk:"-"` } +func (newState *DeleteModelRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteModelRequest) { +} + +func (newState *DeleteModelRequest) SyncEffectiveFieldsDuringRead(existingState DeleteModelRequest) { +} + type DeleteModelResponse struct { } +func (newState *DeleteModelResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteModelResponse) { +} + +func (newState *DeleteModelResponse) SyncEffectiveFieldsDuringRead(existingState DeleteModelResponse) { +} + // Delete a model tag type DeleteModelTagRequest struct { // Name of the tag. The name must be an exact match; wild-card deletion is @@ -346,9 +502,21 @@ type DeleteModelTagRequest struct { Name types.String `tfsdk:"-"` } +func (newState *DeleteModelTagRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteModelTagRequest) { +} + +func (newState *DeleteModelTagRequest) SyncEffectiveFieldsDuringRead(existingState DeleteModelTagRequest) { +} + type DeleteModelTagResponse struct { } +func (newState *DeleteModelTagResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteModelTagResponse) { +} + +func (newState *DeleteModelTagResponse) SyncEffectiveFieldsDuringRead(existingState DeleteModelTagResponse) { +} + // Delete a model version. type DeleteModelVersionRequest struct { // Name of the registered model @@ -357,9 +525,21 @@ type DeleteModelVersionRequest struct { Version types.String `tfsdk:"-"` } +func (newState *DeleteModelVersionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteModelVersionRequest) { +} + +func (newState *DeleteModelVersionRequest) SyncEffectiveFieldsDuringRead(existingState DeleteModelVersionRequest) { +} + type DeleteModelVersionResponse struct { } +func (newState *DeleteModelVersionResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteModelVersionResponse) { +} + +func (newState *DeleteModelVersionResponse) SyncEffectiveFieldsDuringRead(existingState DeleteModelVersionResponse) { +} + // Delete a model version tag type DeleteModelVersionTagRequest struct { // Name of the tag. The name must be an exact match; wild-card deletion is @@ -371,17 +551,41 @@ type DeleteModelVersionTagRequest struct { Version types.String `tfsdk:"-"` } +func (newState *DeleteModelVersionTagRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteModelVersionTagRequest) { +} + +func (newState *DeleteModelVersionTagRequest) SyncEffectiveFieldsDuringRead(existingState DeleteModelVersionTagRequest) { +} + type DeleteModelVersionTagResponse struct { } +func (newState *DeleteModelVersionTagResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteModelVersionTagResponse) { +} + +func (newState *DeleteModelVersionTagResponse) SyncEffectiveFieldsDuringRead(existingState DeleteModelVersionTagResponse) { +} + type DeleteRun struct { // ID of the run to delete. RunId types.String `tfsdk:"run_id" tf:""` } +func (newState *DeleteRun) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRun) { +} + +func (newState *DeleteRun) SyncEffectiveFieldsDuringRead(existingState DeleteRun) { +} + type DeleteRunResponse struct { } +func (newState *DeleteRunResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRunResponse) { +} + +func (newState *DeleteRunResponse) SyncEffectiveFieldsDuringRead(existingState DeleteRunResponse) { +} + type DeleteRuns struct { // The ID of the experiment containing the runs to delete. ExperimentId types.String `tfsdk:"experiment_id" tf:""` @@ -394,11 +598,23 @@ type DeleteRuns struct { MaxTimestampMillis types.Int64 `tfsdk:"max_timestamp_millis" tf:""` } +func (newState *DeleteRuns) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRuns) { +} + +func (newState *DeleteRuns) SyncEffectiveFieldsDuringRead(existingState DeleteRuns) { +} + type DeleteRunsResponse struct { // The number of runs deleted. RunsDeleted types.Int64 `tfsdk:"runs_deleted" tf:"optional"` } +func (newState *DeleteRunsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRunsResponse) { +} + +func (newState *DeleteRunsResponse) SyncEffectiveFieldsDuringRead(existingState DeleteRunsResponse) { +} + type DeleteTag struct { // Name of the tag. Maximum size is 255 bytes. Must be provided. Key types.String `tfsdk:"key" tf:""` @@ -406,9 +622,21 @@ type DeleteTag struct { RunId types.String `tfsdk:"run_id" tf:""` } +func (newState *DeleteTag) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteTag) { +} + +func (newState *DeleteTag) SyncEffectiveFieldsDuringRead(existingState DeleteTag) { +} + type DeleteTagResponse struct { } +func (newState *DeleteTagResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteTagResponse) { +} + +func (newState *DeleteTagResponse) SyncEffectiveFieldsDuringRead(existingState DeleteTagResponse) { +} + // Delete a transition request type DeleteTransitionRequestRequest struct { // User-provided comment on the action. @@ -433,18 +661,42 @@ type DeleteTransitionRequestRequest struct { Version types.String `tfsdk:"-"` } +func (newState *DeleteTransitionRequestRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteTransitionRequestRequest) { +} + +func (newState *DeleteTransitionRequestRequest) SyncEffectiveFieldsDuringRead(existingState DeleteTransitionRequestRequest) { +} + type DeleteTransitionRequestResponse struct { } +func (newState *DeleteTransitionRequestResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteTransitionRequestResponse) { +} + +func (newState *DeleteTransitionRequestResponse) SyncEffectiveFieldsDuringRead(existingState DeleteTransitionRequestResponse) { +} + // Delete a webhook type DeleteWebhookRequest struct { // Webhook ID required to delete a registry webhook. Id types.String `tfsdk:"-"` } +func (newState *DeleteWebhookRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteWebhookRequest) { +} + +func (newState *DeleteWebhookRequest) SyncEffectiveFieldsDuringRead(existingState DeleteWebhookRequest) { +} + type DeleteWebhookResponse struct { } +func (newState *DeleteWebhookResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteWebhookResponse) { +} + +func (newState *DeleteWebhookResponse) SyncEffectiveFieldsDuringRead(existingState DeleteWebhookResponse) { +} + type Experiment struct { // Location where artifacts for the experiment are stored. ArtifactLocation types.String `tfsdk:"artifact_location" tf:"optional"` @@ -463,6 +715,12 @@ type Experiment struct { Tags []ExperimentTag `tfsdk:"tags" tf:"optional"` } +func (newState *Experiment) SyncEffectiveFieldsDuringCreateOrUpdate(plan Experiment) { +} + +func (newState *Experiment) SyncEffectiveFieldsDuringRead(existingState Experiment) { +} + type ExperimentAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -474,6 +732,12 @@ type ExperimentAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *ExperimentAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExperimentAccessControlRequest) { +} + +func (newState *ExperimentAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState ExperimentAccessControlRequest) { +} + type ExperimentAccessControlResponse struct { // All permissions. AllPermissions []ExperimentPermission `tfsdk:"all_permissions" tf:"optional"` @@ -487,6 +751,12 @@ type ExperimentAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *ExperimentAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExperimentAccessControlResponse) { +} + +func (newState *ExperimentAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState ExperimentAccessControlResponse) { +} + type ExperimentPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -495,6 +765,12 @@ type ExperimentPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *ExperimentPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExperimentPermission) { +} + +func (newState *ExperimentPermission) SyncEffectiveFieldsDuringRead(existingState ExperimentPermission) { +} + type ExperimentPermissions struct { AccessControlList []ExperimentAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -503,18 +779,36 @@ type ExperimentPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *ExperimentPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExperimentPermissions) { +} + +func (newState *ExperimentPermissions) SyncEffectiveFieldsDuringRead(existingState ExperimentPermissions) { +} + type ExperimentPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *ExperimentPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExperimentPermissionsDescription) { +} + +func (newState *ExperimentPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState ExperimentPermissionsDescription) { +} + type ExperimentPermissionsRequest struct { AccessControlList []ExperimentAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The experiment for which to get or manage permissions. ExperimentId types.String `tfsdk:"-"` } +func (newState *ExperimentPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExperimentPermissionsRequest) { +} + +func (newState *ExperimentPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState ExperimentPermissionsRequest) { +} + type ExperimentTag struct { // The tag key. Key types.String `tfsdk:"key" tf:"optional"` @@ -522,6 +816,12 @@ type ExperimentTag struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *ExperimentTag) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExperimentTag) { +} + +func (newState *ExperimentTag) SyncEffectiveFieldsDuringRead(existingState ExperimentTag) { +} + type FileInfo struct { // Size in bytes. Unset for directories. FileSize types.Int64 `tfsdk:"file_size" tf:"optional"` @@ -531,40 +831,82 @@ type FileInfo struct { Path types.String `tfsdk:"path" tf:"optional"` } +func (newState *FileInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan FileInfo) { +} + +func (newState *FileInfo) SyncEffectiveFieldsDuringRead(existingState FileInfo) { +} + // Get metadata type GetByNameRequest struct { // Name of the associated experiment. ExperimentName types.String `tfsdk:"-"` } +func (newState *GetByNameRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetByNameRequest) { +} + +func (newState *GetByNameRequest) SyncEffectiveFieldsDuringRead(existingState GetByNameRequest) { +} + // Get experiment permission levels type GetExperimentPermissionLevelsRequest struct { // The experiment for which to get or manage permissions. ExperimentId types.String `tfsdk:"-"` } +func (newState *GetExperimentPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetExperimentPermissionLevelsRequest) { +} + +func (newState *GetExperimentPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetExperimentPermissionLevelsRequest) { +} + type GetExperimentPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []ExperimentPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetExperimentPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetExperimentPermissionLevelsResponse) { +} + +func (newState *GetExperimentPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetExperimentPermissionLevelsResponse) { +} + // Get experiment permissions type GetExperimentPermissionsRequest struct { // The experiment for which to get or manage permissions. ExperimentId types.String `tfsdk:"-"` } +func (newState *GetExperimentPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetExperimentPermissionsRequest) { +} + +func (newState *GetExperimentPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetExperimentPermissionsRequest) { +} + // Get an experiment type GetExperimentRequest struct { // ID of the associated experiment. ExperimentId types.String `tfsdk:"-"` } +func (newState *GetExperimentRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetExperimentRequest) { +} + +func (newState *GetExperimentRequest) SyncEffectiveFieldsDuringRead(existingState GetExperimentRequest) { +} + type GetExperimentResponse struct { // Experiment details. Experiment []Experiment `tfsdk:"experiment" tf:"optional,object"` } +func (newState *GetExperimentResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetExperimentResponse) { +} + +func (newState *GetExperimentResponse) SyncEffectiveFieldsDuringRead(existingState GetExperimentResponse) { +} + // Get history of a given metric within a run type GetHistoryRequest struct { // Maximum number of Metric records to return per paginated request. Default @@ -582,6 +924,12 @@ type GetHistoryRequest struct { RunUuid types.String `tfsdk:"-"` } +func (newState *GetHistoryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetHistoryRequest) { +} + +func (newState *GetHistoryRequest) SyncEffectiveFieldsDuringRead(existingState GetHistoryRequest) { +} + type GetLatestVersionsRequest struct { // Registered model unique name identifier. Name types.String `tfsdk:"name" tf:""` @@ -589,6 +937,12 @@ type GetLatestVersionsRequest struct { Stages []types.String `tfsdk:"stages" tf:"optional"` } +func (newState *GetLatestVersionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetLatestVersionsRequest) { +} + +func (newState *GetLatestVersionsRequest) SyncEffectiveFieldsDuringRead(existingState GetLatestVersionsRequest) { +} + type GetLatestVersionsResponse struct { // Latest version models for each requests stage. Only return models with // current `READY` status. If no `stages` provided, returns the latest @@ -596,6 +950,12 @@ type GetLatestVersionsResponse struct { ModelVersions []ModelVersion `tfsdk:"model_versions" tf:"optional"` } +func (newState *GetLatestVersionsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetLatestVersionsResponse) { +} + +func (newState *GetLatestVersionsResponse) SyncEffectiveFieldsDuringRead(existingState GetLatestVersionsResponse) { +} + type GetMetricHistoryResponse struct { // All logged values for this metric. Metrics []Metric `tfsdk:"metrics" tf:"optional"` @@ -604,16 +964,34 @@ type GetMetricHistoryResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *GetMetricHistoryResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetMetricHistoryResponse) { +} + +func (newState *GetMetricHistoryResponse) SyncEffectiveFieldsDuringRead(existingState GetMetricHistoryResponse) { +} + // Get model type GetModelRequest struct { // Registered model unique name identifier. Name types.String `tfsdk:"-"` } +func (newState *GetModelRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetModelRequest) { +} + +func (newState *GetModelRequest) SyncEffectiveFieldsDuringRead(existingState GetModelRequest) { +} + type GetModelResponse struct { RegisteredModelDatabricks []ModelDatabricks `tfsdk:"registered_model_databricks" tf:"optional,object"` } +func (newState *GetModelResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetModelResponse) { +} + +func (newState *GetModelResponse) SyncEffectiveFieldsDuringRead(existingState GetModelResponse) { +} + // Get a model version URI type GetModelVersionDownloadUriRequest struct { // Name of the registered model @@ -622,11 +1000,23 @@ type GetModelVersionDownloadUriRequest struct { Version types.String `tfsdk:"-"` } +func (newState *GetModelVersionDownloadUriRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetModelVersionDownloadUriRequest) { +} + +func (newState *GetModelVersionDownloadUriRequest) SyncEffectiveFieldsDuringRead(existingState GetModelVersionDownloadUriRequest) { +} + type GetModelVersionDownloadUriResponse struct { // URI corresponding to where artifacts for this model version are stored. ArtifactUri types.String `tfsdk:"artifact_uri" tf:"optional"` } +func (newState *GetModelVersionDownloadUriResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetModelVersionDownloadUriResponse) { +} + +func (newState *GetModelVersionDownloadUriResponse) SyncEffectiveFieldsDuringRead(existingState GetModelVersionDownloadUriResponse) { +} + // Get a model version type GetModelVersionRequest struct { // Name of the registered model @@ -635,27 +1025,57 @@ type GetModelVersionRequest struct { Version types.String `tfsdk:"-"` } +func (newState *GetModelVersionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetModelVersionRequest) { +} + +func (newState *GetModelVersionRequest) SyncEffectiveFieldsDuringRead(existingState GetModelVersionRequest) { +} + type GetModelVersionResponse struct { ModelVersion []ModelVersion `tfsdk:"model_version" tf:"optional,object"` } +func (newState *GetModelVersionResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetModelVersionResponse) { +} + +func (newState *GetModelVersionResponse) SyncEffectiveFieldsDuringRead(existingState GetModelVersionResponse) { +} + // Get registered model permission levels type GetRegisteredModelPermissionLevelsRequest struct { // The registered model for which to get or manage permissions. RegisteredModelId types.String `tfsdk:"-"` } +func (newState *GetRegisteredModelPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRegisteredModelPermissionLevelsRequest) { +} + +func (newState *GetRegisteredModelPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetRegisteredModelPermissionLevelsRequest) { +} + type GetRegisteredModelPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []RegisteredModelPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetRegisteredModelPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRegisteredModelPermissionLevelsResponse) { +} + +func (newState *GetRegisteredModelPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetRegisteredModelPermissionLevelsResponse) { +} + // Get registered model permissions type GetRegisteredModelPermissionsRequest struct { // The registered model for which to get or manage permissions. RegisteredModelId types.String `tfsdk:"-"` } +func (newState *GetRegisteredModelPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRegisteredModelPermissionsRequest) { +} + +func (newState *GetRegisteredModelPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetRegisteredModelPermissionsRequest) { +} + // Get a run type GetRunRequest struct { // ID of the run to fetch. Must be provided. @@ -665,12 +1085,24 @@ type GetRunRequest struct { RunUuid types.String `tfsdk:"-"` } +func (newState *GetRunRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRunRequest) { +} + +func (newState *GetRunRequest) SyncEffectiveFieldsDuringRead(existingState GetRunRequest) { +} + type GetRunResponse struct { // Run metadata (name, start time, etc) and data (metrics, params, and // tags). Run []Run `tfsdk:"run" tf:"optional,object"` } +func (newState *GetRunResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRunResponse) { +} + +func (newState *GetRunResponse) SyncEffectiveFieldsDuringRead(existingState GetRunResponse) { +} + type HttpUrlSpec struct { // Value of the authorization header that should be sent in the request sent // by the wehbook. It should be of the form `" "`. @@ -693,6 +1125,12 @@ type HttpUrlSpec struct { Url types.String `tfsdk:"url" tf:""` } +func (newState *HttpUrlSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan HttpUrlSpec) { +} + +func (newState *HttpUrlSpec) SyncEffectiveFieldsDuringRead(existingState HttpUrlSpec) { +} + type HttpUrlSpecWithoutSecret struct { // Enable/disable SSL certificate validation. Default is true. For // self-signed certificates, this field must be false AND the destination @@ -706,6 +1144,12 @@ type HttpUrlSpecWithoutSecret struct { Url types.String `tfsdk:"url" tf:"optional"` } +func (newState *HttpUrlSpecWithoutSecret) SyncEffectiveFieldsDuringCreateOrUpdate(plan HttpUrlSpecWithoutSecret) { +} + +func (newState *HttpUrlSpecWithoutSecret) SyncEffectiveFieldsDuringRead(existingState HttpUrlSpecWithoutSecret) { +} + type InputTag struct { // The tag key. Key types.String `tfsdk:"key" tf:"optional"` @@ -713,6 +1157,12 @@ type InputTag struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *InputTag) SyncEffectiveFieldsDuringCreateOrUpdate(plan InputTag) { +} + +func (newState *InputTag) SyncEffectiveFieldsDuringRead(existingState InputTag) { +} + type JobSpec struct { // The personal access token used to authorize webhook's job runs. AccessToken types.String `tfsdk:"access_token" tf:""` @@ -724,6 +1174,12 @@ type JobSpec struct { WorkspaceUrl types.String `tfsdk:"workspace_url" tf:"optional"` } +func (newState *JobSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobSpec) { +} + +func (newState *JobSpec) SyncEffectiveFieldsDuringRead(existingState JobSpec) { +} + type JobSpecWithoutSecret struct { // ID of the job that the webhook runs. JobId types.String `tfsdk:"job_id" tf:"optional"` @@ -733,6 +1189,12 @@ type JobSpecWithoutSecret struct { WorkspaceUrl types.String `tfsdk:"workspace_url" tf:"optional"` } +func (newState *JobSpecWithoutSecret) SyncEffectiveFieldsDuringCreateOrUpdate(plan JobSpecWithoutSecret) { +} + +func (newState *JobSpecWithoutSecret) SyncEffectiveFieldsDuringRead(existingState JobSpecWithoutSecret) { +} + // Get all artifacts type ListArtifactsRequest struct { // Token indicating the page of artifact results to fetch. `page_token` is @@ -752,6 +1214,12 @@ type ListArtifactsRequest struct { RunUuid types.String `tfsdk:"-"` } +func (newState *ListArtifactsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListArtifactsRequest) { +} + +func (newState *ListArtifactsRequest) SyncEffectiveFieldsDuringRead(existingState ListArtifactsRequest) { +} + type ListArtifactsResponse struct { // File location and metadata for artifacts. Files []FileInfo `tfsdk:"files" tf:"optional"` @@ -761,6 +1229,12 @@ type ListArtifactsResponse struct { RootUri types.String `tfsdk:"root_uri" tf:"optional"` } +func (newState *ListArtifactsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListArtifactsResponse) { +} + +func (newState *ListArtifactsResponse) SyncEffectiveFieldsDuringRead(existingState ListArtifactsResponse) { +} + // List experiments type ListExperimentsRequest struct { // Maximum number of experiments desired. If `max_results` is unspecified, @@ -776,6 +1250,12 @@ type ListExperimentsRequest struct { ViewType types.String `tfsdk:"-"` } +func (newState *ListExperimentsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListExperimentsRequest) { +} + +func (newState *ListExperimentsRequest) SyncEffectiveFieldsDuringRead(existingState ListExperimentsRequest) { +} + type ListExperimentsResponse struct { // Paginated Experiments beginning with the first item on the requested // page. @@ -785,6 +1265,12 @@ type ListExperimentsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListExperimentsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListExperimentsResponse) { +} + +func (newState *ListExperimentsResponse) SyncEffectiveFieldsDuringRead(existingState ListExperimentsResponse) { +} + // List models type ListModelsRequest struct { // Maximum number of registered models desired. Max threshold is 1000. @@ -793,6 +1279,12 @@ type ListModelsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListModelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListModelsRequest) { +} + +func (newState *ListModelsRequest) SyncEffectiveFieldsDuringRead(existingState ListModelsRequest) { +} + type ListModelsResponse struct { // Pagination token to request next page of models for the same query. NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` @@ -800,6 +1292,12 @@ type ListModelsResponse struct { RegisteredModels []Model `tfsdk:"registered_models" tf:"optional"` } +func (newState *ListModelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListModelsResponse) { +} + +func (newState *ListModelsResponse) SyncEffectiveFieldsDuringRead(existingState ListModelsResponse) { +} + type ListRegistryWebhooks struct { // Token that can be used to retrieve the next page of artifact results NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` @@ -807,6 +1305,12 @@ type ListRegistryWebhooks struct { Webhooks []RegistryWebhook `tfsdk:"webhooks" tf:"optional"` } +func (newState *ListRegistryWebhooks) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListRegistryWebhooks) { +} + +func (newState *ListRegistryWebhooks) SyncEffectiveFieldsDuringRead(existingState ListRegistryWebhooks) { +} + // List transition requests type ListTransitionRequestsRequest struct { // Name of the model. @@ -815,11 +1319,23 @@ type ListTransitionRequestsRequest struct { Version types.String `tfsdk:"-"` } +func (newState *ListTransitionRequestsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListTransitionRequestsRequest) { +} + +func (newState *ListTransitionRequestsRequest) SyncEffectiveFieldsDuringRead(existingState ListTransitionRequestsRequest) { +} + type ListTransitionRequestsResponse struct { // Array of open transition requests. Requests []Activity `tfsdk:"requests" tf:"optional"` } +func (newState *ListTransitionRequestsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListTransitionRequestsResponse) { +} + +func (newState *ListTransitionRequestsResponse) SyncEffectiveFieldsDuringRead(existingState ListTransitionRequestsResponse) { +} + // List registry webhooks type ListWebhooksRequest struct { // If `events` is specified, any webhook with one or more of the specified @@ -833,6 +1349,12 @@ type ListWebhooksRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListWebhooksRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListWebhooksRequest) { +} + +func (newState *ListWebhooksRequest) SyncEffectiveFieldsDuringRead(existingState ListWebhooksRequest) { +} + type LogBatch struct { // Metrics to log. A single request can contain up to 1000 metrics, and up // to 1000 metrics, params, and tags in total. @@ -847,9 +1369,21 @@ type LogBatch struct { Tags []RunTag `tfsdk:"tags" tf:"optional"` } +func (newState *LogBatch) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogBatch) { +} + +func (newState *LogBatch) SyncEffectiveFieldsDuringRead(existingState LogBatch) { +} + type LogBatchResponse struct { } +func (newState *LogBatchResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogBatchResponse) { +} + +func (newState *LogBatchResponse) SyncEffectiveFieldsDuringRead(existingState LogBatchResponse) { +} + type LogInputs struct { // Dataset inputs Datasets []DatasetInput `tfsdk:"datasets" tf:"optional"` @@ -857,9 +1391,21 @@ type LogInputs struct { RunId types.String `tfsdk:"run_id" tf:"optional"` } +func (newState *LogInputs) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogInputs) { +} + +func (newState *LogInputs) SyncEffectiveFieldsDuringRead(existingState LogInputs) { +} + type LogInputsResponse struct { } +func (newState *LogInputsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogInputsResponse) { +} + +func (newState *LogInputsResponse) SyncEffectiveFieldsDuringRead(existingState LogInputsResponse) { +} + type LogMetric struct { // Name of the metric. Key types.String `tfsdk:"key" tf:""` @@ -876,9 +1422,21 @@ type LogMetric struct { Value types.Float64 `tfsdk:"value" tf:""` } +func (newState *LogMetric) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogMetric) { +} + +func (newState *LogMetric) SyncEffectiveFieldsDuringRead(existingState LogMetric) { +} + type LogMetricResponse struct { } +func (newState *LogMetricResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogMetricResponse) { +} + +func (newState *LogMetricResponse) SyncEffectiveFieldsDuringRead(existingState LogMetricResponse) { +} + type LogModel struct { // MLmodel file in json format. ModelJson types.String `tfsdk:"model_json" tf:"optional"` @@ -886,9 +1444,21 @@ type LogModel struct { RunId types.String `tfsdk:"run_id" tf:"optional"` } +func (newState *LogModel) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogModel) { +} + +func (newState *LogModel) SyncEffectiveFieldsDuringRead(existingState LogModel) { +} + type LogModelResponse struct { } +func (newState *LogModelResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogModelResponse) { +} + +func (newState *LogModelResponse) SyncEffectiveFieldsDuringRead(existingState LogModelResponse) { +} + type LogParam struct { // Name of the param. Maximum size is 255 bytes. Key types.String `tfsdk:"key" tf:""` @@ -901,9 +1471,21 @@ type LogParam struct { Value types.String `tfsdk:"value" tf:""` } +func (newState *LogParam) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogParam) { +} + +func (newState *LogParam) SyncEffectiveFieldsDuringRead(existingState LogParam) { +} + type LogParamResponse struct { } +func (newState *LogParamResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogParamResponse) { +} + +func (newState *LogParamResponse) SyncEffectiveFieldsDuringRead(existingState LogParamResponse) { +} + type Metric struct { // Key identifying this metric. Key types.String `tfsdk:"key" tf:"optional"` @@ -915,6 +1497,12 @@ type Metric struct { Value types.Float64 `tfsdk:"value" tf:"optional"` } +func (newState *Metric) SyncEffectiveFieldsDuringCreateOrUpdate(plan Metric) { +} + +func (newState *Metric) SyncEffectiveFieldsDuringRead(existingState Metric) { +} + type Model struct { // Timestamp recorded when this `registered_model` was created. CreationTimestamp types.Int64 `tfsdk:"creation_timestamp" tf:"optional"` @@ -934,6 +1522,12 @@ type Model struct { UserId types.String `tfsdk:"user_id" tf:"optional"` } +func (newState *Model) SyncEffectiveFieldsDuringCreateOrUpdate(plan Model) { +} + +func (newState *Model) SyncEffectiveFieldsDuringRead(existingState Model) { +} + type ModelDatabricks struct { // Creation time of the object, as a Unix timestamp in milliseconds. CreationTimestamp types.Int64 `tfsdk:"creation_timestamp" tf:"optional"` @@ -956,6 +1550,12 @@ type ModelDatabricks struct { UserId types.String `tfsdk:"user_id" tf:"optional"` } +func (newState *ModelDatabricks) SyncEffectiveFieldsDuringCreateOrUpdate(plan ModelDatabricks) { +} + +func (newState *ModelDatabricks) SyncEffectiveFieldsDuringRead(existingState ModelDatabricks) { +} + type ModelTag struct { // The tag key. Key types.String `tfsdk:"key" tf:"optional"` @@ -963,6 +1563,12 @@ type ModelTag struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *ModelTag) SyncEffectiveFieldsDuringCreateOrUpdate(plan ModelTag) { +} + +func (newState *ModelTag) SyncEffectiveFieldsDuringRead(existingState ModelTag) { +} + type ModelVersion struct { // Timestamp recorded when this `model_version` was created. CreationTimestamp types.Int64 `tfsdk:"creation_timestamp" tf:"optional"` @@ -995,6 +1601,12 @@ type ModelVersion struct { Version types.String `tfsdk:"version" tf:"optional"` } +func (newState *ModelVersion) SyncEffectiveFieldsDuringCreateOrUpdate(plan ModelVersion) { +} + +func (newState *ModelVersion) SyncEffectiveFieldsDuringRead(existingState ModelVersion) { +} + type ModelVersionDatabricks struct { // Creation time of the object, as a Unix timestamp in milliseconds. CreationTimestamp types.Int64 `tfsdk:"creation_timestamp" tf:"optional"` @@ -1046,6 +1658,12 @@ type ModelVersionDatabricks struct { Version types.String `tfsdk:"version" tf:"optional"` } +func (newState *ModelVersionDatabricks) SyncEffectiveFieldsDuringCreateOrUpdate(plan ModelVersionDatabricks) { +} + +func (newState *ModelVersionDatabricks) SyncEffectiveFieldsDuringRead(existingState ModelVersionDatabricks) { +} + type ModelVersionTag struct { // The tag key. Key types.String `tfsdk:"key" tf:"optional"` @@ -1053,6 +1671,12 @@ type ModelVersionTag struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *ModelVersionTag) SyncEffectiveFieldsDuringCreateOrUpdate(plan ModelVersionTag) { +} + +func (newState *ModelVersionTag) SyncEffectiveFieldsDuringRead(existingState ModelVersionTag) { +} + type Param struct { // Key identifying this param. Key types.String `tfsdk:"key" tf:"optional"` @@ -1060,6 +1684,12 @@ type Param struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *Param) SyncEffectiveFieldsDuringCreateOrUpdate(plan Param) { +} + +func (newState *Param) SyncEffectiveFieldsDuringRead(existingState Param) { +} + type RegisteredModelAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -1071,6 +1701,12 @@ type RegisteredModelAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *RegisteredModelAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegisteredModelAccessControlRequest) { +} + +func (newState *RegisteredModelAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState RegisteredModelAccessControlRequest) { +} + type RegisteredModelAccessControlResponse struct { // All permissions. AllPermissions []RegisteredModelPermission `tfsdk:"all_permissions" tf:"optional"` @@ -1084,6 +1720,12 @@ type RegisteredModelAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *RegisteredModelAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegisteredModelAccessControlResponse) { +} + +func (newState *RegisteredModelAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState RegisteredModelAccessControlResponse) { +} + type RegisteredModelPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -1092,6 +1734,12 @@ type RegisteredModelPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *RegisteredModelPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegisteredModelPermission) { +} + +func (newState *RegisteredModelPermission) SyncEffectiveFieldsDuringRead(existingState RegisteredModelPermission) { +} + type RegisteredModelPermissions struct { AccessControlList []RegisteredModelAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -1100,18 +1748,36 @@ type RegisteredModelPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *RegisteredModelPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegisteredModelPermissions) { +} + +func (newState *RegisteredModelPermissions) SyncEffectiveFieldsDuringRead(existingState RegisteredModelPermissions) { +} + type RegisteredModelPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *RegisteredModelPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegisteredModelPermissionsDescription) { +} + +func (newState *RegisteredModelPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState RegisteredModelPermissionsDescription) { +} + type RegisteredModelPermissionsRequest struct { AccessControlList []RegisteredModelAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The registered model for which to get or manage permissions. RegisteredModelId types.String `tfsdk:"-"` } +func (newState *RegisteredModelPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegisteredModelPermissionsRequest) { +} + +func (newState *RegisteredModelPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState RegisteredModelPermissionsRequest) { +} + type RegistryWebhook struct { // Creation time of the object, as a Unix timestamp in milliseconds. CreationTimestamp types.Int64 `tfsdk:"creation_timestamp" tf:"optional"` @@ -1172,6 +1838,12 @@ type RegistryWebhook struct { Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *RegistryWebhook) SyncEffectiveFieldsDuringCreateOrUpdate(plan RegistryWebhook) { +} + +func (newState *RegistryWebhook) SyncEffectiveFieldsDuringRead(existingState RegistryWebhook) { +} + type RejectTransitionRequest struct { // User-provided comment on the action. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -1191,11 +1863,23 @@ type RejectTransitionRequest struct { Version types.String `tfsdk:"version" tf:""` } +func (newState *RejectTransitionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RejectTransitionRequest) { +} + +func (newState *RejectTransitionRequest) SyncEffectiveFieldsDuringRead(existingState RejectTransitionRequest) { +} + type RejectTransitionRequestResponse struct { // Activity recorded for the action. Activity []Activity `tfsdk:"activity" tf:"optional,object"` } +func (newState *RejectTransitionRequestResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RejectTransitionRequestResponse) { +} + +func (newState *RejectTransitionRequestResponse) SyncEffectiveFieldsDuringRead(existingState RejectTransitionRequestResponse) { +} + type RenameModelRequest struct { // Registered model unique name identifier. Name types.String `tfsdk:"name" tf:""` @@ -1203,26 +1887,62 @@ type RenameModelRequest struct { NewName types.String `tfsdk:"new_name" tf:"optional"` } +func (newState *RenameModelRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RenameModelRequest) { +} + +func (newState *RenameModelRequest) SyncEffectiveFieldsDuringRead(existingState RenameModelRequest) { +} + type RenameModelResponse struct { RegisteredModel []Model `tfsdk:"registered_model" tf:"optional,object"` } +func (newState *RenameModelResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RenameModelResponse) { +} + +func (newState *RenameModelResponse) SyncEffectiveFieldsDuringRead(existingState RenameModelResponse) { +} + type RestoreExperiment struct { // ID of the associated experiment. ExperimentId types.String `tfsdk:"experiment_id" tf:""` } +func (newState *RestoreExperiment) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestoreExperiment) { +} + +func (newState *RestoreExperiment) SyncEffectiveFieldsDuringRead(existingState RestoreExperiment) { +} + type RestoreExperimentResponse struct { } +func (newState *RestoreExperimentResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestoreExperimentResponse) { +} + +func (newState *RestoreExperimentResponse) SyncEffectiveFieldsDuringRead(existingState RestoreExperimentResponse) { +} + type RestoreRun struct { // ID of the run to restore. RunId types.String `tfsdk:"run_id" tf:""` } +func (newState *RestoreRun) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestoreRun) { +} + +func (newState *RestoreRun) SyncEffectiveFieldsDuringRead(existingState RestoreRun) { +} + type RestoreRunResponse struct { } +func (newState *RestoreRunResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestoreRunResponse) { +} + +func (newState *RestoreRunResponse) SyncEffectiveFieldsDuringRead(existingState RestoreRunResponse) { +} + type RestoreRuns struct { // The ID of the experiment containing the runs to restore. ExperimentId types.String `tfsdk:"experiment_id" tf:""` @@ -1235,11 +1955,23 @@ type RestoreRuns struct { MinTimestampMillis types.Int64 `tfsdk:"min_timestamp_millis" tf:""` } +func (newState *RestoreRuns) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestoreRuns) { +} + +func (newState *RestoreRuns) SyncEffectiveFieldsDuringRead(existingState RestoreRuns) { +} + type RestoreRunsResponse struct { // The number of runs restored. RunsRestored types.Int64 `tfsdk:"runs_restored" tf:"optional"` } +func (newState *RestoreRunsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestoreRunsResponse) { +} + +func (newState *RestoreRunsResponse) SyncEffectiveFieldsDuringRead(existingState RestoreRunsResponse) { +} + type Run struct { // Run data. Data []RunData `tfsdk:"data" tf:"optional,object"` @@ -1249,6 +1981,12 @@ type Run struct { Inputs []RunInputs `tfsdk:"inputs" tf:"optional,object"` } +func (newState *Run) SyncEffectiveFieldsDuringCreateOrUpdate(plan Run) { +} + +func (newState *Run) SyncEffectiveFieldsDuringRead(existingState Run) { +} + type RunData struct { // Run metrics. Metrics []Metric `tfsdk:"metrics" tf:"optional"` @@ -1258,6 +1996,12 @@ type RunData struct { Tags []RunTag `tfsdk:"tags" tf:"optional"` } +func (newState *RunData) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunData) { +} + +func (newState *RunData) SyncEffectiveFieldsDuringRead(existingState RunData) { +} + type RunInfo struct { // URI of the directory where artifacts should be uploaded. This can be a // local path (starting with "/"), or a distributed file system (DFS) path, @@ -1285,11 +2029,23 @@ type RunInfo struct { UserId types.String `tfsdk:"user_id" tf:"optional"` } +func (newState *RunInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunInfo) { +} + +func (newState *RunInfo) SyncEffectiveFieldsDuringRead(existingState RunInfo) { +} + type RunInputs struct { // Run metrics. DatasetInputs []DatasetInput `tfsdk:"dataset_inputs" tf:"optional"` } +func (newState *RunInputs) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunInputs) { +} + +func (newState *RunInputs) SyncEffectiveFieldsDuringRead(existingState RunInputs) { +} + type RunTag struct { // The tag key. Key types.String `tfsdk:"key" tf:"optional"` @@ -1297,6 +2053,12 @@ type RunTag struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *RunTag) SyncEffectiveFieldsDuringCreateOrUpdate(plan RunTag) { +} + +func (newState *RunTag) SyncEffectiveFieldsDuringRead(existingState RunTag) { +} + type SearchExperiments struct { // String representing a SQL filter condition (e.g. "name ILIKE // 'my-experiment%'") @@ -1315,6 +2077,12 @@ type SearchExperiments struct { ViewType types.String `tfsdk:"view_type" tf:"optional"` } +func (newState *SearchExperiments) SyncEffectiveFieldsDuringCreateOrUpdate(plan SearchExperiments) { +} + +func (newState *SearchExperiments) SyncEffectiveFieldsDuringRead(existingState SearchExperiments) { +} + type SearchExperimentsResponse struct { // Experiments that match the search criteria Experiments []Experiment `tfsdk:"experiments" tf:"optional"` @@ -1323,6 +2091,12 @@ type SearchExperimentsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *SearchExperimentsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SearchExperimentsResponse) { +} + +func (newState *SearchExperimentsResponse) SyncEffectiveFieldsDuringRead(existingState SearchExperimentsResponse) { +} + // Searches model versions type SearchModelVersionsRequest struct { // String filter condition, like "name='my-model-name'". Must be a single @@ -1339,6 +2113,12 @@ type SearchModelVersionsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *SearchModelVersionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan SearchModelVersionsRequest) { +} + +func (newState *SearchModelVersionsRequest) SyncEffectiveFieldsDuringRead(existingState SearchModelVersionsRequest) { +} + type SearchModelVersionsResponse struct { // Models that match the search criteria ModelVersions []ModelVersion `tfsdk:"model_versions" tf:"optional"` @@ -1347,6 +2127,12 @@ type SearchModelVersionsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *SearchModelVersionsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SearchModelVersionsResponse) { +} + +func (newState *SearchModelVersionsResponse) SyncEffectiveFieldsDuringRead(existingState SearchModelVersionsResponse) { +} + // Search models type SearchModelsRequest struct { // String filter condition, like "name LIKE 'my-model-name'". Interpreted in @@ -1363,6 +2149,12 @@ type SearchModelsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *SearchModelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan SearchModelsRequest) { +} + +func (newState *SearchModelsRequest) SyncEffectiveFieldsDuringRead(existingState SearchModelsRequest) { +} + type SearchModelsResponse struct { // Pagination token to request the next page of models. NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` @@ -1370,6 +2162,12 @@ type SearchModelsResponse struct { RegisteredModels []Model `tfsdk:"registered_models" tf:"optional"` } +func (newState *SearchModelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SearchModelsResponse) { +} + +func (newState *SearchModelsResponse) SyncEffectiveFieldsDuringRead(existingState SearchModelsResponse) { +} + type SearchRuns struct { // List of experiment IDs to search over. ExperimentIds []types.String `tfsdk:"experiment_ids" tf:"optional"` @@ -1402,6 +2200,12 @@ type SearchRuns struct { RunViewType types.String `tfsdk:"run_view_type" tf:"optional"` } +func (newState *SearchRuns) SyncEffectiveFieldsDuringCreateOrUpdate(plan SearchRuns) { +} + +func (newState *SearchRuns) SyncEffectiveFieldsDuringRead(existingState SearchRuns) { +} + type SearchRunsResponse struct { // Token for the next page of runs. NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` @@ -1409,6 +2213,12 @@ type SearchRunsResponse struct { Runs []Run `tfsdk:"runs" tf:"optional"` } +func (newState *SearchRunsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SearchRunsResponse) { +} + +func (newState *SearchRunsResponse) SyncEffectiveFieldsDuringRead(existingState SearchRunsResponse) { +} + type SetExperimentTag struct { // ID of the experiment under which to log the tag. Must be provided. ExperimentId types.String `tfsdk:"experiment_id" tf:""` @@ -1421,9 +2231,21 @@ type SetExperimentTag struct { Value types.String `tfsdk:"value" tf:""` } +func (newState *SetExperimentTag) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetExperimentTag) { +} + +func (newState *SetExperimentTag) SyncEffectiveFieldsDuringRead(existingState SetExperimentTag) { +} + type SetExperimentTagResponse struct { } +func (newState *SetExperimentTagResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetExperimentTagResponse) { +} + +func (newState *SetExperimentTagResponse) SyncEffectiveFieldsDuringRead(existingState SetExperimentTagResponse) { +} + type SetModelTagRequest struct { // Name of the tag. Maximum size depends on storage backend. If a tag with // this name already exists, its preexisting value will be replaced by the @@ -1438,9 +2260,21 @@ type SetModelTagRequest struct { Value types.String `tfsdk:"value" tf:""` } +func (newState *SetModelTagRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetModelTagRequest) { +} + +func (newState *SetModelTagRequest) SyncEffectiveFieldsDuringRead(existingState SetModelTagRequest) { +} + type SetModelTagResponse struct { } +func (newState *SetModelTagResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetModelTagResponse) { +} + +func (newState *SetModelTagResponse) SyncEffectiveFieldsDuringRead(existingState SetModelTagResponse) { +} + type SetModelVersionTagRequest struct { // Name of the tag. Maximum size depends on storage backend. If a tag with // this name already exists, its preexisting value will be replaced by the @@ -1457,9 +2291,21 @@ type SetModelVersionTagRequest struct { Version types.String `tfsdk:"version" tf:""` } +func (newState *SetModelVersionTagRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetModelVersionTagRequest) { +} + +func (newState *SetModelVersionTagRequest) SyncEffectiveFieldsDuringRead(existingState SetModelVersionTagRequest) { +} + type SetModelVersionTagResponse struct { } +func (newState *SetModelVersionTagResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetModelVersionTagResponse) { +} + +func (newState *SetModelVersionTagResponse) SyncEffectiveFieldsDuringRead(existingState SetModelVersionTagResponse) { +} + type SetTag struct { // Name of the tag. Maximum size depends on storage backend. All storage // backends are guaranteed to support key values up to 250 bytes in size. @@ -1475,9 +2321,21 @@ type SetTag struct { Value types.String `tfsdk:"value" tf:""` } +func (newState *SetTag) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetTag) { +} + +func (newState *SetTag) SyncEffectiveFieldsDuringRead(existingState SetTag) { +} + type SetTagResponse struct { } +func (newState *SetTagResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetTagResponse) { +} + +func (newState *SetTagResponse) SyncEffectiveFieldsDuringRead(existingState SetTagResponse) { +} + // Test webhook response object. type TestRegistryWebhook struct { // Body of the response from the webhook URL @@ -1486,6 +2344,12 @@ type TestRegistryWebhook struct { StatusCode types.Int64 `tfsdk:"status_code" tf:"optional"` } +func (newState *TestRegistryWebhook) SyncEffectiveFieldsDuringCreateOrUpdate(plan TestRegistryWebhook) { +} + +func (newState *TestRegistryWebhook) SyncEffectiveFieldsDuringRead(existingState TestRegistryWebhook) { +} + type TestRegistryWebhookRequest struct { // If `event` is specified, the test trigger uses the specified event. If // `event` is not specified, the test trigger uses a randomly chosen event @@ -1495,11 +2359,23 @@ type TestRegistryWebhookRequest struct { Id types.String `tfsdk:"id" tf:""` } +func (newState *TestRegistryWebhookRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan TestRegistryWebhookRequest) { +} + +func (newState *TestRegistryWebhookRequest) SyncEffectiveFieldsDuringRead(existingState TestRegistryWebhookRequest) { +} + type TestRegistryWebhookResponse struct { // Test webhook response object. Webhook []TestRegistryWebhook `tfsdk:"webhook" tf:"optional,object"` } +func (newState *TestRegistryWebhookResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan TestRegistryWebhookResponse) { +} + +func (newState *TestRegistryWebhookResponse) SyncEffectiveFieldsDuringRead(existingState TestRegistryWebhookResponse) { +} + type TransitionModelVersionStageDatabricks struct { // Specifies whether to archive all current model versions in the target // stage. @@ -1522,6 +2398,12 @@ type TransitionModelVersionStageDatabricks struct { Version types.String `tfsdk:"version" tf:""` } +func (newState *TransitionModelVersionStageDatabricks) SyncEffectiveFieldsDuringCreateOrUpdate(plan TransitionModelVersionStageDatabricks) { +} + +func (newState *TransitionModelVersionStageDatabricks) SyncEffectiveFieldsDuringRead(existingState TransitionModelVersionStageDatabricks) { +} + // Transition request details. type TransitionRequest struct { // Array of actions on the activity allowed for the current viewer. @@ -1545,10 +2427,22 @@ type TransitionRequest struct { UserId types.String `tfsdk:"user_id" tf:"optional"` } +func (newState *TransitionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan TransitionRequest) { +} + +func (newState *TransitionRequest) SyncEffectiveFieldsDuringRead(existingState TransitionRequest) { +} + type TransitionStageResponse struct { ModelVersion []ModelVersionDatabricks `tfsdk:"model_version" tf:"optional,object"` } +func (newState *TransitionStageResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan TransitionStageResponse) { +} + +func (newState *TransitionStageResponse) SyncEffectiveFieldsDuringRead(existingState TransitionStageResponse) { +} + type UpdateComment struct { // User-provided comment on the action. Comment types.String `tfsdk:"comment" tf:""` @@ -1556,11 +2450,23 @@ type UpdateComment struct { Id types.String `tfsdk:"id" tf:""` } +func (newState *UpdateComment) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateComment) { +} + +func (newState *UpdateComment) SyncEffectiveFieldsDuringRead(existingState UpdateComment) { +} + type UpdateCommentResponse struct { // Comment details. Comment []CommentObject `tfsdk:"comment" tf:"optional,object"` } +func (newState *UpdateCommentResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateCommentResponse) { +} + +func (newState *UpdateCommentResponse) SyncEffectiveFieldsDuringRead(existingState UpdateCommentResponse) { +} + type UpdateExperiment struct { // ID of the associated experiment. ExperimentId types.String `tfsdk:"experiment_id" tf:""` @@ -1569,9 +2475,21 @@ type UpdateExperiment struct { NewName types.String `tfsdk:"new_name" tf:"optional"` } +func (newState *UpdateExperiment) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateExperiment) { +} + +func (newState *UpdateExperiment) SyncEffectiveFieldsDuringRead(existingState UpdateExperiment) { +} + type UpdateExperimentResponse struct { } +func (newState *UpdateExperimentResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateExperimentResponse) { +} + +func (newState *UpdateExperimentResponse) SyncEffectiveFieldsDuringRead(existingState UpdateExperimentResponse) { +} + type UpdateModelRequest struct { // If provided, updates the description for this `registered_model`. Description types.String `tfsdk:"description" tf:"optional"` @@ -1579,9 +2497,21 @@ type UpdateModelRequest struct { Name types.String `tfsdk:"name" tf:""` } +func (newState *UpdateModelRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateModelRequest) { +} + +func (newState *UpdateModelRequest) SyncEffectiveFieldsDuringRead(existingState UpdateModelRequest) { +} + type UpdateModelResponse struct { } +func (newState *UpdateModelResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateModelResponse) { +} + +func (newState *UpdateModelResponse) SyncEffectiveFieldsDuringRead(existingState UpdateModelResponse) { +} + type UpdateModelVersionRequest struct { // If provided, updates the description for this `registered_model`. Description types.String `tfsdk:"description" tf:"optional"` @@ -1591,9 +2521,21 @@ type UpdateModelVersionRequest struct { Version types.String `tfsdk:"version" tf:""` } +func (newState *UpdateModelVersionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateModelVersionRequest) { +} + +func (newState *UpdateModelVersionRequest) SyncEffectiveFieldsDuringRead(existingState UpdateModelVersionRequest) { +} + type UpdateModelVersionResponse struct { } +func (newState *UpdateModelVersionResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateModelVersionResponse) { +} + +func (newState *UpdateModelVersionResponse) SyncEffectiveFieldsDuringRead(existingState UpdateModelVersionResponse) { +} + type UpdateRegistryWebhook struct { // User-specified description for the webhook. Description types.String `tfsdk:"description" tf:"optional"` @@ -1648,6 +2590,12 @@ type UpdateRegistryWebhook struct { Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *UpdateRegistryWebhook) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateRegistryWebhook) { +} + +func (newState *UpdateRegistryWebhook) SyncEffectiveFieldsDuringRead(existingState UpdateRegistryWebhook) { +} + type UpdateRun struct { // Unix timestamp in milliseconds of when the run ended. EndTime types.Int64 `tfsdk:"end_time" tf:"optional"` @@ -1660,10 +2608,28 @@ type UpdateRun struct { Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *UpdateRun) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateRun) { +} + +func (newState *UpdateRun) SyncEffectiveFieldsDuringRead(existingState UpdateRun) { +} + type UpdateRunResponse struct { // Updated metadata of the run. RunInfo []RunInfo `tfsdk:"run_info" tf:"optional,object"` } +func (newState *UpdateRunResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateRunResponse) { +} + +func (newState *UpdateRunResponse) SyncEffectiveFieldsDuringRead(existingState UpdateRunResponse) { +} + type UpdateWebhookResponse struct { } + +func (newState *UpdateWebhookResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateWebhookResponse) { +} + +func (newState *UpdateWebhookResponse) SyncEffectiveFieldsDuringRead(existingState UpdateWebhookResponse) { +} diff --git a/internal/service/oauth2_tf/model.go b/internal/service/oauth2_tf/model.go index f7959bfcf5..e738e7f094 100755 --- a/internal/service/oauth2_tf/model.go +++ b/internal/service/oauth2_tf/model.go @@ -29,6 +29,12 @@ type CreateCustomAppIntegration struct { TokenAccessPolicy []TokenAccessPolicy `tfsdk:"token_access_policy" tf:"optional,object"` } +func (newState *CreateCustomAppIntegration) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCustomAppIntegration) { +} + +func (newState *CreateCustomAppIntegration) SyncEffectiveFieldsDuringRead(existingState CreateCustomAppIntegration) { +} + type CreateCustomAppIntegrationOutput struct { // OAuth client-id generated by the Databricks ClientId types.String `tfsdk:"client_id" tf:"optional"` @@ -39,6 +45,12 @@ type CreateCustomAppIntegrationOutput struct { IntegrationId types.String `tfsdk:"integration_id" tf:"optional"` } +func (newState *CreateCustomAppIntegrationOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCustomAppIntegrationOutput) { +} + +func (newState *CreateCustomAppIntegrationOutput) SyncEffectiveFieldsDuringRead(existingState CreateCustomAppIntegrationOutput) { +} + type CreatePublishedAppIntegration struct { // App id of the OAuth published app integration. For example power-bi, // tableau-deskop @@ -47,17 +59,35 @@ type CreatePublishedAppIntegration struct { TokenAccessPolicy []TokenAccessPolicy `tfsdk:"token_access_policy" tf:"optional,object"` } +func (newState *CreatePublishedAppIntegration) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreatePublishedAppIntegration) { +} + +func (newState *CreatePublishedAppIntegration) SyncEffectiveFieldsDuringRead(existingState CreatePublishedAppIntegration) { +} + type CreatePublishedAppIntegrationOutput struct { // Unique integration id for the published OAuth app IntegrationId types.String `tfsdk:"integration_id" tf:"optional"` } +func (newState *CreatePublishedAppIntegrationOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreatePublishedAppIntegrationOutput) { +} + +func (newState *CreatePublishedAppIntegrationOutput) SyncEffectiveFieldsDuringRead(existingState CreatePublishedAppIntegrationOutput) { +} + // Create service principal secret type CreateServicePrincipalSecretRequest struct { // The service principal ID. ServicePrincipalId types.Int64 `tfsdk:"-"` } +func (newState *CreateServicePrincipalSecretRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateServicePrincipalSecretRequest) { +} + +func (newState *CreateServicePrincipalSecretRequest) SyncEffectiveFieldsDuringRead(existingState CreateServicePrincipalSecretRequest) { +} + type CreateServicePrincipalSecretResponse struct { // UTC time when the secret was created CreateTime types.String `tfsdk:"create_time" tf:"optional"` @@ -73,6 +103,12 @@ type CreateServicePrincipalSecretResponse struct { UpdateTime types.String `tfsdk:"update_time" tf:"optional"` } +func (newState *CreateServicePrincipalSecretResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateServicePrincipalSecretResponse) { +} + +func (newState *CreateServicePrincipalSecretResponse) SyncEffectiveFieldsDuringRead(existingState CreateServicePrincipalSecretResponse) { +} + type DataPlaneInfo struct { // Authorization details as a string. AuthorizationDetails types.String `tfsdk:"authorization_details" tf:"optional"` @@ -80,25 +116,61 @@ type DataPlaneInfo struct { EndpointUrl types.String `tfsdk:"endpoint_url" tf:"optional"` } +func (newState *DataPlaneInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan DataPlaneInfo) { +} + +func (newState *DataPlaneInfo) SyncEffectiveFieldsDuringRead(existingState DataPlaneInfo) { +} + type DeleteCustomAppIntegrationOutput struct { } +func (newState *DeleteCustomAppIntegrationOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteCustomAppIntegrationOutput) { +} + +func (newState *DeleteCustomAppIntegrationOutput) SyncEffectiveFieldsDuringRead(existingState DeleteCustomAppIntegrationOutput) { +} + // Delete Custom OAuth App Integration type DeleteCustomAppIntegrationRequest struct { IntegrationId types.String `tfsdk:"-"` } +func (newState *DeleteCustomAppIntegrationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteCustomAppIntegrationRequest) { +} + +func (newState *DeleteCustomAppIntegrationRequest) SyncEffectiveFieldsDuringRead(existingState DeleteCustomAppIntegrationRequest) { +} + type DeletePublishedAppIntegrationOutput struct { } +func (newState *DeletePublishedAppIntegrationOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeletePublishedAppIntegrationOutput) { +} + +func (newState *DeletePublishedAppIntegrationOutput) SyncEffectiveFieldsDuringRead(existingState DeletePublishedAppIntegrationOutput) { +} + // Delete Published OAuth App Integration type DeletePublishedAppIntegrationRequest struct { IntegrationId types.String `tfsdk:"-"` } +func (newState *DeletePublishedAppIntegrationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeletePublishedAppIntegrationRequest) { +} + +func (newState *DeletePublishedAppIntegrationRequest) SyncEffectiveFieldsDuringRead(existingState DeletePublishedAppIntegrationRequest) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + // Delete service principal secret type DeleteServicePrincipalSecretRequest struct { // The secret ID. @@ -107,6 +179,12 @@ type DeleteServicePrincipalSecretRequest struct { ServicePrincipalId types.Int64 `tfsdk:"-"` } +func (newState *DeleteServicePrincipalSecretRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteServicePrincipalSecretRequest) { +} + +func (newState *DeleteServicePrincipalSecretRequest) SyncEffectiveFieldsDuringRead(existingState DeleteServicePrincipalSecretRequest) { +} + type GetCustomAppIntegrationOutput struct { // The client id of the custom OAuth app ClientId types.String `tfsdk:"client_id" tf:"optional"` @@ -131,11 +209,23 @@ type GetCustomAppIntegrationOutput struct { TokenAccessPolicy []TokenAccessPolicy `tfsdk:"token_access_policy" tf:"optional,object"` } +func (newState *GetCustomAppIntegrationOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetCustomAppIntegrationOutput) { +} + +func (newState *GetCustomAppIntegrationOutput) SyncEffectiveFieldsDuringRead(existingState GetCustomAppIntegrationOutput) { +} + // Get OAuth Custom App Integration type GetCustomAppIntegrationRequest struct { IntegrationId types.String `tfsdk:"-"` } +func (newState *GetCustomAppIntegrationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetCustomAppIntegrationRequest) { +} + +func (newState *GetCustomAppIntegrationRequest) SyncEffectiveFieldsDuringRead(existingState GetCustomAppIntegrationRequest) { +} + type GetCustomAppIntegrationsOutput struct { // List of Custom OAuth App Integrations defined for the account. Apps []GetCustomAppIntegrationOutput `tfsdk:"apps" tf:"optional"` @@ -143,6 +233,12 @@ type GetCustomAppIntegrationsOutput struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *GetCustomAppIntegrationsOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetCustomAppIntegrationsOutput) { +} + +func (newState *GetCustomAppIntegrationsOutput) SyncEffectiveFieldsDuringRead(existingState GetCustomAppIntegrationsOutput) { +} + type GetPublishedAppIntegrationOutput struct { // App-id of the published app integration AppId types.String `tfsdk:"app_id" tf:"optional"` @@ -158,11 +254,23 @@ type GetPublishedAppIntegrationOutput struct { TokenAccessPolicy []TokenAccessPolicy `tfsdk:"token_access_policy" tf:"optional,object"` } +func (newState *GetPublishedAppIntegrationOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPublishedAppIntegrationOutput) { +} + +func (newState *GetPublishedAppIntegrationOutput) SyncEffectiveFieldsDuringRead(existingState GetPublishedAppIntegrationOutput) { +} + // Get OAuth Published App Integration type GetPublishedAppIntegrationRequest struct { IntegrationId types.String `tfsdk:"-"` } +func (newState *GetPublishedAppIntegrationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPublishedAppIntegrationRequest) { +} + +func (newState *GetPublishedAppIntegrationRequest) SyncEffectiveFieldsDuringRead(existingState GetPublishedAppIntegrationRequest) { +} + type GetPublishedAppIntegrationsOutput struct { // List of Published OAuth App Integrations defined for the account. Apps []GetPublishedAppIntegrationOutput `tfsdk:"apps" tf:"optional"` @@ -170,6 +278,12 @@ type GetPublishedAppIntegrationsOutput struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *GetPublishedAppIntegrationsOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPublishedAppIntegrationsOutput) { +} + +func (newState *GetPublishedAppIntegrationsOutput) SyncEffectiveFieldsDuringRead(existingState GetPublishedAppIntegrationsOutput) { +} + type GetPublishedAppsOutput struct { // List of Published OAuth Apps. Apps []PublishedAppOutput `tfsdk:"apps" tf:"optional"` @@ -178,6 +292,12 @@ type GetPublishedAppsOutput struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *GetPublishedAppsOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPublishedAppsOutput) { +} + +func (newState *GetPublishedAppsOutput) SyncEffectiveFieldsDuringRead(existingState GetPublishedAppsOutput) { +} + // Get custom oauth app integrations type ListCustomAppIntegrationsRequest struct { IncludeCreatorUsername types.Bool `tfsdk:"-"` @@ -187,6 +307,12 @@ type ListCustomAppIntegrationsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListCustomAppIntegrationsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListCustomAppIntegrationsRequest) { +} + +func (newState *ListCustomAppIntegrationsRequest) SyncEffectiveFieldsDuringRead(existingState ListCustomAppIntegrationsRequest) { +} + // Get all the published OAuth apps type ListOAuthPublishedAppsRequest struct { // The max number of OAuth published apps to return in one page. @@ -195,6 +321,12 @@ type ListOAuthPublishedAppsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListOAuthPublishedAppsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListOAuthPublishedAppsRequest) { +} + +func (newState *ListOAuthPublishedAppsRequest) SyncEffectiveFieldsDuringRead(existingState ListOAuthPublishedAppsRequest) { +} + // Get published oauth app integrations type ListPublishedAppIntegrationsRequest struct { PageSize types.Int64 `tfsdk:"-"` @@ -202,17 +334,35 @@ type ListPublishedAppIntegrationsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListPublishedAppIntegrationsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListPublishedAppIntegrationsRequest) { +} + +func (newState *ListPublishedAppIntegrationsRequest) SyncEffectiveFieldsDuringRead(existingState ListPublishedAppIntegrationsRequest) { +} + // List service principal secrets type ListServicePrincipalSecretsRequest struct { // The service principal ID. ServicePrincipalId types.Int64 `tfsdk:"-"` } +func (newState *ListServicePrincipalSecretsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListServicePrincipalSecretsRequest) { +} + +func (newState *ListServicePrincipalSecretsRequest) SyncEffectiveFieldsDuringRead(existingState ListServicePrincipalSecretsRequest) { +} + type ListServicePrincipalSecretsResponse struct { // List of the secrets Secrets []SecretInfo `tfsdk:"secrets" tf:"optional"` } +func (newState *ListServicePrincipalSecretsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListServicePrincipalSecretsResponse) { +} + +func (newState *ListServicePrincipalSecretsResponse) SyncEffectiveFieldsDuringRead(existingState ListServicePrincipalSecretsResponse) { +} + type PublishedAppOutput struct { // Unique ID of the published OAuth app. AppId types.String `tfsdk:"app_id" tf:"optional"` @@ -232,6 +382,12 @@ type PublishedAppOutput struct { Scopes []types.String `tfsdk:"scopes" tf:"optional"` } +func (newState *PublishedAppOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan PublishedAppOutput) { +} + +func (newState *PublishedAppOutput) SyncEffectiveFieldsDuringRead(existingState PublishedAppOutput) { +} + type SecretInfo struct { // UTC time when the secret was created CreateTime types.String `tfsdk:"create_time" tf:"optional"` @@ -245,6 +401,12 @@ type SecretInfo struct { UpdateTime types.String `tfsdk:"update_time" tf:"optional"` } +func (newState *SecretInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan SecretInfo) { +} + +func (newState *SecretInfo) SyncEffectiveFieldsDuringRead(existingState SecretInfo) { +} + type TokenAccessPolicy struct { // access token time to live in minutes AccessTokenTtlInMinutes types.Int64 `tfsdk:"access_token_ttl_in_minutes" tf:"optional"` @@ -252,6 +414,12 @@ type TokenAccessPolicy struct { RefreshTokenTtlInMinutes types.Int64 `tfsdk:"refresh_token_ttl_in_minutes" tf:"optional"` } +func (newState *TokenAccessPolicy) SyncEffectiveFieldsDuringCreateOrUpdate(plan TokenAccessPolicy) { +} + +func (newState *TokenAccessPolicy) SyncEffectiveFieldsDuringRead(existingState TokenAccessPolicy) { +} + type UpdateCustomAppIntegration struct { IntegrationId types.String `tfsdk:"-"` // List of OAuth redirect urls to be updated in the custom OAuth app @@ -261,14 +429,38 @@ type UpdateCustomAppIntegration struct { TokenAccessPolicy []TokenAccessPolicy `tfsdk:"token_access_policy" tf:"optional,object"` } +func (newState *UpdateCustomAppIntegration) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateCustomAppIntegration) { +} + +func (newState *UpdateCustomAppIntegration) SyncEffectiveFieldsDuringRead(existingState UpdateCustomAppIntegration) { +} + type UpdateCustomAppIntegrationOutput struct { } +func (newState *UpdateCustomAppIntegrationOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateCustomAppIntegrationOutput) { +} + +func (newState *UpdateCustomAppIntegrationOutput) SyncEffectiveFieldsDuringRead(existingState UpdateCustomAppIntegrationOutput) { +} + type UpdatePublishedAppIntegration struct { IntegrationId types.String `tfsdk:"-"` // Token access policy to be updated in the published OAuth app integration TokenAccessPolicy []TokenAccessPolicy `tfsdk:"token_access_policy" tf:"optional,object"` } +func (newState *UpdatePublishedAppIntegration) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdatePublishedAppIntegration) { +} + +func (newState *UpdatePublishedAppIntegration) SyncEffectiveFieldsDuringRead(existingState UpdatePublishedAppIntegration) { +} + type UpdatePublishedAppIntegrationOutput struct { } + +func (newState *UpdatePublishedAppIntegrationOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdatePublishedAppIntegrationOutput) { +} + +func (newState *UpdatePublishedAppIntegrationOutput) SyncEffectiveFieldsDuringRead(existingState UpdatePublishedAppIntegrationOutput) { +} diff --git a/internal/service/pipelines_tf/model.go b/internal/service/pipelines_tf/model.go index c4ad05458b..8adcfa0bfa 100755 --- a/internal/service/pipelines_tf/model.go +++ b/internal/service/pipelines_tf/model.go @@ -76,6 +76,12 @@ type CreatePipeline struct { Trigger []PipelineTrigger `tfsdk:"trigger" tf:"optional,object"` } +func (newState *CreatePipeline) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreatePipeline) { +} + +func (newState *CreatePipeline) SyncEffectiveFieldsDuringRead(existingState CreatePipeline) { +} + type CreatePipelineResponse struct { // Only returned when dry_run is true. EffectiveSettings []PipelineSpec `tfsdk:"effective_settings" tf:"optional,object"` @@ -84,12 +90,24 @@ type CreatePipelineResponse struct { PipelineId types.String `tfsdk:"pipeline_id" tf:"optional"` } +func (newState *CreatePipelineResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreatePipelineResponse) { +} + +func (newState *CreatePipelineResponse) SyncEffectiveFieldsDuringRead(existingState CreatePipelineResponse) { +} + type CronTrigger struct { QuartzCronSchedule types.String `tfsdk:"quartz_cron_schedule" tf:"optional"` TimezoneId types.String `tfsdk:"timezone_id" tf:"optional"` } +func (newState *CronTrigger) SyncEffectiveFieldsDuringCreateOrUpdate(plan CronTrigger) { +} + +func (newState *CronTrigger) SyncEffectiveFieldsDuringRead(existingState CronTrigger) { +} + type DataPlaneId struct { // The instance name of the data plane emitting an event. Instance types.String `tfsdk:"instance" tf:"optional"` @@ -97,14 +115,32 @@ type DataPlaneId struct { SeqNo types.Int64 `tfsdk:"seq_no" tf:"optional"` } +func (newState *DataPlaneId) SyncEffectiveFieldsDuringCreateOrUpdate(plan DataPlaneId) { +} + +func (newState *DataPlaneId) SyncEffectiveFieldsDuringRead(existingState DataPlaneId) { +} + // Delete a pipeline type DeletePipelineRequest struct { PipelineId types.String `tfsdk:"-"` } +func (newState *DeletePipelineRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeletePipelineRequest) { +} + +func (newState *DeletePipelineRequest) SyncEffectiveFieldsDuringRead(existingState DeletePipelineRequest) { +} + type DeletePipelineResponse struct { } +func (newState *DeletePipelineResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeletePipelineResponse) { +} + +func (newState *DeletePipelineResponse) SyncEffectiveFieldsDuringRead(existingState DeletePipelineResponse) { +} + type EditPipeline struct { // If false, deployment will fail if name has changed and conflicts the name // of another pipeline. @@ -170,9 +206,21 @@ type EditPipeline struct { Trigger []PipelineTrigger `tfsdk:"trigger" tf:"optional,object"` } +func (newState *EditPipeline) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditPipeline) { +} + +func (newState *EditPipeline) SyncEffectiveFieldsDuringRead(existingState EditPipeline) { +} + type EditPipelineResponse struct { } +func (newState *EditPipelineResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditPipelineResponse) { +} + +func (newState *EditPipelineResponse) SyncEffectiveFieldsDuringRead(existingState EditPipelineResponse) { +} + type ErrorDetail struct { // The exception thrown for this error, with its chain of cause. Exceptions []SerializedException `tfsdk:"exceptions" tf:"optional"` @@ -180,11 +228,23 @@ type ErrorDetail struct { Fatal types.Bool `tfsdk:"fatal" tf:"optional"` } +func (newState *ErrorDetail) SyncEffectiveFieldsDuringCreateOrUpdate(plan ErrorDetail) { +} + +func (newState *ErrorDetail) SyncEffectiveFieldsDuringRead(existingState ErrorDetail) { +} + type FileLibrary struct { // The absolute path of the file. Path types.String `tfsdk:"path" tf:"optional"` } +func (newState *FileLibrary) SyncEffectiveFieldsDuringCreateOrUpdate(plan FileLibrary) { +} + +func (newState *FileLibrary) SyncEffectiveFieldsDuringRead(existingState FileLibrary) { +} + type Filters struct { // Paths to exclude. Exclude []types.String `tfsdk:"exclude" tf:"optional"` @@ -192,28 +252,58 @@ type Filters struct { Include []types.String `tfsdk:"include" tf:"optional"` } +func (newState *Filters) SyncEffectiveFieldsDuringCreateOrUpdate(plan Filters) { +} + +func (newState *Filters) SyncEffectiveFieldsDuringRead(existingState Filters) { +} + // Get pipeline permission levels type GetPipelinePermissionLevelsRequest struct { // The pipeline for which to get or manage permissions. PipelineId types.String `tfsdk:"-"` } +func (newState *GetPipelinePermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPipelinePermissionLevelsRequest) { +} + +func (newState *GetPipelinePermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetPipelinePermissionLevelsRequest) { +} + type GetPipelinePermissionLevelsResponse struct { // Specific permission levels PermissionLevels []PipelinePermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetPipelinePermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPipelinePermissionLevelsResponse) { +} + +func (newState *GetPipelinePermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetPipelinePermissionLevelsResponse) { +} + // Get pipeline permissions type GetPipelinePermissionsRequest struct { // The pipeline for which to get or manage permissions. PipelineId types.String `tfsdk:"-"` } +func (newState *GetPipelinePermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPipelinePermissionsRequest) { +} + +func (newState *GetPipelinePermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetPipelinePermissionsRequest) { +} + // Get a pipeline type GetPipelineRequest struct { PipelineId types.String `tfsdk:"-"` } +func (newState *GetPipelineRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPipelineRequest) { +} + +func (newState *GetPipelineRequest) SyncEffectiveFieldsDuringRead(existingState GetPipelineRequest) { +} + type GetPipelineResponse struct { // An optional message detailing the cause of the pipeline state. Cause types.String `tfsdk:"cause" tf:"optional"` @@ -243,6 +333,12 @@ type GetPipelineResponse struct { State types.String `tfsdk:"state" tf:"optional"` } +func (newState *GetPipelineResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPipelineResponse) { +} + +func (newState *GetPipelineResponse) SyncEffectiveFieldsDuringRead(existingState GetPipelineResponse) { +} + // Get a pipeline update type GetUpdateRequest struct { // The ID of the pipeline. @@ -251,18 +347,38 @@ type GetUpdateRequest struct { UpdateId types.String `tfsdk:"-"` } +func (newState *GetUpdateRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetUpdateRequest) { +} + +func (newState *GetUpdateRequest) SyncEffectiveFieldsDuringRead(existingState GetUpdateRequest) { +} + type GetUpdateResponse struct { // The current update info. Update []UpdateInfo `tfsdk:"update" tf:"optional,object"` } +func (newState *GetUpdateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetUpdateResponse) { +} + +func (newState *GetUpdateResponse) SyncEffectiveFieldsDuringRead(existingState GetUpdateResponse) { +} + type IngestionConfig struct { + // Select tables from a specific source report. + Report []ReportSpec `tfsdk:"report" tf:"optional,object"` // Select tables from a specific source schema. Schema []SchemaSpec `tfsdk:"schema" tf:"optional,object"` // Select tables from a specific source table. Table []TableSpec `tfsdk:"table" tf:"optional,object"` } +func (newState *IngestionConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan IngestionConfig) { +} + +func (newState *IngestionConfig) SyncEffectiveFieldsDuringRead(existingState IngestionConfig) { +} + type IngestionGatewayPipelineDefinition struct { // Immutable. The Unity Catalog connection this gateway pipeline uses to // communicate with the source. @@ -280,6 +396,12 @@ type IngestionGatewayPipelineDefinition struct { GatewayStorageSchema types.String `tfsdk:"gateway_storage_schema" tf:"optional"` } +func (newState *IngestionGatewayPipelineDefinition) SyncEffectiveFieldsDuringCreateOrUpdate(plan IngestionGatewayPipelineDefinition) { +} + +func (newState *IngestionGatewayPipelineDefinition) SyncEffectiveFieldsDuringRead(existingState IngestionGatewayPipelineDefinition) { +} + type IngestionPipelineDefinition struct { // Immutable. The Unity Catalog connection this ingestion pipeline uses to // communicate with the source. Specify either ingestion_gateway_id or @@ -297,6 +419,12 @@ type IngestionPipelineDefinition struct { TableConfiguration []TableSpecificConfig `tfsdk:"table_configuration" tf:"optional,object"` } +func (newState *IngestionPipelineDefinition) SyncEffectiveFieldsDuringCreateOrUpdate(plan IngestionPipelineDefinition) { +} + +func (newState *IngestionPipelineDefinition) SyncEffectiveFieldsDuringRead(existingState IngestionPipelineDefinition) { +} + // List pipeline events type ListPipelineEventsRequest struct { // Criteria to select a subset of results, expressed using a SQL-like @@ -324,6 +452,12 @@ type ListPipelineEventsRequest struct { PipelineId types.String `tfsdk:"-"` } +func (newState *ListPipelineEventsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListPipelineEventsRequest) { +} + +func (newState *ListPipelineEventsRequest) SyncEffectiveFieldsDuringRead(existingState ListPipelineEventsRequest) { +} + type ListPipelineEventsResponse struct { // The list of events matching the request criteria. Events []PipelineEvent `tfsdk:"events" tf:"optional"` @@ -333,6 +467,12 @@ type ListPipelineEventsResponse struct { PrevPageToken types.String `tfsdk:"prev_page_token" tf:"optional"` } +func (newState *ListPipelineEventsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListPipelineEventsResponse) { +} + +func (newState *ListPipelineEventsResponse) SyncEffectiveFieldsDuringRead(existingState ListPipelineEventsResponse) { +} + // List pipelines type ListPipelinesRequest struct { // Select a subset of results based on the specified criteria. The supported @@ -358,6 +498,12 @@ type ListPipelinesRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListPipelinesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListPipelinesRequest) { +} + +func (newState *ListPipelinesRequest) SyncEffectiveFieldsDuringRead(existingState ListPipelinesRequest) { +} + type ListPipelinesResponse struct { // If present, a token to fetch the next page of events. NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` @@ -365,6 +511,12 @@ type ListPipelinesResponse struct { Statuses []PipelineStateInfo `tfsdk:"statuses" tf:"optional"` } +func (newState *ListPipelinesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListPipelinesResponse) { +} + +func (newState *ListPipelinesResponse) SyncEffectiveFieldsDuringRead(existingState ListPipelinesResponse) { +} + // List pipeline updates type ListUpdatesRequest struct { // Max number of entries to return in a single page. @@ -377,6 +529,12 @@ type ListUpdatesRequest struct { UntilUpdateId types.String `tfsdk:"-"` } +func (newState *ListUpdatesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListUpdatesRequest) { +} + +func (newState *ListUpdatesRequest) SyncEffectiveFieldsDuringRead(existingState ListUpdatesRequest) { +} + type ListUpdatesResponse struct { // If present, then there are more results, and this a token to be used in a // subsequent request to fetch the next page. @@ -388,14 +546,32 @@ type ListUpdatesResponse struct { Updates []UpdateInfo `tfsdk:"updates" tf:"optional"` } +func (newState *ListUpdatesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListUpdatesResponse) { +} + +func (newState *ListUpdatesResponse) SyncEffectiveFieldsDuringRead(existingState ListUpdatesResponse) { +} + type ManualTrigger struct { } +func (newState *ManualTrigger) SyncEffectiveFieldsDuringCreateOrUpdate(plan ManualTrigger) { +} + +func (newState *ManualTrigger) SyncEffectiveFieldsDuringRead(existingState ManualTrigger) { +} + type NotebookLibrary struct { // The absolute path of the notebook. Path types.String `tfsdk:"path" tf:"optional"` } +func (newState *NotebookLibrary) SyncEffectiveFieldsDuringCreateOrUpdate(plan NotebookLibrary) { +} + +func (newState *NotebookLibrary) SyncEffectiveFieldsDuringRead(existingState NotebookLibrary) { +} + type Notifications struct { // A list of alerts that trigger the sending of notifications to the // configured destinations. The supported alerts are: @@ -409,6 +585,12 @@ type Notifications struct { EmailRecipients []types.String `tfsdk:"email_recipients" tf:"optional"` } +func (newState *Notifications) SyncEffectiveFieldsDuringCreateOrUpdate(plan Notifications) { +} + +func (newState *Notifications) SyncEffectiveFieldsDuringRead(existingState Notifications) { +} + type Origin struct { // The id of a batch. Unique within a flow. BatchId types.Int64 `tfsdk:"batch_id" tf:"optional"` @@ -447,6 +629,12 @@ type Origin struct { UpdateId types.String `tfsdk:"update_id" tf:"optional"` } +func (newState *Origin) SyncEffectiveFieldsDuringCreateOrUpdate(plan Origin) { +} + +func (newState *Origin) SyncEffectiveFieldsDuringRead(existingState Origin) { +} + type PipelineAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -458,6 +646,12 @@ type PipelineAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *PipelineAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineAccessControlRequest) { +} + +func (newState *PipelineAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState PipelineAccessControlRequest) { +} + type PipelineAccessControlResponse struct { // All permissions. AllPermissions []PipelinePermission `tfsdk:"all_permissions" tf:"optional"` @@ -471,6 +665,12 @@ type PipelineAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *PipelineAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineAccessControlResponse) { +} + +func (newState *PipelineAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState PipelineAccessControlResponse) { +} + type PipelineCluster struct { // Note: This field won't be persisted. Only API users will check this // field. @@ -568,6 +768,12 @@ type PipelineCluster struct { SshPublicKeys []types.String `tfsdk:"ssh_public_keys" tf:"optional"` } +func (newState *PipelineCluster) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineCluster) { +} + +func (newState *PipelineCluster) SyncEffectiveFieldsDuringRead(existingState PipelineCluster) { +} + type PipelineClusterAutoscale struct { // The maximum number of workers to which the cluster can scale up when // overloaded. `max_workers` must be strictly greater than `min_workers`. @@ -584,6 +790,12 @@ type PipelineClusterAutoscale struct { Mode types.String `tfsdk:"mode" tf:"optional"` } +func (newState *PipelineClusterAutoscale) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineClusterAutoscale) { +} + +func (newState *PipelineClusterAutoscale) SyncEffectiveFieldsDuringRead(existingState PipelineClusterAutoscale) { +} + type PipelineDeployment struct { // The deployment method that manages the pipeline. Kind types.String `tfsdk:"kind" tf:"optional"` @@ -591,6 +803,12 @@ type PipelineDeployment struct { MetadataFilePath types.String `tfsdk:"metadata_file_path" tf:"optional"` } +func (newState *PipelineDeployment) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineDeployment) { +} + +func (newState *PipelineDeployment) SyncEffectiveFieldsDuringRead(existingState PipelineDeployment) { +} + type PipelineEvent struct { // Information about an error captured by the event. Error []ErrorDetail `tfsdk:"error" tf:"optional,object"` @@ -612,6 +830,12 @@ type PipelineEvent struct { Timestamp types.String `tfsdk:"timestamp" tf:"optional"` } +func (newState *PipelineEvent) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineEvent) { +} + +func (newState *PipelineEvent) SyncEffectiveFieldsDuringRead(existingState PipelineEvent) { +} + type PipelineLibrary struct { // The path to a file that defines a pipeline and is stored in the // Databricks Repos. @@ -627,6 +851,12 @@ type PipelineLibrary struct { Whl types.String `tfsdk:"whl" tf:"optional"` } +func (newState *PipelineLibrary) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineLibrary) { +} + +func (newState *PipelineLibrary) SyncEffectiveFieldsDuringRead(existingState PipelineLibrary) { +} + type PipelinePermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -635,6 +865,12 @@ type PipelinePermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *PipelinePermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelinePermission) { +} + +func (newState *PipelinePermission) SyncEffectiveFieldsDuringRead(existingState PipelinePermission) { +} + type PipelinePermissions struct { AccessControlList []PipelineAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -643,18 +879,36 @@ type PipelinePermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *PipelinePermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelinePermissions) { +} + +func (newState *PipelinePermissions) SyncEffectiveFieldsDuringRead(existingState PipelinePermissions) { +} + type PipelinePermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *PipelinePermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelinePermissionsDescription) { +} + +func (newState *PipelinePermissionsDescription) SyncEffectiveFieldsDuringRead(existingState PipelinePermissionsDescription) { +} + type PipelinePermissionsRequest struct { AccessControlList []PipelineAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The pipeline for which to get or manage permissions. PipelineId types.String `tfsdk:"-"` } +func (newState *PipelinePermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelinePermissionsRequest) { +} + +func (newState *PipelinePermissionsRequest) SyncEffectiveFieldsDuringRead(existingState PipelinePermissionsRequest) { +} + type PipelineSpec struct { // Budget policy of this pipeline. BudgetPolicyId types.String `tfsdk:"budget_policy_id" tf:"optional"` @@ -711,6 +965,12 @@ type PipelineSpec struct { Trigger []PipelineTrigger `tfsdk:"trigger" tf:"optional,object"` } +func (newState *PipelineSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineSpec) { +} + +func (newState *PipelineSpec) SyncEffectiveFieldsDuringRead(existingState PipelineSpec) { +} + type PipelineStateInfo struct { // The unique identifier of the cluster running the pipeline. ClusterId types.String `tfsdk:"cluster_id" tf:"optional"` @@ -732,12 +992,46 @@ type PipelineStateInfo struct { State types.String `tfsdk:"state" tf:"optional"` } +func (newState *PipelineStateInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineStateInfo) { +} + +func (newState *PipelineStateInfo) SyncEffectiveFieldsDuringRead(existingState PipelineStateInfo) { +} + type PipelineTrigger struct { Cron []CronTrigger `tfsdk:"cron" tf:"optional,object"` Manual []ManualTrigger `tfsdk:"manual" tf:"optional,object"` } +func (newState *PipelineTrigger) SyncEffectiveFieldsDuringCreateOrUpdate(plan PipelineTrigger) { +} + +func (newState *PipelineTrigger) SyncEffectiveFieldsDuringRead(existingState PipelineTrigger) { +} + +type ReportSpec struct { + // Required. Destination catalog to store table. + DestinationCatalog types.String `tfsdk:"destination_catalog" tf:"optional"` + // Required. Destination schema to store table. + DestinationSchema types.String `tfsdk:"destination_schema" tf:"optional"` + // Required. Destination table name. The pipeline fails if a table with that + // name already exists. + DestinationTable types.String `tfsdk:"destination_table" tf:"optional"` + // Required. Report URL in the source system. + SourceUrl types.String `tfsdk:"source_url" tf:"optional"` + // Configuration settings to control the ingestion of tables. These settings + // override the table_configuration defined in the + // IngestionPipelineDefinition object. + TableConfiguration []TableSpecificConfig `tfsdk:"table_configuration" tf:"optional,object"` +} + +func (newState *ReportSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan ReportSpec) { +} + +func (newState *ReportSpec) SyncEffectiveFieldsDuringRead(existingState ReportSpec) { +} + type SchemaSpec struct { // Required. Destination catalog to store tables. DestinationCatalog types.String `tfsdk:"destination_catalog" tf:"optional"` @@ -756,6 +1050,12 @@ type SchemaSpec struct { TableConfiguration []TableSpecificConfig `tfsdk:"table_configuration" tf:"optional,object"` } +func (newState *SchemaSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan SchemaSpec) { +} + +func (newState *SchemaSpec) SyncEffectiveFieldsDuringRead(existingState SchemaSpec) { +} + type Sequencing struct { // A sequence number, unique and increasing within the control plane. ControlPlaneSeqNo types.Int64 `tfsdk:"control_plane_seq_no" tf:"optional"` @@ -763,6 +1063,12 @@ type Sequencing struct { DataPlaneId []DataPlaneId `tfsdk:"data_plane_id" tf:"optional,object"` } +func (newState *Sequencing) SyncEffectiveFieldsDuringCreateOrUpdate(plan Sequencing) { +} + +func (newState *Sequencing) SyncEffectiveFieldsDuringRead(existingState Sequencing) { +} + type SerializedException struct { // Runtime class of the exception ClassName types.String `tfsdk:"class_name" tf:"optional"` @@ -772,6 +1078,12 @@ type SerializedException struct { Stack []StackFrame `tfsdk:"stack" tf:"optional"` } +func (newState *SerializedException) SyncEffectiveFieldsDuringCreateOrUpdate(plan SerializedException) { +} + +func (newState *SerializedException) SyncEffectiveFieldsDuringRead(existingState SerializedException) { +} + type StackFrame struct { // Class from which the method call originated DeclaringClass types.String `tfsdk:"declaring_class" tf:"optional"` @@ -783,6 +1095,12 @@ type StackFrame struct { MethodName types.String `tfsdk:"method_name" tf:"optional"` } +func (newState *StackFrame) SyncEffectiveFieldsDuringCreateOrUpdate(plan StackFrame) { +} + +func (newState *StackFrame) SyncEffectiveFieldsDuringRead(existingState StackFrame) { +} + type StartUpdate struct { Cause types.String `tfsdk:"cause" tf:"optional"` // If true, this update will reset all tables before running. @@ -804,24 +1122,48 @@ type StartUpdate struct { ValidateOnly types.Bool `tfsdk:"validate_only" tf:"optional"` } +func (newState *StartUpdate) SyncEffectiveFieldsDuringCreateOrUpdate(plan StartUpdate) { +} + +func (newState *StartUpdate) SyncEffectiveFieldsDuringRead(existingState StartUpdate) { +} + type StartUpdateResponse struct { UpdateId types.String `tfsdk:"update_id" tf:"optional"` } +func (newState *StartUpdateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan StartUpdateResponse) { +} + +func (newState *StartUpdateResponse) SyncEffectiveFieldsDuringRead(existingState StartUpdateResponse) { +} + type StopPipelineResponse struct { } +func (newState *StopPipelineResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan StopPipelineResponse) { +} + +func (newState *StopPipelineResponse) SyncEffectiveFieldsDuringRead(existingState StopPipelineResponse) { +} + // Stop a pipeline type StopRequest struct { PipelineId types.String `tfsdk:"-"` } +func (newState *StopRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan StopRequest) { +} + +func (newState *StopRequest) SyncEffectiveFieldsDuringRead(existingState StopRequest) { +} + type TableSpec struct { // Required. Destination catalog to store table. DestinationCatalog types.String `tfsdk:"destination_catalog" tf:"optional"` // Required. Destination schema to store table. DestinationSchema types.String `tfsdk:"destination_schema" tf:"optional"` - // Optional. Destination table name. The pipeline fails If a table with that + // Optional. Destination table name. The pipeline fails if a table with that // name already exists. If not set, the source table name is used. DestinationTable types.String `tfsdk:"destination_table" tf:"optional"` // Source catalog name. Might be optional depending on the type of source. @@ -837,6 +1179,12 @@ type TableSpec struct { TableConfiguration []TableSpecificConfig `tfsdk:"table_configuration" tf:"optional,object"` } +func (newState *TableSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan TableSpec) { +} + +func (newState *TableSpec) SyncEffectiveFieldsDuringRead(existingState TableSpec) { +} + type TableSpecificConfig struct { // The primary key of the table used to apply changes. PrimaryKeys []types.String `tfsdk:"primary_keys" tf:"optional"` @@ -845,6 +1193,16 @@ type TableSpecificConfig struct { SalesforceIncludeFormulaFields types.Bool `tfsdk:"salesforce_include_formula_fields" tf:"optional"` // The SCD type to use to ingest the table. ScdType types.String `tfsdk:"scd_type" tf:"optional"` + // The column names specifying the logical order of events in the source + // data. Delta Live Tables uses this sequencing to handle change events that + // arrive out of order. + SequenceBy []types.String `tfsdk:"sequence_by" tf:"optional"` +} + +func (newState *TableSpecificConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan TableSpecificConfig) { +} + +func (newState *TableSpecificConfig) SyncEffectiveFieldsDuringRead(existingState TableSpecificConfig) { } type UpdateInfo struct { @@ -880,6 +1238,12 @@ type UpdateInfo struct { ValidateOnly types.Bool `tfsdk:"validate_only" tf:"optional"` } +func (newState *UpdateInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateInfo) { +} + +func (newState *UpdateInfo) SyncEffectiveFieldsDuringRead(existingState UpdateInfo) { +} + type UpdateStateInfo struct { CreationTime types.String `tfsdk:"creation_time" tf:"optional"` @@ -887,3 +1251,9 @@ type UpdateStateInfo struct { UpdateId types.String `tfsdk:"update_id" tf:"optional"` } + +func (newState *UpdateStateInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateStateInfo) { +} + +func (newState *UpdateStateInfo) SyncEffectiveFieldsDuringRead(existingState UpdateStateInfo) { +} diff --git a/internal/service/provisioning_tf/model.go b/internal/service/provisioning_tf/model.go index 502b806409..be8e5f0c2f 100755 --- a/internal/service/provisioning_tf/model.go +++ b/internal/service/provisioning_tf/model.go @@ -18,6 +18,12 @@ type AwsCredentials struct { StsRole []StsRole `tfsdk:"sts_role" tf:"optional,object"` } +func (newState *AwsCredentials) SyncEffectiveFieldsDuringCreateOrUpdate(plan AwsCredentials) { +} + +func (newState *AwsCredentials) SyncEffectiveFieldsDuringRead(existingState AwsCredentials) { +} + type AwsKeyInfo struct { // The AWS KMS key alias. KeyAlias types.String `tfsdk:"key_alias" tf:"optional"` @@ -32,6 +38,12 @@ type AwsKeyInfo struct { ReuseKeyForClusterVolumes types.Bool `tfsdk:"reuse_key_for_cluster_volumes" tf:"optional"` } +func (newState *AwsKeyInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan AwsKeyInfo) { +} + +func (newState *AwsKeyInfo) SyncEffectiveFieldsDuringRead(existingState AwsKeyInfo) { +} + type AzureWorkspaceInfo struct { // Azure Resource Group name ResourceGroup types.String `tfsdk:"resource_group" tf:"optional"` @@ -39,12 +51,24 @@ type AzureWorkspaceInfo struct { SubscriptionId types.String `tfsdk:"subscription_id" tf:"optional"` } +func (newState *AzureWorkspaceInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan AzureWorkspaceInfo) { +} + +func (newState *AzureWorkspaceInfo) SyncEffectiveFieldsDuringRead(existingState AzureWorkspaceInfo) { +} + // The general workspace configurations that are specific to cloud providers. type CloudResourceContainer struct { // The general workspace configurations that are specific to Google Cloud. Gcp []CustomerFacingGcpCloudResourceContainer `tfsdk:"gcp" tf:"optional,object"` } +func (newState *CloudResourceContainer) SyncEffectiveFieldsDuringCreateOrUpdate(plan CloudResourceContainer) { +} + +func (newState *CloudResourceContainer) SyncEffectiveFieldsDuringRead(existingState CloudResourceContainer) { +} + type CreateAwsKeyInfo struct { // The AWS KMS key alias. KeyAlias types.String `tfsdk:"key_alias" tf:"optional"` @@ -58,21 +82,45 @@ type CreateAwsKeyInfo struct { ReuseKeyForClusterVolumes types.Bool `tfsdk:"reuse_key_for_cluster_volumes" tf:"optional"` } +func (newState *CreateAwsKeyInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateAwsKeyInfo) { +} + +func (newState *CreateAwsKeyInfo) SyncEffectiveFieldsDuringRead(existingState CreateAwsKeyInfo) { +} + type CreateCredentialAwsCredentials struct { StsRole []CreateCredentialStsRole `tfsdk:"sts_role" tf:"optional,object"` } +func (newState *CreateCredentialAwsCredentials) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCredentialAwsCredentials) { +} + +func (newState *CreateCredentialAwsCredentials) SyncEffectiveFieldsDuringRead(existingState CreateCredentialAwsCredentials) { +} + type CreateCredentialRequest struct { AwsCredentials []CreateCredentialAwsCredentials `tfsdk:"aws_credentials" tf:"object"` // The human-readable name of the credential configuration object. CredentialsName types.String `tfsdk:"credentials_name" tf:""` } +func (newState *CreateCredentialRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCredentialRequest) { +} + +func (newState *CreateCredentialRequest) SyncEffectiveFieldsDuringRead(existingState CreateCredentialRequest) { +} + type CreateCredentialStsRole struct { // The Amazon Resource Name (ARN) of the cross account role. RoleArn types.String `tfsdk:"role_arn" tf:"optional"` } +func (newState *CreateCredentialStsRole) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCredentialStsRole) { +} + +func (newState *CreateCredentialStsRole) SyncEffectiveFieldsDuringRead(existingState CreateCredentialStsRole) { +} + type CreateCustomerManagedKeyRequest struct { AwsKeyInfo []CreateAwsKeyInfo `tfsdk:"aws_key_info" tf:"optional,object"` @@ -81,11 +129,23 @@ type CreateCustomerManagedKeyRequest struct { UseCases []types.String `tfsdk:"use_cases" tf:""` } +func (newState *CreateCustomerManagedKeyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCustomerManagedKeyRequest) { +} + +func (newState *CreateCustomerManagedKeyRequest) SyncEffectiveFieldsDuringRead(existingState CreateCustomerManagedKeyRequest) { +} + type CreateGcpKeyInfo struct { // The GCP KMS key's resource name KmsKeyId types.String `tfsdk:"kms_key_id" tf:""` } +func (newState *CreateGcpKeyInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateGcpKeyInfo) { +} + +func (newState *CreateGcpKeyInfo) SyncEffectiveFieldsDuringRead(existingState CreateGcpKeyInfo) { +} + type CreateNetworkRequest struct { // The Google Cloud specific information for this network (for example, the // VPC ID, subnet ID, and secondary IP ranges). @@ -108,6 +168,12 @@ type CreateNetworkRequest struct { VpcId types.String `tfsdk:"vpc_id" tf:"optional"` } +func (newState *CreateNetworkRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateNetworkRequest) { +} + +func (newState *CreateNetworkRequest) SyncEffectiveFieldsDuringRead(existingState CreateNetworkRequest) { +} + type CreateStorageConfigurationRequest struct { // Root S3 bucket information. RootBucketInfo []RootBucketInfo `tfsdk:"root_bucket_info" tf:"object"` @@ -115,6 +181,12 @@ type CreateStorageConfigurationRequest struct { StorageConfigurationName types.String `tfsdk:"storage_configuration_name" tf:""` } +func (newState *CreateStorageConfigurationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateStorageConfigurationRequest) { +} + +func (newState *CreateStorageConfigurationRequest) SyncEffectiveFieldsDuringRead(existingState CreateStorageConfigurationRequest) { +} + type CreateVpcEndpointRequest struct { // The ID of the VPC endpoint object in AWS. AwsVpcEndpointId types.String `tfsdk:"aws_vpc_endpoint_id" tf:"optional"` @@ -127,6 +199,12 @@ type CreateVpcEndpointRequest struct { VpcEndpointName types.String `tfsdk:"vpc_endpoint_name" tf:""` } +func (newState *CreateVpcEndpointRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateVpcEndpointRequest) { +} + +func (newState *CreateVpcEndpointRequest) SyncEffectiveFieldsDuringRead(existingState CreateVpcEndpointRequest) { +} + type CreateWorkspaceRequest struct { // The AWS region of the workspace's data plane. AwsRegion types.String `tfsdk:"aws_region" tf:"optional"` @@ -238,19 +316,37 @@ type CreateWorkspaceRequest struct { WorkspaceName types.String `tfsdk:"workspace_name" tf:""` } +func (newState *CreateWorkspaceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateWorkspaceRequest) { +} + +func (newState *CreateWorkspaceRequest) SyncEffectiveFieldsDuringRead(existingState CreateWorkspaceRequest) { +} + type Credential struct { // The Databricks account ID that hosts the credential. AccountId types.String `tfsdk:"account_id" tf:"optional"` AwsCredentials []AwsCredentials `tfsdk:"aws_credentials" tf:"optional,object"` // Time in epoch milliseconds when the credential was created. - CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + EffectiveCreationTime types.Int64 `tfsdk:"effective_creation_time" tf:"computed,optional"` // Databricks credential configuration ID. CredentialsId types.String `tfsdk:"credentials_id" tf:"optional"` // The human-readable name of the credential configuration object. CredentialsName types.String `tfsdk:"credentials_name" tf:"optional"` } +func (newState *Credential) SyncEffectiveFieldsDuringCreateOrUpdate(plan Credential) { + newState.EffectiveCreationTime = newState.CreationTime + newState.CreationTime = plan.CreationTime +} + +func (newState *Credential) SyncEffectiveFieldsDuringRead(existingState Credential) { + if existingState.EffectiveCreationTime.ValueInt64() == newState.CreationTime.ValueInt64() { + newState.CreationTime = existingState.CreationTime + } +} + // The general workspace configurations that are specific to Google Cloud. type CustomerFacingGcpCloudResourceContainer struct { // The Google Cloud project ID, which the workspace uses to instantiate @@ -258,13 +354,20 @@ type CustomerFacingGcpCloudResourceContainer struct { ProjectId types.String `tfsdk:"project_id" tf:"optional"` } +func (newState *CustomerFacingGcpCloudResourceContainer) SyncEffectiveFieldsDuringCreateOrUpdate(plan CustomerFacingGcpCloudResourceContainer) { +} + +func (newState *CustomerFacingGcpCloudResourceContainer) SyncEffectiveFieldsDuringRead(existingState CustomerFacingGcpCloudResourceContainer) { +} + type CustomerManagedKey struct { // The Databricks account ID that holds the customer-managed key. AccountId types.String `tfsdk:"account_id" tf:"optional"` AwsKeyInfo []AwsKeyInfo `tfsdk:"aws_key_info" tf:"optional,object"` // Time in epoch milliseconds when the customer key was created. - CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + EffectiveCreationTime types.Int64 `tfsdk:"effective_creation_time" tf:"computed,optional"` // ID of the encryption key configuration object. CustomerManagedKeyId types.String `tfsdk:"customer_managed_key_id" tf:"optional"` @@ -273,56 +376,121 @@ type CustomerManagedKey struct { UseCases []types.String `tfsdk:"use_cases" tf:"optional"` } +func (newState *CustomerManagedKey) SyncEffectiveFieldsDuringCreateOrUpdate(plan CustomerManagedKey) { + newState.EffectiveCreationTime = newState.CreationTime + newState.CreationTime = plan.CreationTime +} + +func (newState *CustomerManagedKey) SyncEffectiveFieldsDuringRead(existingState CustomerManagedKey) { + if existingState.EffectiveCreationTime.ValueInt64() == newState.CreationTime.ValueInt64() { + newState.CreationTime = existingState.CreationTime + } +} + // Delete credential configuration type DeleteCredentialRequest struct { // Databricks Account API credential configuration ID CredentialsId types.String `tfsdk:"-"` } +func (newState *DeleteCredentialRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteCredentialRequest) { +} + +func (newState *DeleteCredentialRequest) SyncEffectiveFieldsDuringRead(existingState DeleteCredentialRequest) { +} + // Delete encryption key configuration type DeleteEncryptionKeyRequest struct { // Databricks encryption key configuration ID. CustomerManagedKeyId types.String `tfsdk:"-"` } +func (newState *DeleteEncryptionKeyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteEncryptionKeyRequest) { +} + +func (newState *DeleteEncryptionKeyRequest) SyncEffectiveFieldsDuringRead(existingState DeleteEncryptionKeyRequest) { +} + // Delete a network configuration type DeleteNetworkRequest struct { // Databricks Account API network configuration ID. NetworkId types.String `tfsdk:"-"` } +func (newState *DeleteNetworkRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteNetworkRequest) { +} + +func (newState *DeleteNetworkRequest) SyncEffectiveFieldsDuringRead(existingState DeleteNetworkRequest) { +} + // Delete a private access settings object type DeletePrivateAccesRequest struct { // Databricks Account API private access settings ID. PrivateAccessSettingsId types.String `tfsdk:"-"` } +func (newState *DeletePrivateAccesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeletePrivateAccesRequest) { +} + +func (newState *DeletePrivateAccesRequest) SyncEffectiveFieldsDuringRead(existingState DeletePrivateAccesRequest) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + // Delete storage configuration type DeleteStorageRequest struct { // Databricks Account API storage configuration ID. StorageConfigurationId types.String `tfsdk:"-"` } +func (newState *DeleteStorageRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteStorageRequest) { +} + +func (newState *DeleteStorageRequest) SyncEffectiveFieldsDuringRead(existingState DeleteStorageRequest) { +} + // Delete VPC endpoint configuration type DeleteVpcEndpointRequest struct { // Databricks VPC endpoint ID. VpcEndpointId types.String `tfsdk:"-"` } +func (newState *DeleteVpcEndpointRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteVpcEndpointRequest) { +} + +func (newState *DeleteVpcEndpointRequest) SyncEffectiveFieldsDuringRead(existingState DeleteVpcEndpointRequest) { +} + // Delete a workspace type DeleteWorkspaceRequest struct { // Workspace ID. WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *DeleteWorkspaceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteWorkspaceRequest) { +} + +func (newState *DeleteWorkspaceRequest) SyncEffectiveFieldsDuringRead(existingState DeleteWorkspaceRequest) { +} + type GcpKeyInfo struct { // The GCP KMS key's resource name KmsKeyId types.String `tfsdk:"kms_key_id" tf:""` } +func (newState *GcpKeyInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan GcpKeyInfo) { +} + +func (newState *GcpKeyInfo) SyncEffectiveFieldsDuringRead(existingState GcpKeyInfo) { +} + // The network settings for the workspace. The configurations are only for // Databricks-managed VPCs. It is ignored if you specify a customer-managed VPC // in the `network_id` field.", All the IP range configurations must be mutually @@ -358,6 +526,12 @@ type GcpManagedNetworkConfig struct { SubnetCidr types.String `tfsdk:"subnet_cidr" tf:"optional"` } +func (newState *GcpManagedNetworkConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan GcpManagedNetworkConfig) { +} + +func (newState *GcpManagedNetworkConfig) SyncEffectiveFieldsDuringRead(existingState GcpManagedNetworkConfig) { +} + // The Google Cloud specific information for this network (for example, the VPC // ID, subnet ID, and secondary IP ranges). type GcpNetworkInfo struct { @@ -381,6 +555,12 @@ type GcpNetworkInfo struct { VpcId types.String `tfsdk:"vpc_id" tf:""` } +func (newState *GcpNetworkInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan GcpNetworkInfo) { +} + +func (newState *GcpNetworkInfo) SyncEffectiveFieldsDuringRead(existingState GcpNetworkInfo) { +} + // The Google Cloud specific information for this Private Service Connect // endpoint. type GcpVpcEndpointInfo struct { @@ -397,48 +577,96 @@ type GcpVpcEndpointInfo struct { ServiceAttachmentId types.String `tfsdk:"service_attachment_id" tf:"optional"` } +func (newState *GcpVpcEndpointInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan GcpVpcEndpointInfo) { +} + +func (newState *GcpVpcEndpointInfo) SyncEffectiveFieldsDuringRead(existingState GcpVpcEndpointInfo) { +} + // Get credential configuration type GetCredentialRequest struct { // Databricks Account API credential configuration ID CredentialsId types.String `tfsdk:"-"` } +func (newState *GetCredentialRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetCredentialRequest) { +} + +func (newState *GetCredentialRequest) SyncEffectiveFieldsDuringRead(existingState GetCredentialRequest) { +} + // Get encryption key configuration type GetEncryptionKeyRequest struct { // Databricks encryption key configuration ID. CustomerManagedKeyId types.String `tfsdk:"-"` } +func (newState *GetEncryptionKeyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetEncryptionKeyRequest) { +} + +func (newState *GetEncryptionKeyRequest) SyncEffectiveFieldsDuringRead(existingState GetEncryptionKeyRequest) { +} + // Get a network configuration type GetNetworkRequest struct { // Databricks Account API network configuration ID. NetworkId types.String `tfsdk:"-"` } +func (newState *GetNetworkRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetNetworkRequest) { +} + +func (newState *GetNetworkRequest) SyncEffectiveFieldsDuringRead(existingState GetNetworkRequest) { +} + // Get a private access settings object type GetPrivateAccesRequest struct { // Databricks Account API private access settings ID. PrivateAccessSettingsId types.String `tfsdk:"-"` } +func (newState *GetPrivateAccesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPrivateAccesRequest) { +} + +func (newState *GetPrivateAccesRequest) SyncEffectiveFieldsDuringRead(existingState GetPrivateAccesRequest) { +} + // Get storage configuration type GetStorageRequest struct { // Databricks Account API storage configuration ID. StorageConfigurationId types.String `tfsdk:"-"` } +func (newState *GetStorageRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetStorageRequest) { +} + +func (newState *GetStorageRequest) SyncEffectiveFieldsDuringRead(existingState GetStorageRequest) { +} + // Get a VPC endpoint configuration type GetVpcEndpointRequest struct { // Databricks VPC endpoint ID. VpcEndpointId types.String `tfsdk:"-"` } +func (newState *GetVpcEndpointRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetVpcEndpointRequest) { +} + +func (newState *GetVpcEndpointRequest) SyncEffectiveFieldsDuringRead(existingState GetVpcEndpointRequest) { +} + // Get a workspace type GetWorkspaceRequest struct { // Workspace ID. WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *GetWorkspaceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWorkspaceRequest) { +} + +func (newState *GetWorkspaceRequest) SyncEffectiveFieldsDuringRead(existingState GetWorkspaceRequest) { +} + // The configurations for the GKE cluster of a Databricks workspace. type GkeConfig struct { // Specifies the network connectivity types for the GKE nodes and the GKE @@ -457,13 +685,21 @@ type GkeConfig struct { MasterIpRange types.String `tfsdk:"master_ip_range" tf:"optional"` } +func (newState *GkeConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan GkeConfig) { +} + +func (newState *GkeConfig) SyncEffectiveFieldsDuringRead(existingState GkeConfig) { +} + type Network struct { // The Databricks account ID associated with this network configuration. AccountId types.String `tfsdk:"account_id" tf:"optional"` // Time in epoch milliseconds when the network was created. - CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + EffectiveCreationTime types.Int64 `tfsdk:"effective_creation_time" tf:"computed,optional"` // Array of error messages about the network configuration. - ErrorMessages []NetworkHealth `tfsdk:"error_messages" tf:"optional"` + ErrorMessages []NetworkHealth `tfsdk:"error_messages" tf:"optional"` + EffectiveErrorMessages []NetworkHealth `tfsdk:"effective_error_messages" tf:"computed,optional"` // The Google Cloud specific information for this network (for example, the // VPC ID, subnet ID, and secondary IP ranges). GcpNetworkInfo []GcpNetworkInfo `tfsdk:"gcp_network_info" tf:"optional,object"` @@ -486,13 +722,31 @@ type Network struct { // The status of this network configuration object in terms of its use in a // workspace: * `UNATTACHED`: Unattached. * `VALID`: Valid. * `BROKEN`: // Broken. * `WARNED`: Warned. - VpcStatus types.String `tfsdk:"vpc_status" tf:"optional"` + VpcStatus types.String `tfsdk:"vpc_status" tf:"optional"` + EffectiveVpcStatus types.String `tfsdk:"effective_vpc_status" tf:"computed,optional"` // Array of warning messages about the network configuration. - WarningMessages []NetworkWarning `tfsdk:"warning_messages" tf:"optional"` + WarningMessages []NetworkWarning `tfsdk:"warning_messages" tf:"optional"` + EffectiveWarningMessages []NetworkWarning `tfsdk:"effective_warning_messages" tf:"computed,optional"` // Workspace ID associated with this network configuration. WorkspaceId types.Int64 `tfsdk:"workspace_id" tf:"optional"` } +func (newState *Network) SyncEffectiveFieldsDuringCreateOrUpdate(plan Network) { + newState.EffectiveCreationTime = newState.CreationTime + newState.CreationTime = plan.CreationTime + newState.EffectiveVpcStatus = newState.VpcStatus + newState.VpcStatus = plan.VpcStatus +} + +func (newState *Network) SyncEffectiveFieldsDuringRead(existingState Network) { + if existingState.EffectiveCreationTime.ValueInt64() == newState.CreationTime.ValueInt64() { + newState.CreationTime = existingState.CreationTime + } + if existingState.EffectiveVpcStatus.ValueString() == newState.VpcStatus.ValueString() { + newState.VpcStatus = existingState.VpcStatus + } +} + type NetworkHealth struct { // Details of the error. ErrorMessage types.String `tfsdk:"error_message" tf:"optional"` @@ -501,6 +755,12 @@ type NetworkHealth struct { ErrorType types.String `tfsdk:"error_type" tf:"optional"` } +func (newState *NetworkHealth) SyncEffectiveFieldsDuringCreateOrUpdate(plan NetworkHealth) { +} + +func (newState *NetworkHealth) SyncEffectiveFieldsDuringRead(existingState NetworkHealth) { +} + // If specified, contains the VPC endpoints used to allow cluster communication // from this VPC over [AWS PrivateLink]. // @@ -514,6 +774,12 @@ type NetworkVpcEndpoints struct { RestApi []types.String `tfsdk:"rest_api" tf:""` } +func (newState *NetworkVpcEndpoints) SyncEffectiveFieldsDuringCreateOrUpdate(plan NetworkVpcEndpoints) { +} + +func (newState *NetworkVpcEndpoints) SyncEffectiveFieldsDuringRead(existingState NetworkVpcEndpoints) { +} + type NetworkWarning struct { // Details of the warning. WarningMessage types.String `tfsdk:"warning_message" tf:"optional"` @@ -522,6 +788,12 @@ type NetworkWarning struct { WarningType types.String `tfsdk:"warning_type" tf:"optional"` } +func (newState *NetworkWarning) SyncEffectiveFieldsDuringCreateOrUpdate(plan NetworkWarning) { +} + +func (newState *NetworkWarning) SyncEffectiveFieldsDuringRead(existingState NetworkWarning) { +} + type PrivateAccessSettings struct { // The Databricks account ID that hosts the credential. AccountId types.String `tfsdk:"account_id" tf:"optional"` @@ -549,20 +821,40 @@ type PrivateAccessSettings struct { Region types.String `tfsdk:"region" tf:"optional"` } +func (newState *PrivateAccessSettings) SyncEffectiveFieldsDuringCreateOrUpdate(plan PrivateAccessSettings) { +} + +func (newState *PrivateAccessSettings) SyncEffectiveFieldsDuringRead(existingState PrivateAccessSettings) { +} + type ReplaceResponse struct { } +func (newState *ReplaceResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ReplaceResponse) { +} + +func (newState *ReplaceResponse) SyncEffectiveFieldsDuringRead(existingState ReplaceResponse) { +} + // Root S3 bucket information. type RootBucketInfo struct { // The name of the S3 bucket. BucketName types.String `tfsdk:"bucket_name" tf:"optional"` } +func (newState *RootBucketInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan RootBucketInfo) { +} + +func (newState *RootBucketInfo) SyncEffectiveFieldsDuringRead(existingState RootBucketInfo) { +} + type StorageConfiguration struct { // The Databricks account ID that hosts the credential. - AccountId types.String `tfsdk:"account_id" tf:"optional"` + AccountId types.String `tfsdk:"account_id" tf:"optional"` + EffectiveAccountId types.String `tfsdk:"effective_account_id" tf:"computed,optional"` // Time in epoch milliseconds when the storage configuration was created. - CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + EffectiveCreationTime types.Int64 `tfsdk:"effective_creation_time" tf:"computed,optional"` // Root S3 bucket information. RootBucketInfo []RootBucketInfo `tfsdk:"root_bucket_info" tf:"optional,object"` // Databricks storage configuration ID. @@ -571,6 +863,22 @@ type StorageConfiguration struct { StorageConfigurationName types.String `tfsdk:"storage_configuration_name" tf:"optional"` } +func (newState *StorageConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan StorageConfiguration) { + newState.EffectiveAccountId = newState.AccountId + newState.AccountId = plan.AccountId + newState.EffectiveCreationTime = newState.CreationTime + newState.CreationTime = plan.CreationTime +} + +func (newState *StorageConfiguration) SyncEffectiveFieldsDuringRead(existingState StorageConfiguration) { + if existingState.EffectiveAccountId.ValueString() == newState.AccountId.ValueString() { + newState.AccountId = existingState.AccountId + } + if existingState.EffectiveCreationTime.ValueInt64() == newState.CreationTime.ValueInt64() { + newState.CreationTime = existingState.CreationTime + } +} + type StsRole struct { // The external ID that needs to be trusted by the cross-account role. This // is always your Databricks account ID. @@ -579,9 +887,21 @@ type StsRole struct { RoleArn types.String `tfsdk:"role_arn" tf:"optional"` } +func (newState *StsRole) SyncEffectiveFieldsDuringCreateOrUpdate(plan StsRole) { +} + +func (newState *StsRole) SyncEffectiveFieldsDuringRead(existingState StsRole) { +} + type UpdateResponse struct { } +func (newState *UpdateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateResponse) { +} + +func (newState *UpdateResponse) SyncEffectiveFieldsDuringRead(existingState UpdateResponse) { +} + type UpdateWorkspaceRequest struct { // The AWS region of the workspace's data plane (for example, `us-west-2`). // This parameter is available only for updating failed workspaces. @@ -614,6 +934,12 @@ type UpdateWorkspaceRequest struct { WorkspaceId types.Int64 `tfsdk:"-"` } +func (newState *UpdateWorkspaceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateWorkspaceRequest) { +} + +func (newState *UpdateWorkspaceRequest) SyncEffectiveFieldsDuringRead(existingState UpdateWorkspaceRequest) { +} + type UpsertPrivateAccessSettingsRequest struct { // An array of Databricks VPC endpoint IDs. This is the Databricks ID that // is returned when registering the VPC endpoint configuration in your @@ -652,6 +978,12 @@ type UpsertPrivateAccessSettingsRequest struct { Region types.String `tfsdk:"region" tf:""` } +func (newState *UpsertPrivateAccessSettingsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpsertPrivateAccessSettingsRequest) { +} + +func (newState *UpsertPrivateAccessSettingsRequest) SyncEffectiveFieldsDuringRead(existingState UpsertPrivateAccessSettingsRequest) { +} + type VpcEndpoint struct { // The Databricks account ID that hosts the VPC endpoint configuration. AccountId types.String `tfsdk:"account_id" tf:"optional"` @@ -690,6 +1022,12 @@ type VpcEndpoint struct { VpcEndpointName types.String `tfsdk:"vpc_endpoint_name" tf:"optional"` } +func (newState *VpcEndpoint) SyncEffectiveFieldsDuringCreateOrUpdate(plan VpcEndpoint) { +} + +func (newState *VpcEndpoint) SyncEffectiveFieldsDuringRead(existingState VpcEndpoint) { +} + type Workspace struct { // Databricks account ID. AccountId types.String `tfsdk:"account_id" tf:"optional"` @@ -703,7 +1041,8 @@ type Workspace struct { // providers. CloudResourceContainer []CloudResourceContainer `tfsdk:"cloud_resource_container" tf:"optional,object"` // Time in epoch milliseconds when the workspace was created. - CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + EffectiveCreationTime types.Int64 `tfsdk:"effective_creation_time" tf:"computed,optional"` // ID of the workspace's credential configuration object. CredentialsId types.String `tfsdk:"credentials_id" tf:"optional"` // The custom tags key-value pairing that is attached to this workspace. The @@ -779,7 +1118,30 @@ type Workspace struct { // The status of the workspace. For workspace creation, usually it is set to // `PROVISIONING` initially. Continue to check the status until the status // is `RUNNING`. - WorkspaceStatus types.String `tfsdk:"workspace_status" tf:"optional"` + WorkspaceStatus types.String `tfsdk:"workspace_status" tf:"optional"` + EffectiveWorkspaceStatus types.String `tfsdk:"effective_workspace_status" tf:"computed,optional"` // Message describing the current workspace status. - WorkspaceStatusMessage types.String `tfsdk:"workspace_status_message" tf:"optional"` + WorkspaceStatusMessage types.String `tfsdk:"workspace_status_message" tf:"optional"` + EffectiveWorkspaceStatusMessage types.String `tfsdk:"effective_workspace_status_message" tf:"computed,optional"` +} + +func (newState *Workspace) SyncEffectiveFieldsDuringCreateOrUpdate(plan Workspace) { + newState.EffectiveCreationTime = newState.CreationTime + newState.CreationTime = plan.CreationTime + newState.EffectiveWorkspaceStatus = newState.WorkspaceStatus + newState.WorkspaceStatus = plan.WorkspaceStatus + newState.EffectiveWorkspaceStatusMessage = newState.WorkspaceStatusMessage + newState.WorkspaceStatusMessage = plan.WorkspaceStatusMessage +} + +func (newState *Workspace) SyncEffectiveFieldsDuringRead(existingState Workspace) { + if existingState.EffectiveCreationTime.ValueInt64() == newState.CreationTime.ValueInt64() { + newState.CreationTime = existingState.CreationTime + } + if existingState.EffectiveWorkspaceStatus.ValueString() == newState.WorkspaceStatus.ValueString() { + newState.WorkspaceStatus = existingState.WorkspaceStatus + } + if existingState.EffectiveWorkspaceStatusMessage.ValueString() == newState.WorkspaceStatusMessage.ValueString() { + newState.WorkspaceStatusMessage = existingState.WorkspaceStatusMessage + } } diff --git a/internal/service/serving_tf/model.go b/internal/service/serving_tf/model.go index 7e6bdee0a1..940de56ad4 100755 --- a/internal/service/serving_tf/model.go +++ b/internal/service/serving_tf/model.go @@ -30,6 +30,12 @@ type Ai21LabsConfig struct { Ai21labsApiKeyPlaintext types.String `tfsdk:"ai21labs_api_key_plaintext" tf:"optional"` } +func (newState *Ai21LabsConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan Ai21LabsConfig) { +} + +func (newState *Ai21LabsConfig) SyncEffectiveFieldsDuringRead(existingState Ai21LabsConfig) { +} + type AiGatewayConfig struct { // Configuration for AI Guardrails to prevent unwanted data and unsafe data // in requests and responses. @@ -46,6 +52,12 @@ type AiGatewayConfig struct { UsageTrackingConfig []AiGatewayUsageTrackingConfig `tfsdk:"usage_tracking_config" tf:"optional,object"` } +func (newState *AiGatewayConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan AiGatewayConfig) { +} + +func (newState *AiGatewayConfig) SyncEffectiveFieldsDuringRead(existingState AiGatewayConfig) { +} + type AiGatewayGuardrailParameters struct { // List of invalid keywords. AI guardrail uses keyword or string matching to // decide if the keyword exists in the request or response content. @@ -59,6 +71,12 @@ type AiGatewayGuardrailParameters struct { ValidTopics []types.String `tfsdk:"valid_topics" tf:"optional"` } +func (newState *AiGatewayGuardrailParameters) SyncEffectiveFieldsDuringCreateOrUpdate(plan AiGatewayGuardrailParameters) { +} + +func (newState *AiGatewayGuardrailParameters) SyncEffectiveFieldsDuringRead(existingState AiGatewayGuardrailParameters) { +} + type AiGatewayGuardrailPiiBehavior struct { // Behavior for PII filter. Currently only 'BLOCK' is supported. If 'BLOCK' // is set for the input guardrail and the request contains PII, the request @@ -69,6 +87,12 @@ type AiGatewayGuardrailPiiBehavior struct { Behavior types.String `tfsdk:"behavior" tf:""` } +func (newState *AiGatewayGuardrailPiiBehavior) SyncEffectiveFieldsDuringCreateOrUpdate(plan AiGatewayGuardrailPiiBehavior) { +} + +func (newState *AiGatewayGuardrailPiiBehavior) SyncEffectiveFieldsDuringRead(existingState AiGatewayGuardrailPiiBehavior) { +} + type AiGatewayGuardrails struct { // Configuration for input guardrail filters. Input []AiGatewayGuardrailParameters `tfsdk:"input" tf:"optional,object"` @@ -76,6 +100,12 @@ type AiGatewayGuardrails struct { Output []AiGatewayGuardrailParameters `tfsdk:"output" tf:"optional,object"` } +func (newState *AiGatewayGuardrails) SyncEffectiveFieldsDuringCreateOrUpdate(plan AiGatewayGuardrails) { +} + +func (newState *AiGatewayGuardrails) SyncEffectiveFieldsDuringRead(existingState AiGatewayGuardrails) { +} + type AiGatewayInferenceTableConfig struct { // The name of the catalog in Unity Catalog. Required when enabling // inference tables. NOTE: On update, you have to disable inference table @@ -92,6 +122,12 @@ type AiGatewayInferenceTableConfig struct { TableNamePrefix types.String `tfsdk:"table_name_prefix" tf:"optional"` } +func (newState *AiGatewayInferenceTableConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan AiGatewayInferenceTableConfig) { +} + +func (newState *AiGatewayInferenceTableConfig) SyncEffectiveFieldsDuringRead(existingState AiGatewayInferenceTableConfig) { +} + type AiGatewayRateLimit struct { // Used to specify how many calls are allowed for a key within the // renewal_period. @@ -104,11 +140,23 @@ type AiGatewayRateLimit struct { RenewalPeriod types.String `tfsdk:"renewal_period" tf:""` } +func (newState *AiGatewayRateLimit) SyncEffectiveFieldsDuringCreateOrUpdate(plan AiGatewayRateLimit) { +} + +func (newState *AiGatewayRateLimit) SyncEffectiveFieldsDuringRead(existingState AiGatewayRateLimit) { +} + type AiGatewayUsageTrackingConfig struct { // Whether to enable usage tracking. Enabled types.Bool `tfsdk:"enabled" tf:"optional"` } +func (newState *AiGatewayUsageTrackingConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan AiGatewayUsageTrackingConfig) { +} + +func (newState *AiGatewayUsageTrackingConfig) SyncEffectiveFieldsDuringRead(existingState AiGatewayUsageTrackingConfig) { +} + type AmazonBedrockConfig struct { // The Databricks secret key reference for an AWS access key ID with // permissions to interact with Bedrock services. If you prefer to paste @@ -143,6 +191,12 @@ type AmazonBedrockConfig struct { BedrockProvider types.String `tfsdk:"bedrock_provider" tf:""` } +func (newState *AmazonBedrockConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan AmazonBedrockConfig) { +} + +func (newState *AmazonBedrockConfig) SyncEffectiveFieldsDuringRead(existingState AmazonBedrockConfig) { +} + type AnthropicConfig struct { // The Databricks secret key reference for an Anthropic API key. If you // prefer to paste your API key directly, see `anthropic_api_key_plaintext`. @@ -156,6 +210,12 @@ type AnthropicConfig struct { AnthropicApiKeyPlaintext types.String `tfsdk:"anthropic_api_key_plaintext" tf:"optional"` } +func (newState *AnthropicConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan AnthropicConfig) { +} + +func (newState *AnthropicConfig) SyncEffectiveFieldsDuringRead(existingState AnthropicConfig) { +} + type AutoCaptureConfigInput struct { // The name of the catalog in Unity Catalog. NOTE: On update, you cannot // change the catalog name if the inference table is already enabled. @@ -170,6 +230,12 @@ type AutoCaptureConfigInput struct { TableNamePrefix types.String `tfsdk:"table_name_prefix" tf:"optional"` } +func (newState *AutoCaptureConfigInput) SyncEffectiveFieldsDuringCreateOrUpdate(plan AutoCaptureConfigInput) { +} + +func (newState *AutoCaptureConfigInput) SyncEffectiveFieldsDuringRead(existingState AutoCaptureConfigInput) { +} + type AutoCaptureConfigOutput struct { // The name of the catalog in Unity Catalog. CatalogName types.String `tfsdk:"catalog_name" tf:"optional"` @@ -183,10 +249,22 @@ type AutoCaptureConfigOutput struct { TableNamePrefix types.String `tfsdk:"table_name_prefix" tf:"optional"` } +func (newState *AutoCaptureConfigOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan AutoCaptureConfigOutput) { +} + +func (newState *AutoCaptureConfigOutput) SyncEffectiveFieldsDuringRead(existingState AutoCaptureConfigOutput) { +} + type AutoCaptureState struct { PayloadTable []PayloadTable `tfsdk:"payload_table" tf:"optional,object"` } +func (newState *AutoCaptureState) SyncEffectiveFieldsDuringCreateOrUpdate(plan AutoCaptureState) { +} + +func (newState *AutoCaptureState) SyncEffectiveFieldsDuringRead(existingState AutoCaptureState) { +} + // Get build logs for a served model type BuildLogsRequest struct { // The name of the serving endpoint that the served model belongs to. This @@ -197,11 +275,23 @@ type BuildLogsRequest struct { ServedModelName types.String `tfsdk:"-"` } +func (newState *BuildLogsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan BuildLogsRequest) { +} + +func (newState *BuildLogsRequest) SyncEffectiveFieldsDuringRead(existingState BuildLogsRequest) { +} + type BuildLogsResponse struct { // The logs associated with building the served entity's environment. Logs types.String `tfsdk:"logs" tf:""` } +func (newState *BuildLogsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan BuildLogsResponse) { +} + +func (newState *BuildLogsResponse) SyncEffectiveFieldsDuringRead(existingState BuildLogsResponse) { +} + type ChatMessage struct { // The content of the message. Content types.String `tfsdk:"content" tf:"optional"` @@ -209,6 +299,12 @@ type ChatMessage struct { Role types.String `tfsdk:"role" tf:"optional"` } +func (newState *ChatMessage) SyncEffectiveFieldsDuringCreateOrUpdate(plan ChatMessage) { +} + +func (newState *ChatMessage) SyncEffectiveFieldsDuringRead(existingState ChatMessage) { +} + type CohereConfig struct { // This is an optional field to provide a customized base URL for the Cohere // API. If left unspecified, the standard Cohere base URL is used. @@ -225,6 +321,12 @@ type CohereConfig struct { CohereApiKeyPlaintext types.String `tfsdk:"cohere_api_key_plaintext" tf:"optional"` } +func (newState *CohereConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan CohereConfig) { +} + +func (newState *CohereConfig) SyncEffectiveFieldsDuringRead(existingState CohereConfig) { +} + type CreateServingEndpoint struct { // The AI Gateway configuration for the serving endpoint. NOTE: only // external model endpoints are supported as of now. @@ -245,6 +347,12 @@ type CreateServingEndpoint struct { Tags []EndpointTag `tfsdk:"tags" tf:"optional"` } +func (newState *CreateServingEndpoint) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateServingEndpoint) { +} + +func (newState *CreateServingEndpoint) SyncEffectiveFieldsDuringRead(existingState CreateServingEndpoint) { +} + type DatabricksModelServingConfig struct { // The Databricks secret key reference for a Databricks API token that // corresponds to a user or service principal with Can Query access to the @@ -265,6 +373,12 @@ type DatabricksModelServingConfig struct { DatabricksWorkspaceUrl types.String `tfsdk:"databricks_workspace_url" tf:""` } +func (newState *DatabricksModelServingConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan DatabricksModelServingConfig) { +} + +func (newState *DatabricksModelServingConfig) SyncEffectiveFieldsDuringRead(existingState DatabricksModelServingConfig) { +} + type DataframeSplitInput struct { Columns []any `tfsdk:"columns" tf:"optional"` @@ -273,15 +387,33 @@ type DataframeSplitInput struct { Index []types.Int64 `tfsdk:"index" tf:"optional"` } +func (newState *DataframeSplitInput) SyncEffectiveFieldsDuringCreateOrUpdate(plan DataframeSplitInput) { +} + +func (newState *DataframeSplitInput) SyncEffectiveFieldsDuringRead(existingState DataframeSplitInput) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + // Delete a serving endpoint type DeleteServingEndpointRequest struct { // The name of the serving endpoint. This field is required. Name types.String `tfsdk:"-"` } +func (newState *DeleteServingEndpointRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteServingEndpointRequest) { +} + +func (newState *DeleteServingEndpointRequest) SyncEffectiveFieldsDuringRead(existingState DeleteServingEndpointRequest) { +} + type EmbeddingsV1ResponseEmbeddingElement struct { Embedding []types.Float64 `tfsdk:"embedding" tf:"optional"` // The index of the embedding in the response. @@ -290,6 +422,12 @@ type EmbeddingsV1ResponseEmbeddingElement struct { Object types.String `tfsdk:"object" tf:"optional"` } +func (newState *EmbeddingsV1ResponseEmbeddingElement) SyncEffectiveFieldsDuringCreateOrUpdate(plan EmbeddingsV1ResponseEmbeddingElement) { +} + +func (newState *EmbeddingsV1ResponseEmbeddingElement) SyncEffectiveFieldsDuringRead(existingState EmbeddingsV1ResponseEmbeddingElement) { +} + type EndpointCoreConfigInput struct { // Configuration for Inference Tables which automatically logs requests and // responses to Unity Catalog. @@ -307,6 +445,12 @@ type EndpointCoreConfigInput struct { TrafficConfig []TrafficConfig `tfsdk:"traffic_config" tf:"optional,object"` } +func (newState *EndpointCoreConfigInput) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointCoreConfigInput) { +} + +func (newState *EndpointCoreConfigInput) SyncEffectiveFieldsDuringRead(existingState EndpointCoreConfigInput) { +} + type EndpointCoreConfigOutput struct { // Configuration for Inference Tables which automatically logs requests and // responses to Unity Catalog. @@ -322,6 +466,12 @@ type EndpointCoreConfigOutput struct { TrafficConfig []TrafficConfig `tfsdk:"traffic_config" tf:"optional,object"` } +func (newState *EndpointCoreConfigOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointCoreConfigOutput) { +} + +func (newState *EndpointCoreConfigOutput) SyncEffectiveFieldsDuringRead(existingState EndpointCoreConfigOutput) { +} + type EndpointCoreConfigSummary struct { // The list of served entities under the serving endpoint config. ServedEntities []ServedEntitySpec `tfsdk:"served_entities" tf:"optional"` @@ -330,6 +480,12 @@ type EndpointCoreConfigSummary struct { ServedModels []ServedModelSpec `tfsdk:"served_models" tf:"optional"` } +func (newState *EndpointCoreConfigSummary) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointCoreConfigSummary) { +} + +func (newState *EndpointCoreConfigSummary) SyncEffectiveFieldsDuringRead(existingState EndpointCoreConfigSummary) { +} + type EndpointPendingConfig struct { // Configuration for Inference Tables which automatically logs requests and // responses to Unity Catalog. @@ -349,6 +505,12 @@ type EndpointPendingConfig struct { TrafficConfig []TrafficConfig `tfsdk:"traffic_config" tf:"optional,object"` } +func (newState *EndpointPendingConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointPendingConfig) { +} + +func (newState *EndpointPendingConfig) SyncEffectiveFieldsDuringRead(existingState EndpointPendingConfig) { +} + type EndpointState struct { // The state of an endpoint's config update. This informs the user if the // pending_config is in progress, if the update failed, or if there is no @@ -363,6 +525,12 @@ type EndpointState struct { Ready types.String `tfsdk:"ready" tf:"optional"` } +func (newState *EndpointState) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointState) { +} + +func (newState *EndpointState) SyncEffectiveFieldsDuringRead(existingState EndpointState) { +} + type EndpointTag struct { // Key field for a serving endpoint tag. Key types.String `tfsdk:"key" tf:""` @@ -370,6 +538,12 @@ type EndpointTag struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *EndpointTag) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointTag) { +} + +func (newState *EndpointTag) SyncEffectiveFieldsDuringRead(existingState EndpointTag) { +} + // Get metrics of a serving endpoint type ExportMetricsRequest struct { // The name of the serving endpoint to retrieve metrics for. This field is @@ -377,10 +551,22 @@ type ExportMetricsRequest struct { Name types.String `tfsdk:"-"` } +func (newState *ExportMetricsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExportMetricsRequest) { +} + +func (newState *ExportMetricsRequest) SyncEffectiveFieldsDuringRead(existingState ExportMetricsRequest) { +} + type ExportMetricsResponse struct { Contents io.ReadCloser `tfsdk:"-"` } +func (newState *ExportMetricsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExportMetricsResponse) { +} + +func (newState *ExportMetricsResponse) SyncEffectiveFieldsDuringRead(existingState ExportMetricsResponse) { +} + type ExternalModel struct { // AI21Labs Config. Only required if the provider is 'ai21labs'. Ai21labsConfig []Ai21LabsConfig `tfsdk:"ai21labs_config" tf:"optional,object"` @@ -411,6 +597,12 @@ type ExternalModel struct { Task types.String `tfsdk:"task" tf:""` } +func (newState *ExternalModel) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExternalModel) { +} + +func (newState *ExternalModel) SyncEffectiveFieldsDuringRead(existingState ExternalModel) { +} + type ExternalModelUsageElement struct { // The number of tokens in the chat/completions response. CompletionTokens types.Int64 `tfsdk:"completion_tokens" tf:"optional"` @@ -420,6 +612,12 @@ type ExternalModelUsageElement struct { TotalTokens types.Int64 `tfsdk:"total_tokens" tf:"optional"` } +func (newState *ExternalModelUsageElement) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExternalModelUsageElement) { +} + +func (newState *ExternalModelUsageElement) SyncEffectiveFieldsDuringRead(existingState ExternalModelUsageElement) { +} + type FoundationModel struct { // The description of the foundation model. Description types.String `tfsdk:"description" tf:"optional"` @@ -431,6 +629,12 @@ type FoundationModel struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *FoundationModel) SyncEffectiveFieldsDuringCreateOrUpdate(plan FoundationModel) { +} + +func (newState *FoundationModel) SyncEffectiveFieldsDuringRead(existingState FoundationModel) { +} + // Get the schema for a serving endpoint type GetOpenApiRequest struct { // The name of the serving endpoint that the served model belongs to. This @@ -438,34 +642,70 @@ type GetOpenApiRequest struct { Name types.String `tfsdk:"-"` } +func (newState *GetOpenApiRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetOpenApiRequest) { +} + +func (newState *GetOpenApiRequest) SyncEffectiveFieldsDuringRead(existingState GetOpenApiRequest) { +} + // The response is an OpenAPI spec in JSON format that typically includes fields // like openapi, info, servers and paths, etc. type GetOpenApiResponse struct { } +func (newState *GetOpenApiResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetOpenApiResponse) { +} + +func (newState *GetOpenApiResponse) SyncEffectiveFieldsDuringRead(existingState GetOpenApiResponse) { +} + // Get serving endpoint permission levels type GetServingEndpointPermissionLevelsRequest struct { // The serving endpoint for which to get or manage permissions. ServingEndpointId types.String `tfsdk:"-"` } +func (newState *GetServingEndpointPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetServingEndpointPermissionLevelsRequest) { +} + +func (newState *GetServingEndpointPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetServingEndpointPermissionLevelsRequest) { +} + type GetServingEndpointPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []ServingEndpointPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetServingEndpointPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetServingEndpointPermissionLevelsResponse) { +} + +func (newState *GetServingEndpointPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetServingEndpointPermissionLevelsResponse) { +} + // Get serving endpoint permissions type GetServingEndpointPermissionsRequest struct { // The serving endpoint for which to get or manage permissions. ServingEndpointId types.String `tfsdk:"-"` } +func (newState *GetServingEndpointPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetServingEndpointPermissionsRequest) { +} + +func (newState *GetServingEndpointPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetServingEndpointPermissionsRequest) { +} + // Get a single serving endpoint type GetServingEndpointRequest struct { // The name of the serving endpoint. This field is required. Name types.String `tfsdk:"-"` } +func (newState *GetServingEndpointRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetServingEndpointRequest) { +} + +func (newState *GetServingEndpointRequest) SyncEffectiveFieldsDuringRead(existingState GetServingEndpointRequest) { +} + type GoogleCloudVertexAiConfig struct { // The Databricks secret key reference for a private key for the service // account which has access to the Google Cloud Vertex AI Service. See [Best @@ -496,11 +736,23 @@ type GoogleCloudVertexAiConfig struct { Region types.String `tfsdk:"region" tf:"optional"` } +func (newState *GoogleCloudVertexAiConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan GoogleCloudVertexAiConfig) { +} + +func (newState *GoogleCloudVertexAiConfig) SyncEffectiveFieldsDuringRead(existingState GoogleCloudVertexAiConfig) { +} + type ListEndpointsResponse struct { // The list of endpoints. Endpoints []ServingEndpoint `tfsdk:"endpoints" tf:"optional"` } +func (newState *ListEndpointsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListEndpointsResponse) { +} + +func (newState *ListEndpointsResponse) SyncEffectiveFieldsDuringRead(existingState ListEndpointsResponse) { +} + // Get the latest logs for a served model type LogsRequest struct { // The name of the serving endpoint that the served model belongs to. This @@ -511,11 +763,23 @@ type LogsRequest struct { ServedModelName types.String `tfsdk:"-"` } +func (newState *LogsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan LogsRequest) { +} + +func (newState *LogsRequest) SyncEffectiveFieldsDuringRead(existingState LogsRequest) { +} + type ModelDataPlaneInfo struct { // Information required to query DataPlane API 'query' endpoint. QueryInfo oauth2.DataPlaneInfo `tfsdk:"query_info" tf:"optional,object"` } +func (newState *ModelDataPlaneInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ModelDataPlaneInfo) { +} + +func (newState *ModelDataPlaneInfo) SyncEffectiveFieldsDuringRead(existingState ModelDataPlaneInfo) { +} + type OpenAiConfig struct { // This field is only required for Azure AD OpenAI and is the Microsoft // Entra Client ID. @@ -570,6 +834,12 @@ type OpenAiConfig struct { OpenaiOrganization types.String `tfsdk:"openai_organization" tf:"optional"` } +func (newState *OpenAiConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan OpenAiConfig) { +} + +func (newState *OpenAiConfig) SyncEffectiveFieldsDuringRead(existingState OpenAiConfig) { +} + type PaLmConfig struct { // The Databricks secret key reference for a PaLM API key. If you prefer to // paste your API key directly, see `palm_api_key_plaintext`. You must @@ -583,6 +853,12 @@ type PaLmConfig struct { PalmApiKeyPlaintext types.String `tfsdk:"palm_api_key_plaintext" tf:"optional"` } +func (newState *PaLmConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan PaLmConfig) { +} + +func (newState *PaLmConfig) SyncEffectiveFieldsDuringRead(existingState PaLmConfig) { +} + type PatchServingEndpointTags struct { // List of endpoint tags to add AddTags []EndpointTag `tfsdk:"add_tags" tf:"optional"` @@ -593,6 +869,12 @@ type PatchServingEndpointTags struct { Name types.String `tfsdk:"-"` } +func (newState *PatchServingEndpointTags) SyncEffectiveFieldsDuringCreateOrUpdate(plan PatchServingEndpointTags) { +} + +func (newState *PatchServingEndpointTags) SyncEffectiveFieldsDuringRead(existingState PatchServingEndpointTags) { +} + type PayloadTable struct { // The name of the payload table. Name types.String `tfsdk:"name" tf:"optional"` @@ -602,6 +884,12 @@ type PayloadTable struct { StatusMessage types.String `tfsdk:"status_message" tf:"optional"` } +func (newState *PayloadTable) SyncEffectiveFieldsDuringCreateOrUpdate(plan PayloadTable) { +} + +func (newState *PayloadTable) SyncEffectiveFieldsDuringRead(existingState PayloadTable) { +} + // Update AI Gateway of a serving endpoint type PutAiGatewayRequest struct { // Configuration for AI Guardrails to prevent unwanted data and unsafe data @@ -622,6 +910,12 @@ type PutAiGatewayRequest struct { UsageTrackingConfig []AiGatewayUsageTrackingConfig `tfsdk:"usage_tracking_config" tf:"optional,object"` } +func (newState *PutAiGatewayRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan PutAiGatewayRequest) { +} + +func (newState *PutAiGatewayRequest) SyncEffectiveFieldsDuringRead(existingState PutAiGatewayRequest) { +} + type PutAiGatewayResponse struct { // Configuration for AI Guardrails to prevent unwanted data and unsafe data // in requests and responses. @@ -638,6 +932,12 @@ type PutAiGatewayResponse struct { UsageTrackingConfig []AiGatewayUsageTrackingConfig `tfsdk:"usage_tracking_config" tf:"optional,object"` } +func (newState *PutAiGatewayResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PutAiGatewayResponse) { +} + +func (newState *PutAiGatewayResponse) SyncEffectiveFieldsDuringRead(existingState PutAiGatewayResponse) { +} + // Update rate limits of a serving endpoint type PutRequest struct { // The name of the serving endpoint whose rate limits are being updated. @@ -647,11 +947,23 @@ type PutRequest struct { RateLimits []RateLimit `tfsdk:"rate_limits" tf:"optional"` } +func (newState *PutRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan PutRequest) { +} + +func (newState *PutRequest) SyncEffectiveFieldsDuringRead(existingState PutRequest) { +} + type PutResponse struct { // The list of endpoint rate limits. RateLimits []RateLimit `tfsdk:"rate_limits" tf:"optional"` } +func (newState *PutResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PutResponse) { +} + +func (newState *PutResponse) SyncEffectiveFieldsDuringRead(existingState PutResponse) { +} + type QueryEndpointInput struct { // Pandas Dataframe input in the records orientation. DataframeRecords []any `tfsdk:"dataframe_records" tf:"optional"` @@ -704,6 +1016,12 @@ type QueryEndpointInput struct { Temperature types.Float64 `tfsdk:"temperature" tf:"optional"` } +func (newState *QueryEndpointInput) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryEndpointInput) { +} + +func (newState *QueryEndpointInput) SyncEffectiveFieldsDuringRead(existingState QueryEndpointInput) { +} + type QueryEndpointResponse struct { // The list of choices returned by the __chat or completions // external/foundation model__ serving endpoint. @@ -735,6 +1053,12 @@ type QueryEndpointResponse struct { Usage []ExternalModelUsageElement `tfsdk:"usage" tf:"optional,object"` } +func (newState *QueryEndpointResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryEndpointResponse) { +} + +func (newState *QueryEndpointResponse) SyncEffectiveFieldsDuringRead(existingState QueryEndpointResponse) { +} + type RateLimit struct { // Used to specify how many calls are allowed for a key within the // renewal_period. @@ -748,6 +1072,12 @@ type RateLimit struct { RenewalPeriod types.String `tfsdk:"renewal_period" tf:""` } +func (newState *RateLimit) SyncEffectiveFieldsDuringCreateOrUpdate(plan RateLimit) { +} + +func (newState *RateLimit) SyncEffectiveFieldsDuringRead(existingState RateLimit) { +} + type Route struct { // The name of the served model this route configures traffic for. ServedModelName types.String `tfsdk:"served_model_name" tf:""` @@ -756,6 +1086,12 @@ type Route struct { TrafficPercentage types.Int64 `tfsdk:"traffic_percentage" tf:""` } +func (newState *Route) SyncEffectiveFieldsDuringCreateOrUpdate(plan Route) { +} + +func (newState *Route) SyncEffectiveFieldsDuringRead(existingState Route) { +} + type ServedEntityInput struct { // The name of the entity to be served. The entity may be a model in the // Databricks Model Registry, a model in the Unity Catalog (UC), or a @@ -817,6 +1153,12 @@ type ServedEntityInput struct { WorkloadType types.String `tfsdk:"workload_type" tf:"optional"` } +func (newState *ServedEntityInput) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServedEntityInput) { +} + +func (newState *ServedEntityInput) SyncEffectiveFieldsDuringRead(existingState ServedEntityInput) { +} + type ServedEntityOutput struct { // The creation timestamp of the served entity in Unix time. CreationTimestamp types.Int64 `tfsdk:"creation_timestamp" tf:"optional"` @@ -880,6 +1222,12 @@ type ServedEntityOutput struct { WorkloadType types.String `tfsdk:"workload_type" tf:"optional"` } +func (newState *ServedEntityOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServedEntityOutput) { +} + +func (newState *ServedEntityOutput) SyncEffectiveFieldsDuringRead(existingState ServedEntityOutput) { +} + type ServedEntitySpec struct { // The name of the entity served. The entity may be a model in the // Databricks Model Registry, a model in the Unity Catalog (UC), or a @@ -902,6 +1250,12 @@ type ServedEntitySpec struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *ServedEntitySpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServedEntitySpec) { +} + +func (newState *ServedEntitySpec) SyncEffectiveFieldsDuringRead(existingState ServedEntitySpec) { +} + type ServedModelInput struct { // An object containing a set of optional, user-specified environment // variable key-value pairs used for serving this model. Note: this is an @@ -950,6 +1304,12 @@ type ServedModelInput struct { WorkloadType types.String `tfsdk:"workload_type" tf:"optional"` } +func (newState *ServedModelInput) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServedModelInput) { +} + +func (newState *ServedModelInput) SyncEffectiveFieldsDuringRead(existingState ServedModelInput) { +} + type ServedModelOutput struct { // The creation timestamp of the served model in Unix time. CreationTimestamp types.Int64 `tfsdk:"creation_timestamp" tf:"optional"` @@ -996,6 +1356,12 @@ type ServedModelOutput struct { WorkloadType types.String `tfsdk:"workload_type" tf:"optional"` } +func (newState *ServedModelOutput) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServedModelOutput) { +} + +func (newState *ServedModelOutput) SyncEffectiveFieldsDuringRead(existingState ServedModelOutput) { +} + type ServedModelSpec struct { // The name of the model in Databricks Model Registry or the full name of // the model in Unity Catalog. @@ -1007,6 +1373,12 @@ type ServedModelSpec struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *ServedModelSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServedModelSpec) { +} + +func (newState *ServedModelSpec) SyncEffectiveFieldsDuringRead(existingState ServedModelSpec) { +} + type ServedModelState struct { // The state of the served entity deployment. DEPLOYMENT_CREATING indicates // that the served entity is not ready yet because the deployment is still @@ -1025,12 +1397,24 @@ type ServedModelState struct { DeploymentStateMessage types.String `tfsdk:"deployment_state_message" tf:"optional"` } +func (newState *ServedModelState) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServedModelState) { +} + +func (newState *ServedModelState) SyncEffectiveFieldsDuringRead(existingState ServedModelState) { +} + type ServerLogsResponse struct { // The most recent log lines of the model server processing invocation // requests. Logs types.String `tfsdk:"logs" tf:""` } +func (newState *ServerLogsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServerLogsResponse) { +} + +func (newState *ServerLogsResponse) SyncEffectiveFieldsDuringRead(existingState ServerLogsResponse) { +} + type ServingEndpoint struct { // The AI Gateway configuration for the serving endpoint. NOTE: Only // external model endpoints are currently supported. @@ -1056,6 +1440,12 @@ type ServingEndpoint struct { Task types.String `tfsdk:"task" tf:"optional"` } +func (newState *ServingEndpoint) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServingEndpoint) { +} + +func (newState *ServingEndpoint) SyncEffectiveFieldsDuringRead(existingState ServingEndpoint) { +} + type ServingEndpointAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -1067,6 +1457,12 @@ type ServingEndpointAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *ServingEndpointAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServingEndpointAccessControlRequest) { +} + +func (newState *ServingEndpointAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState ServingEndpointAccessControlRequest) { +} + type ServingEndpointAccessControlResponse struct { // All permissions. AllPermissions []ServingEndpointPermission `tfsdk:"all_permissions" tf:"optional"` @@ -1080,6 +1476,12 @@ type ServingEndpointAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *ServingEndpointAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServingEndpointAccessControlResponse) { +} + +func (newState *ServingEndpointAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState ServingEndpointAccessControlResponse) { +} + type ServingEndpointDetailed struct { // The AI Gateway configuration for the serving endpoint. NOTE: Only // external model endpoints are currently supported. @@ -1116,6 +1518,12 @@ type ServingEndpointDetailed struct { Task types.String `tfsdk:"task" tf:"optional"` } +func (newState *ServingEndpointDetailed) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServingEndpointDetailed) { +} + +func (newState *ServingEndpointDetailed) SyncEffectiveFieldsDuringRead(existingState ServingEndpointDetailed) { +} + type ServingEndpointPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -1124,6 +1532,12 @@ type ServingEndpointPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *ServingEndpointPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServingEndpointPermission) { +} + +func (newState *ServingEndpointPermission) SyncEffectiveFieldsDuringRead(existingState ServingEndpointPermission) { +} + type ServingEndpointPermissions struct { AccessControlList []ServingEndpointAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -1132,23 +1546,47 @@ type ServingEndpointPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *ServingEndpointPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServingEndpointPermissions) { +} + +func (newState *ServingEndpointPermissions) SyncEffectiveFieldsDuringRead(existingState ServingEndpointPermissions) { +} + type ServingEndpointPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *ServingEndpointPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServingEndpointPermissionsDescription) { +} + +func (newState *ServingEndpointPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState ServingEndpointPermissionsDescription) { +} + type ServingEndpointPermissionsRequest struct { AccessControlList []ServingEndpointAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The serving endpoint for which to get or manage permissions. ServingEndpointId types.String `tfsdk:"-"` } +func (newState *ServingEndpointPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServingEndpointPermissionsRequest) { +} + +func (newState *ServingEndpointPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState ServingEndpointPermissionsRequest) { +} + type TrafficConfig struct { // The list of routes that define traffic to each served entity. Routes []Route `tfsdk:"routes" tf:"optional"` } +func (newState *TrafficConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan TrafficConfig) { +} + +func (newState *TrafficConfig) SyncEffectiveFieldsDuringRead(existingState TrafficConfig) { +} + type V1ResponseChoiceElement struct { // The finish reason returned by the endpoint. FinishReason types.String `tfsdk:"finishReason" tf:"optional"` @@ -1161,3 +1599,9 @@ type V1ResponseChoiceElement struct { // The text response from the __completions__ endpoint. Text types.String `tfsdk:"text" tf:"optional"` } + +func (newState *V1ResponseChoiceElement) SyncEffectiveFieldsDuringCreateOrUpdate(plan V1ResponseChoiceElement) { +} + +func (newState *V1ResponseChoiceElement) SyncEffectiveFieldsDuringRead(existingState V1ResponseChoiceElement) { +} diff --git a/internal/service/settings_tf/model.go b/internal/service/settings_tf/model.go index a3fad58cb7..3ca9895b89 100755 --- a/internal/service/settings_tf/model.go +++ b/internal/service/settings_tf/model.go @@ -32,10 +32,22 @@ type AutomaticClusterUpdateSetting struct { SettingName types.String `tfsdk:"setting_name" tf:"optional"` } +func (newState *AutomaticClusterUpdateSetting) SyncEffectiveFieldsDuringCreateOrUpdate(plan AutomaticClusterUpdateSetting) { +} + +func (newState *AutomaticClusterUpdateSetting) SyncEffectiveFieldsDuringRead(existingState AutomaticClusterUpdateSetting) { +} + type BooleanMessage struct { Value types.Bool `tfsdk:"value" tf:"optional"` } +func (newState *BooleanMessage) SyncEffectiveFieldsDuringCreateOrUpdate(plan BooleanMessage) { +} + +func (newState *BooleanMessage) SyncEffectiveFieldsDuringRead(existingState BooleanMessage) { +} + type ClusterAutoRestartMessage struct { CanToggle types.Bool `tfsdk:"can_toggle" tf:"optional"` @@ -53,6 +65,12 @@ type ClusterAutoRestartMessage struct { RestartEvenIfNoUpdatesAvailable types.Bool `tfsdk:"restart_even_if_no_updates_available" tf:"optional"` } +func (newState *ClusterAutoRestartMessage) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterAutoRestartMessage) { +} + +func (newState *ClusterAutoRestartMessage) SyncEffectiveFieldsDuringRead(existingState ClusterAutoRestartMessage) { +} + // Contains an information about the enablement status judging (e.g. whether the // enterprise tier is enabled) This is only additional information that MUST NOT // be used to decide whether the setting is enabled or not. This is intended to @@ -69,10 +87,22 @@ type ClusterAutoRestartMessageEnablementDetails struct { UnavailableForNonEnterpriseTier types.Bool `tfsdk:"unavailable_for_non_enterprise_tier" tf:"optional"` } +func (newState *ClusterAutoRestartMessageEnablementDetails) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterAutoRestartMessageEnablementDetails) { +} + +func (newState *ClusterAutoRestartMessageEnablementDetails) SyncEffectiveFieldsDuringRead(existingState ClusterAutoRestartMessageEnablementDetails) { +} + type ClusterAutoRestartMessageMaintenanceWindow struct { WeekDayBasedSchedule []ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule `tfsdk:"week_day_based_schedule" tf:"optional,object"` } +func (newState *ClusterAutoRestartMessageMaintenanceWindow) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterAutoRestartMessageMaintenanceWindow) { +} + +func (newState *ClusterAutoRestartMessageMaintenanceWindow) SyncEffectiveFieldsDuringRead(existingState ClusterAutoRestartMessageMaintenanceWindow) { +} + type ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule struct { DayOfWeek types.String `tfsdk:"day_of_week" tf:"optional"` @@ -81,12 +111,24 @@ type ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule struct { WindowStartTime []ClusterAutoRestartMessageMaintenanceWindowWindowStartTime `tfsdk:"window_start_time" tf:"optional,object"` } +func (newState *ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule) { +} + +func (newState *ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule) SyncEffectiveFieldsDuringRead(existingState ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule) { +} + type ClusterAutoRestartMessageMaintenanceWindowWindowStartTime struct { Hours types.Int64 `tfsdk:"hours" tf:"optional"` Minutes types.Int64 `tfsdk:"minutes" tf:"optional"` } +func (newState *ClusterAutoRestartMessageMaintenanceWindowWindowStartTime) SyncEffectiveFieldsDuringCreateOrUpdate(plan ClusterAutoRestartMessageMaintenanceWindowWindowStartTime) { +} + +func (newState *ClusterAutoRestartMessageMaintenanceWindowWindowStartTime) SyncEffectiveFieldsDuringRead(existingState ClusterAutoRestartMessageMaintenanceWindowWindowStartTime) { +} + // SHIELD feature: CSP type ComplianceSecurityProfile struct { // Set by customers when they request Compliance Security Profile (CSP) @@ -95,6 +137,12 @@ type ComplianceSecurityProfile struct { IsEnabled types.Bool `tfsdk:"is_enabled" tf:"optional"` } +func (newState *ComplianceSecurityProfile) SyncEffectiveFieldsDuringCreateOrUpdate(plan ComplianceSecurityProfile) { +} + +func (newState *ComplianceSecurityProfile) SyncEffectiveFieldsDuringRead(existingState ComplianceSecurityProfile) { +} + type ComplianceSecurityProfileSetting struct { // SHIELD feature: CSP ComplianceSecurityProfileWorkspace []ComplianceSecurityProfile `tfsdk:"compliance_security_profile_workspace" tf:"object"` @@ -114,6 +162,12 @@ type ComplianceSecurityProfileSetting struct { SettingName types.String `tfsdk:"setting_name" tf:"optional"` } +func (newState *ComplianceSecurityProfileSetting) SyncEffectiveFieldsDuringCreateOrUpdate(plan ComplianceSecurityProfileSetting) { +} + +func (newState *ComplianceSecurityProfileSetting) SyncEffectiveFieldsDuringRead(existingState ComplianceSecurityProfileSetting) { +} + type Config struct { Email []EmailConfig `tfsdk:"email" tf:"optional,object"` @@ -126,6 +180,12 @@ type Config struct { Slack []SlackConfig `tfsdk:"slack" tf:"optional,object"` } +func (newState *Config) SyncEffectiveFieldsDuringCreateOrUpdate(plan Config) { +} + +func (newState *Config) SyncEffectiveFieldsDuringRead(existingState Config) { +} + // Details required to configure a block list or allow list. type CreateIpAccessList struct { IpAddresses []types.String `tfsdk:"ip_addresses" tf:"optional"` @@ -140,12 +200,24 @@ type CreateIpAccessList struct { ListType types.String `tfsdk:"list_type" tf:""` } +func (newState *CreateIpAccessList) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateIpAccessList) { +} + +func (newState *CreateIpAccessList) SyncEffectiveFieldsDuringRead(existingState CreateIpAccessList) { +} + // An IP access list was successfully created. type CreateIpAccessListResponse struct { // Definition of an IP Access list IpAccessList []IpAccessListInfo `tfsdk:"ip_access_list" tf:"optional,object"` } +func (newState *CreateIpAccessListResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateIpAccessListResponse) { +} + +func (newState *CreateIpAccessListResponse) SyncEffectiveFieldsDuringRead(existingState CreateIpAccessListResponse) { +} + type CreateNetworkConnectivityConfigRequest struct { // The name of the network connectivity configuration. The name can contain // alphanumeric characters, hyphens, and underscores. The length must be @@ -158,6 +230,12 @@ type CreateNetworkConnectivityConfigRequest struct { Region types.String `tfsdk:"region" tf:""` } +func (newState *CreateNetworkConnectivityConfigRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateNetworkConnectivityConfigRequest) { +} + +func (newState *CreateNetworkConnectivityConfigRequest) SyncEffectiveFieldsDuringRead(existingState CreateNetworkConnectivityConfigRequest) { +} + type CreateNotificationDestinationRequest struct { // The configuration for the notification destination. Must wrap EXACTLY one // of the nested configs. @@ -166,6 +244,12 @@ type CreateNotificationDestinationRequest struct { DisplayName types.String `tfsdk:"display_name" tf:"optional"` } +func (newState *CreateNotificationDestinationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateNotificationDestinationRequest) { +} + +func (newState *CreateNotificationDestinationRequest) SyncEffectiveFieldsDuringRead(existingState CreateNotificationDestinationRequest) { +} + // Configuration details for creating on-behalf tokens. type CreateOboTokenRequest struct { // Application ID of the service principal. @@ -176,6 +260,12 @@ type CreateOboTokenRequest struct { LifetimeSeconds types.Int64 `tfsdk:"lifetime_seconds" tf:"optional"` } +func (newState *CreateOboTokenRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateOboTokenRequest) { +} + +func (newState *CreateOboTokenRequest) SyncEffectiveFieldsDuringRead(existingState CreateOboTokenRequest) { +} + // An on-behalf token was successfully created for the service principal. type CreateOboTokenResponse struct { TokenInfo []TokenInfo `tfsdk:"token_info" tf:"optional,object"` @@ -183,6 +273,12 @@ type CreateOboTokenResponse struct { TokenValue types.String `tfsdk:"token_value" tf:"optional"` } +func (newState *CreateOboTokenResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateOboTokenResponse) { +} + +func (newState *CreateOboTokenResponse) SyncEffectiveFieldsDuringRead(existingState CreateOboTokenResponse) { +} + type CreatePrivateEndpointRuleRequest struct { // The sub-resource type (group ID) of the target resource. Note that to // connect to workspace root storage (root DBFS), you need two endpoints, @@ -194,6 +290,12 @@ type CreatePrivateEndpointRuleRequest struct { ResourceId types.String `tfsdk:"resource_id" tf:""` } +func (newState *CreatePrivateEndpointRuleRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreatePrivateEndpointRuleRequest) { +} + +func (newState *CreatePrivateEndpointRuleRequest) SyncEffectiveFieldsDuringRead(existingState CreatePrivateEndpointRuleRequest) { +} + type CreateTokenRequest struct { // Optional description to attach to the token. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -203,6 +305,12 @@ type CreateTokenRequest struct { LifetimeSeconds types.Int64 `tfsdk:"lifetime_seconds" tf:"optional"` } +func (newState *CreateTokenRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateTokenRequest) { +} + +func (newState *CreateTokenRequest) SyncEffectiveFieldsDuringRead(existingState CreateTokenRequest) { +} + type CreateTokenResponse struct { // The information for the new token. TokenInfo []PublicTokenInfo `tfsdk:"token_info" tf:"optional,object"` @@ -210,6 +318,12 @@ type CreateTokenResponse struct { TokenValue types.String `tfsdk:"token_value" tf:"optional"` } +func (newState *CreateTokenResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateTokenResponse) { +} + +func (newState *CreateTokenResponse) SyncEffectiveFieldsDuringRead(existingState CreateTokenResponse) { +} + // Account level policy for CSP type CspEnablementAccount struct { // Set by customers when they request Compliance Security Profile (CSP) @@ -219,6 +333,12 @@ type CspEnablementAccount struct { IsEnforced types.Bool `tfsdk:"is_enforced" tf:"optional"` } +func (newState *CspEnablementAccount) SyncEffectiveFieldsDuringCreateOrUpdate(plan CspEnablementAccount) { +} + +func (newState *CspEnablementAccount) SyncEffectiveFieldsDuringRead(existingState CspEnablementAccount) { +} + type CspEnablementAccountSetting struct { // Account level policy for CSP CspEnablementAccount []CspEnablementAccount `tfsdk:"csp_enablement_account" tf:"object"` @@ -238,6 +358,12 @@ type CspEnablementAccountSetting struct { SettingName types.String `tfsdk:"setting_name" tf:"optional"` } +func (newState *CspEnablementAccountSetting) SyncEffectiveFieldsDuringCreateOrUpdate(plan CspEnablementAccountSetting) { +} + +func (newState *CspEnablementAccountSetting) SyncEffectiveFieldsDuringRead(existingState CspEnablementAccountSetting) { +} + // This represents the setting configuration for the default namespace in the // Databricks workspace. Setting the default catalog for the workspace // determines the catalog that is used when queries do not reference a fully @@ -266,12 +392,24 @@ type DefaultNamespaceSetting struct { SettingName types.String `tfsdk:"setting_name" tf:"optional"` } +func (newState *DefaultNamespaceSetting) SyncEffectiveFieldsDuringCreateOrUpdate(plan DefaultNamespaceSetting) { +} + +func (newState *DefaultNamespaceSetting) SyncEffectiveFieldsDuringRead(existingState DefaultNamespaceSetting) { +} + // Delete access list type DeleteAccountIpAccessListRequest struct { // The ID for the corresponding IP access list IpAccessListId types.String `tfsdk:"-"` } +func (newState *DeleteAccountIpAccessListRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAccountIpAccessListRequest) { +} + +func (newState *DeleteAccountIpAccessListRequest) SyncEffectiveFieldsDuringRead(existingState DeleteAccountIpAccessListRequest) { +} + // Delete the default namespace setting type DeleteDefaultNamespaceSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -284,6 +422,12 @@ type DeleteDefaultNamespaceSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *DeleteDefaultNamespaceSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDefaultNamespaceSettingRequest) { +} + +func (newState *DeleteDefaultNamespaceSettingRequest) SyncEffectiveFieldsDuringRead(existingState DeleteDefaultNamespaceSettingRequest) { +} + // The etag is returned. type DeleteDefaultNamespaceSettingResponse struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -296,6 +440,12 @@ type DeleteDefaultNamespaceSettingResponse struct { Etag types.String `tfsdk:"etag" tf:""` } +func (newState *DeleteDefaultNamespaceSettingResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDefaultNamespaceSettingResponse) { +} + +func (newState *DeleteDefaultNamespaceSettingResponse) SyncEffectiveFieldsDuringRead(existingState DeleteDefaultNamespaceSettingResponse) { +} + // Delete Legacy Access Disablement Status type DeleteDisableLegacyAccessRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -308,6 +458,12 @@ type DeleteDisableLegacyAccessRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *DeleteDisableLegacyAccessRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDisableLegacyAccessRequest) { +} + +func (newState *DeleteDisableLegacyAccessRequest) SyncEffectiveFieldsDuringRead(existingState DeleteDisableLegacyAccessRequest) { +} + // The etag is returned. type DeleteDisableLegacyAccessResponse struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -320,6 +476,48 @@ type DeleteDisableLegacyAccessResponse struct { Etag types.String `tfsdk:"etag" tf:""` } +func (newState *DeleteDisableLegacyAccessResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDisableLegacyAccessResponse) { +} + +func (newState *DeleteDisableLegacyAccessResponse) SyncEffectiveFieldsDuringRead(existingState DeleteDisableLegacyAccessResponse) { +} + +// Delete the disable legacy DBFS setting +type DeleteDisableLegacyDbfsRequest struct { + // etag used for versioning. The response is at least as fresh as the eTag + // provided. This is used for optimistic concurrency control as a way to + // help prevent simultaneous writes of a setting overwriting each other. It + // is strongly suggested that systems make use of the etag in the read -> + // delete pattern to perform setting deletions in order to avoid race + // conditions. That is, get an etag from a GET request, and pass it with the + // DELETE request to identify the rule set version you are deleting. + Etag types.String `tfsdk:"-"` +} + +func (newState *DeleteDisableLegacyDbfsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDisableLegacyDbfsRequest) { +} + +func (newState *DeleteDisableLegacyDbfsRequest) SyncEffectiveFieldsDuringRead(existingState DeleteDisableLegacyDbfsRequest) { +} + +// The etag is returned. +type DeleteDisableLegacyDbfsResponse struct { + // etag used for versioning. The response is at least as fresh as the eTag + // provided. This is used for optimistic concurrency control as a way to + // help prevent simultaneous writes of a setting overwriting each other. It + // is strongly suggested that systems make use of the etag in the read -> + // delete pattern to perform setting deletions in order to avoid race + // conditions. That is, get an etag from a GET request, and pass it with the + // DELETE request to identify the rule set version you are deleting. + Etag types.String `tfsdk:"etag" tf:""` +} + +func (newState *DeleteDisableLegacyDbfsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDisableLegacyDbfsResponse) { +} + +func (newState *DeleteDisableLegacyDbfsResponse) SyncEffectiveFieldsDuringRead(existingState DeleteDisableLegacyDbfsResponse) { +} + // Delete the disable legacy features setting type DeleteDisableLegacyFeaturesRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -332,6 +530,12 @@ type DeleteDisableLegacyFeaturesRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *DeleteDisableLegacyFeaturesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDisableLegacyFeaturesRequest) { +} + +func (newState *DeleteDisableLegacyFeaturesRequest) SyncEffectiveFieldsDuringRead(existingState DeleteDisableLegacyFeaturesRequest) { +} + // The etag is returned. type DeleteDisableLegacyFeaturesResponse struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -344,26 +548,56 @@ type DeleteDisableLegacyFeaturesResponse struct { Etag types.String `tfsdk:"etag" tf:""` } +func (newState *DeleteDisableLegacyFeaturesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDisableLegacyFeaturesResponse) { +} + +func (newState *DeleteDisableLegacyFeaturesResponse) SyncEffectiveFieldsDuringRead(existingState DeleteDisableLegacyFeaturesResponse) { +} + // Delete access list type DeleteIpAccessListRequest struct { // The ID for the corresponding IP access list IpAccessListId types.String `tfsdk:"-"` } +func (newState *DeleteIpAccessListRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteIpAccessListRequest) { +} + +func (newState *DeleteIpAccessListRequest) SyncEffectiveFieldsDuringRead(existingState DeleteIpAccessListRequest) { +} + // Delete a network connectivity configuration type DeleteNetworkConnectivityConfigurationRequest struct { // Your Network Connectvity Configuration ID. NetworkConnectivityConfigId types.String `tfsdk:"-"` } +func (newState *DeleteNetworkConnectivityConfigurationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteNetworkConnectivityConfigurationRequest) { +} + +func (newState *DeleteNetworkConnectivityConfigurationRequest) SyncEffectiveFieldsDuringRead(existingState DeleteNetworkConnectivityConfigurationRequest) { +} + type DeleteNetworkConnectivityConfigurationResponse struct { } +func (newState *DeleteNetworkConnectivityConfigurationResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteNetworkConnectivityConfigurationResponse) { +} + +func (newState *DeleteNetworkConnectivityConfigurationResponse) SyncEffectiveFieldsDuringRead(existingState DeleteNetworkConnectivityConfigurationResponse) { +} + // Delete a notification destination type DeleteNotificationDestinationRequest struct { Id types.String `tfsdk:"-"` } +func (newState *DeleteNotificationDestinationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteNotificationDestinationRequest) { +} + +func (newState *DeleteNotificationDestinationRequest) SyncEffectiveFieldsDuringRead(existingState DeleteNotificationDestinationRequest) { +} + // Delete Personal Compute setting type DeletePersonalComputeSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -376,6 +610,12 @@ type DeletePersonalComputeSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *DeletePersonalComputeSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeletePersonalComputeSettingRequest) { +} + +func (newState *DeletePersonalComputeSettingRequest) SyncEffectiveFieldsDuringRead(existingState DeletePersonalComputeSettingRequest) { +} + // The etag is returned. type DeletePersonalComputeSettingResponse struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -388,6 +628,12 @@ type DeletePersonalComputeSettingResponse struct { Etag types.String `tfsdk:"etag" tf:""` } +func (newState *DeletePersonalComputeSettingResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeletePersonalComputeSettingResponse) { +} + +func (newState *DeletePersonalComputeSettingResponse) SyncEffectiveFieldsDuringRead(existingState DeletePersonalComputeSettingResponse) { +} + // Delete a private endpoint rule type DeletePrivateEndpointRuleRequest struct { // Your Network Connectvity Configuration ID. @@ -396,9 +642,21 @@ type DeletePrivateEndpointRuleRequest struct { PrivateEndpointRuleId types.String `tfsdk:"-"` } +func (newState *DeletePrivateEndpointRuleRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeletePrivateEndpointRuleRequest) { +} + +func (newState *DeletePrivateEndpointRuleRequest) SyncEffectiveFieldsDuringRead(existingState DeletePrivateEndpointRuleRequest) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + // Delete the restrict workspace admins setting type DeleteRestrictWorkspaceAdminsSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -411,6 +669,12 @@ type DeleteRestrictWorkspaceAdminsSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *DeleteRestrictWorkspaceAdminsSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRestrictWorkspaceAdminsSettingRequest) { +} + +func (newState *DeleteRestrictWorkspaceAdminsSettingRequest) SyncEffectiveFieldsDuringRead(existingState DeleteRestrictWorkspaceAdminsSettingRequest) { +} + // The etag is returned. type DeleteRestrictWorkspaceAdminsSettingResponse struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -423,12 +687,24 @@ type DeleteRestrictWorkspaceAdminsSettingResponse struct { Etag types.String `tfsdk:"etag" tf:""` } +func (newState *DeleteRestrictWorkspaceAdminsSettingResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRestrictWorkspaceAdminsSettingResponse) { +} + +func (newState *DeleteRestrictWorkspaceAdminsSettingResponse) SyncEffectiveFieldsDuringRead(existingState DeleteRestrictWorkspaceAdminsSettingResponse) { +} + // Delete a token type DeleteTokenManagementRequest struct { // The ID of the token to get. TokenId types.String `tfsdk:"-"` } +func (newState *DeleteTokenManagementRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteTokenManagementRequest) { +} + +func (newState *DeleteTokenManagementRequest) SyncEffectiveFieldsDuringRead(existingState DeleteTokenManagementRequest) { +} + type DisableLegacyAccess struct { DisableLegacyAccess []BooleanMessage `tfsdk:"disable_legacy_access" tf:"object"` // etag used for versioning. The response is at least as fresh as the eTag @@ -447,6 +723,36 @@ type DisableLegacyAccess struct { SettingName types.String `tfsdk:"setting_name" tf:"optional"` } +func (newState *DisableLegacyAccess) SyncEffectiveFieldsDuringCreateOrUpdate(plan DisableLegacyAccess) { +} + +func (newState *DisableLegacyAccess) SyncEffectiveFieldsDuringRead(existingState DisableLegacyAccess) { +} + +type DisableLegacyDbfs struct { + DisableLegacyDbfs []BooleanMessage `tfsdk:"disable_legacy_dbfs" tf:"object"` + // etag used for versioning. The response is at least as fresh as the eTag + // provided. This is used for optimistic concurrency control as a way to + // help prevent simultaneous writes of a setting overwriting each other. It + // is strongly suggested that systems make use of the etag in the read -> + // update pattern to perform setting updates in order to avoid race + // conditions. That is, get an etag from a GET request, and pass it with the + // PATCH request to identify the setting version you are updating. + Etag types.String `tfsdk:"etag" tf:"optional"` + // Name of the corresponding setting. This field is populated in the + // response, but it will not be respected even if it's set in the request + // body. The setting name in the path parameter will be respected instead. + // Setting name is required to be 'default' if the setting only has one + // instance per workspace. + SettingName types.String `tfsdk:"setting_name" tf:"optional"` +} + +func (newState *DisableLegacyDbfs) SyncEffectiveFieldsDuringCreateOrUpdate(plan DisableLegacyDbfs) { +} + +func (newState *DisableLegacyDbfs) SyncEffectiveFieldsDuringRead(existingState DisableLegacyDbfs) { +} + type DisableLegacyFeatures struct { DisableLegacyFeatures []BooleanMessage `tfsdk:"disable_legacy_features" tf:"object"` // etag used for versioning. The response is at least as fresh as the eTag @@ -465,19 +771,43 @@ type DisableLegacyFeatures struct { SettingName types.String `tfsdk:"setting_name" tf:"optional"` } +func (newState *DisableLegacyFeatures) SyncEffectiveFieldsDuringCreateOrUpdate(plan DisableLegacyFeatures) { +} + +func (newState *DisableLegacyFeatures) SyncEffectiveFieldsDuringRead(existingState DisableLegacyFeatures) { +} + type EmailConfig struct { // Email addresses to notify. Addresses []types.String `tfsdk:"addresses" tf:"optional"` } +func (newState *EmailConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan EmailConfig) { +} + +func (newState *EmailConfig) SyncEffectiveFieldsDuringRead(existingState EmailConfig) { +} + type Empty struct { } +func (newState *Empty) SyncEffectiveFieldsDuringCreateOrUpdate(plan Empty) { +} + +func (newState *Empty) SyncEffectiveFieldsDuringRead(existingState Empty) { +} + // SHIELD feature: ESM type EnhancedSecurityMonitoring struct { IsEnabled types.Bool `tfsdk:"is_enabled" tf:"optional"` } +func (newState *EnhancedSecurityMonitoring) SyncEffectiveFieldsDuringCreateOrUpdate(plan EnhancedSecurityMonitoring) { +} + +func (newState *EnhancedSecurityMonitoring) SyncEffectiveFieldsDuringRead(existingState EnhancedSecurityMonitoring) { +} + type EnhancedSecurityMonitoringSetting struct { // SHIELD feature: ESM EnhancedSecurityMonitoringWorkspace []EnhancedSecurityMonitoring `tfsdk:"enhanced_security_monitoring_workspace" tf:"object"` @@ -497,11 +827,23 @@ type EnhancedSecurityMonitoringSetting struct { SettingName types.String `tfsdk:"setting_name" tf:"optional"` } +func (newState *EnhancedSecurityMonitoringSetting) SyncEffectiveFieldsDuringCreateOrUpdate(plan EnhancedSecurityMonitoringSetting) { +} + +func (newState *EnhancedSecurityMonitoringSetting) SyncEffectiveFieldsDuringRead(existingState EnhancedSecurityMonitoringSetting) { +} + // Account level policy for ESM type EsmEnablementAccount struct { IsEnforced types.Bool `tfsdk:"is_enforced" tf:"optional"` } +func (newState *EsmEnablementAccount) SyncEffectiveFieldsDuringCreateOrUpdate(plan EsmEnablementAccount) { +} + +func (newState *EsmEnablementAccount) SyncEffectiveFieldsDuringRead(existingState EsmEnablementAccount) { +} + type EsmEnablementAccountSetting struct { // Account level policy for ESM EsmEnablementAccount []EsmEnablementAccount `tfsdk:"esm_enablement_account" tf:"object"` @@ -521,6 +863,12 @@ type EsmEnablementAccountSetting struct { SettingName types.String `tfsdk:"setting_name" tf:"optional"` } +func (newState *EsmEnablementAccountSetting) SyncEffectiveFieldsDuringCreateOrUpdate(plan EsmEnablementAccountSetting) { +} + +func (newState *EsmEnablementAccountSetting) SyncEffectiveFieldsDuringRead(existingState EsmEnablementAccountSetting) { +} + // The exchange token is the result of the token exchange with the IdP type ExchangeToken struct { // The requested token. @@ -536,6 +884,12 @@ type ExchangeToken struct { TokenType types.String `tfsdk:"tokenType" tf:"optional"` } +func (newState *ExchangeToken) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExchangeToken) { +} + +func (newState *ExchangeToken) SyncEffectiveFieldsDuringRead(existingState ExchangeToken) { +} + // Exchange a token with the IdP type ExchangeTokenRequest struct { // The partition of Credentials store @@ -546,17 +900,35 @@ type ExchangeTokenRequest struct { TokenType []types.String `tfsdk:"tokenType" tf:""` } +func (newState *ExchangeTokenRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExchangeTokenRequest) { +} + +func (newState *ExchangeTokenRequest) SyncEffectiveFieldsDuringRead(existingState ExchangeTokenRequest) { +} + // Exhanged tokens were successfully returned. type ExchangeTokenResponse struct { Values []ExchangeToken `tfsdk:"values" tf:"optional"` } +func (newState *ExchangeTokenResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExchangeTokenResponse) { +} + +func (newState *ExchangeTokenResponse) SyncEffectiveFieldsDuringRead(existingState ExchangeTokenResponse) { +} + // An IP access list was successfully returned. type FetchIpAccessListResponse struct { // Definition of an IP Access list IpAccessList []IpAccessListInfo `tfsdk:"ip_access_list" tf:"optional,object"` } +func (newState *FetchIpAccessListResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan FetchIpAccessListResponse) { +} + +func (newState *FetchIpAccessListResponse) SyncEffectiveFieldsDuringRead(existingState FetchIpAccessListResponse) { +} + type GenericWebhookConfig struct { // [Input-Only][Optional] Password for webhook. Password types.String `tfsdk:"password" tf:"optional"` @@ -572,12 +944,24 @@ type GenericWebhookConfig struct { UsernameSet types.Bool `tfsdk:"username_set" tf:"optional"` } +func (newState *GenericWebhookConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan GenericWebhookConfig) { +} + +func (newState *GenericWebhookConfig) SyncEffectiveFieldsDuringRead(existingState GenericWebhookConfig) { +} + // Get IP access list type GetAccountIpAccessListRequest struct { // The ID for the corresponding IP access list IpAccessListId types.String `tfsdk:"-"` } +func (newState *GetAccountIpAccessListRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAccountIpAccessListRequest) { +} + +func (newState *GetAccountIpAccessListRequest) SyncEffectiveFieldsDuringRead(existingState GetAccountIpAccessListRequest) { +} + // Get the automatic cluster update setting type GetAutomaticClusterUpdateSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -590,6 +974,12 @@ type GetAutomaticClusterUpdateSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *GetAutomaticClusterUpdateSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAutomaticClusterUpdateSettingRequest) { +} + +func (newState *GetAutomaticClusterUpdateSettingRequest) SyncEffectiveFieldsDuringRead(existingState GetAutomaticClusterUpdateSettingRequest) { +} + // Get the compliance security profile setting type GetComplianceSecurityProfileSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -602,6 +992,12 @@ type GetComplianceSecurityProfileSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *GetComplianceSecurityProfileSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetComplianceSecurityProfileSettingRequest) { +} + +func (newState *GetComplianceSecurityProfileSettingRequest) SyncEffectiveFieldsDuringRead(existingState GetComplianceSecurityProfileSettingRequest) { +} + // Get the compliance security profile setting for new workspaces type GetCspEnablementAccountSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -614,6 +1010,12 @@ type GetCspEnablementAccountSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *GetCspEnablementAccountSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetCspEnablementAccountSettingRequest) { +} + +func (newState *GetCspEnablementAccountSettingRequest) SyncEffectiveFieldsDuringRead(existingState GetCspEnablementAccountSettingRequest) { +} + // Get the default namespace setting type GetDefaultNamespaceSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -626,6 +1028,12 @@ type GetDefaultNamespaceSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *GetDefaultNamespaceSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetDefaultNamespaceSettingRequest) { +} + +func (newState *GetDefaultNamespaceSettingRequest) SyncEffectiveFieldsDuringRead(existingState GetDefaultNamespaceSettingRequest) { +} + // Retrieve Legacy Access Disablement Status type GetDisableLegacyAccessRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -638,6 +1046,30 @@ type GetDisableLegacyAccessRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *GetDisableLegacyAccessRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetDisableLegacyAccessRequest) { +} + +func (newState *GetDisableLegacyAccessRequest) SyncEffectiveFieldsDuringRead(existingState GetDisableLegacyAccessRequest) { +} + +// Get the disable legacy DBFS setting +type GetDisableLegacyDbfsRequest struct { + // etag used for versioning. The response is at least as fresh as the eTag + // provided. This is used for optimistic concurrency control as a way to + // help prevent simultaneous writes of a setting overwriting each other. It + // is strongly suggested that systems make use of the etag in the read -> + // delete pattern to perform setting deletions in order to avoid race + // conditions. That is, get an etag from a GET request, and pass it with the + // DELETE request to identify the rule set version you are deleting. + Etag types.String `tfsdk:"-"` +} + +func (newState *GetDisableLegacyDbfsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetDisableLegacyDbfsRequest) { +} + +func (newState *GetDisableLegacyDbfsRequest) SyncEffectiveFieldsDuringRead(existingState GetDisableLegacyDbfsRequest) { +} + // Get the disable legacy features setting type GetDisableLegacyFeaturesRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -650,6 +1082,12 @@ type GetDisableLegacyFeaturesRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *GetDisableLegacyFeaturesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetDisableLegacyFeaturesRequest) { +} + +func (newState *GetDisableLegacyFeaturesRequest) SyncEffectiveFieldsDuringRead(existingState GetDisableLegacyFeaturesRequest) { +} + // Get the enhanced security monitoring setting type GetEnhancedSecurityMonitoringSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -662,6 +1100,12 @@ type GetEnhancedSecurityMonitoringSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *GetEnhancedSecurityMonitoringSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetEnhancedSecurityMonitoringSettingRequest) { +} + +func (newState *GetEnhancedSecurityMonitoringSettingRequest) SyncEffectiveFieldsDuringRead(existingState GetEnhancedSecurityMonitoringSettingRequest) { +} + // Get the enhanced security monitoring setting for new workspaces type GetEsmEnablementAccountSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -674,33 +1118,69 @@ type GetEsmEnablementAccountSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *GetEsmEnablementAccountSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetEsmEnablementAccountSettingRequest) { +} + +func (newState *GetEsmEnablementAccountSettingRequest) SyncEffectiveFieldsDuringRead(existingState GetEsmEnablementAccountSettingRequest) { +} + // Get access list type GetIpAccessListRequest struct { // The ID for the corresponding IP access list IpAccessListId types.String `tfsdk:"-"` } +func (newState *GetIpAccessListRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetIpAccessListRequest) { +} + +func (newState *GetIpAccessListRequest) SyncEffectiveFieldsDuringRead(existingState GetIpAccessListRequest) { +} + type GetIpAccessListResponse struct { // Definition of an IP Access list IpAccessList []IpAccessListInfo `tfsdk:"ip_access_list" tf:"optional,object"` } +func (newState *GetIpAccessListResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetIpAccessListResponse) { +} + +func (newState *GetIpAccessListResponse) SyncEffectiveFieldsDuringRead(existingState GetIpAccessListResponse) { +} + // IP access lists were successfully returned. type GetIpAccessListsResponse struct { IpAccessLists []IpAccessListInfo `tfsdk:"ip_access_lists" tf:"optional"` } +func (newState *GetIpAccessListsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetIpAccessListsResponse) { +} + +func (newState *GetIpAccessListsResponse) SyncEffectiveFieldsDuringRead(existingState GetIpAccessListsResponse) { +} + // Get a network connectivity configuration type GetNetworkConnectivityConfigurationRequest struct { // Your Network Connectvity Configuration ID. NetworkConnectivityConfigId types.String `tfsdk:"-"` } +func (newState *GetNetworkConnectivityConfigurationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetNetworkConnectivityConfigurationRequest) { +} + +func (newState *GetNetworkConnectivityConfigurationRequest) SyncEffectiveFieldsDuringRead(existingState GetNetworkConnectivityConfigurationRequest) { +} + // Get a notification destination type GetNotificationDestinationRequest struct { Id types.String `tfsdk:"-"` } +func (newState *GetNotificationDestinationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetNotificationDestinationRequest) { +} + +func (newState *GetNotificationDestinationRequest) SyncEffectiveFieldsDuringRead(existingState GetNotificationDestinationRequest) { +} + // Get Personal Compute setting type GetPersonalComputeSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -713,6 +1193,12 @@ type GetPersonalComputeSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *GetPersonalComputeSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPersonalComputeSettingRequest) { +} + +func (newState *GetPersonalComputeSettingRequest) SyncEffectiveFieldsDuringRead(existingState GetPersonalComputeSettingRequest) { +} + // Get a private endpoint rule type GetPrivateEndpointRuleRequest struct { // Your Network Connectvity Configuration ID. @@ -721,6 +1207,12 @@ type GetPrivateEndpointRuleRequest struct { PrivateEndpointRuleId types.String `tfsdk:"-"` } +func (newState *GetPrivateEndpointRuleRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetPrivateEndpointRuleRequest) { +} + +func (newState *GetPrivateEndpointRuleRequest) SyncEffectiveFieldsDuringRead(existingState GetPrivateEndpointRuleRequest) { +} + // Get the restrict workspace admins setting type GetRestrictWorkspaceAdminsSettingRequest struct { // etag used for versioning. The response is at least as fresh as the eTag @@ -733,27 +1225,57 @@ type GetRestrictWorkspaceAdminsSettingRequest struct { Etag types.String `tfsdk:"-"` } +func (newState *GetRestrictWorkspaceAdminsSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRestrictWorkspaceAdminsSettingRequest) { +} + +func (newState *GetRestrictWorkspaceAdminsSettingRequest) SyncEffectiveFieldsDuringRead(existingState GetRestrictWorkspaceAdminsSettingRequest) { +} + // Check configuration status type GetStatusRequest struct { Keys types.String `tfsdk:"-"` } +func (newState *GetStatusRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetStatusRequest) { +} + +func (newState *GetStatusRequest) SyncEffectiveFieldsDuringRead(existingState GetStatusRequest) { +} + // Get token info type GetTokenManagementRequest struct { // The ID of the token to get. TokenId types.String `tfsdk:"-"` } +func (newState *GetTokenManagementRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetTokenManagementRequest) { +} + +func (newState *GetTokenManagementRequest) SyncEffectiveFieldsDuringRead(existingState GetTokenManagementRequest) { +} + type GetTokenPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []TokenPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetTokenPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetTokenPermissionLevelsResponse) { +} + +func (newState *GetTokenPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetTokenPermissionLevelsResponse) { +} + // Token with specified Token ID was successfully returned. type GetTokenResponse struct { TokenInfo []TokenInfo `tfsdk:"token_info" tf:"optional,object"` } +func (newState *GetTokenResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetTokenResponse) { +} + +func (newState *GetTokenResponse) SyncEffectiveFieldsDuringRead(existingState GetTokenResponse) { +} + // Definition of an IP Access list type IpAccessListInfo struct { // Total number of IP or CIDR values. @@ -783,11 +1305,23 @@ type IpAccessListInfo struct { UpdatedBy types.Int64 `tfsdk:"updated_by" tf:"optional"` } +func (newState *IpAccessListInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan IpAccessListInfo) { +} + +func (newState *IpAccessListInfo) SyncEffectiveFieldsDuringRead(existingState IpAccessListInfo) { +} + // IP access lists were successfully returned. type ListIpAccessListResponse struct { IpAccessLists []IpAccessListInfo `tfsdk:"ip_access_lists" tf:"optional"` } +func (newState *ListIpAccessListResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListIpAccessListResponse) { +} + +func (newState *ListIpAccessListResponse) SyncEffectiveFieldsDuringRead(existingState ListIpAccessListResponse) { +} + type ListNccAzurePrivateEndpointRulesResponse struct { Items []NccAzurePrivateEndpointRule `tfsdk:"items" tf:"optional"` // A token that can be used to get the next page of results. If null, there @@ -795,12 +1329,24 @@ type ListNccAzurePrivateEndpointRulesResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListNccAzurePrivateEndpointRulesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListNccAzurePrivateEndpointRulesResponse) { +} + +func (newState *ListNccAzurePrivateEndpointRulesResponse) SyncEffectiveFieldsDuringRead(existingState ListNccAzurePrivateEndpointRulesResponse) { +} + // List network connectivity configurations type ListNetworkConnectivityConfigurationsRequest struct { // Pagination token to go to next page based on previous query. PageToken types.String `tfsdk:"-"` } +func (newState *ListNetworkConnectivityConfigurationsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListNetworkConnectivityConfigurationsRequest) { +} + +func (newState *ListNetworkConnectivityConfigurationsRequest) SyncEffectiveFieldsDuringRead(existingState ListNetworkConnectivityConfigurationsRequest) { +} + type ListNetworkConnectivityConfigurationsResponse struct { Items []NetworkConnectivityConfiguration `tfsdk:"items" tf:"optional"` // A token that can be used to get the next page of results. If null, there @@ -808,6 +1354,12 @@ type ListNetworkConnectivityConfigurationsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListNetworkConnectivityConfigurationsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListNetworkConnectivityConfigurationsResponse) { +} + +func (newState *ListNetworkConnectivityConfigurationsResponse) SyncEffectiveFieldsDuringRead(existingState ListNetworkConnectivityConfigurationsResponse) { +} + // List notification destinations type ListNotificationDestinationsRequest struct { PageSize types.Int64 `tfsdk:"-"` @@ -815,6 +1367,12 @@ type ListNotificationDestinationsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListNotificationDestinationsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListNotificationDestinationsRequest) { +} + +func (newState *ListNotificationDestinationsRequest) SyncEffectiveFieldsDuringRead(existingState ListNotificationDestinationsRequest) { +} + type ListNotificationDestinationsResponse struct { // Page token for next of results. NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` @@ -822,6 +1380,12 @@ type ListNotificationDestinationsResponse struct { Results []ListNotificationDestinationsResult `tfsdk:"results" tf:"optional"` } +func (newState *ListNotificationDestinationsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListNotificationDestinationsResponse) { +} + +func (newState *ListNotificationDestinationsResponse) SyncEffectiveFieldsDuringRead(existingState ListNotificationDestinationsResponse) { +} + type ListNotificationDestinationsResult struct { // [Output-only] The type of the notification destination. The type can not // be changed once set. @@ -832,6 +1396,12 @@ type ListNotificationDestinationsResult struct { Id types.String `tfsdk:"id" tf:"optional"` } +func (newState *ListNotificationDestinationsResult) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListNotificationDestinationsResult) { +} + +func (newState *ListNotificationDestinationsResult) SyncEffectiveFieldsDuringRead(existingState ListNotificationDestinationsResult) { +} + // List private endpoint rules type ListPrivateEndpointRulesRequest struct { // Your Network Connectvity Configuration ID. @@ -840,11 +1410,23 @@ type ListPrivateEndpointRulesRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListPrivateEndpointRulesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListPrivateEndpointRulesRequest) { +} + +func (newState *ListPrivateEndpointRulesRequest) SyncEffectiveFieldsDuringRead(existingState ListPrivateEndpointRulesRequest) { +} + type ListPublicTokensResponse struct { // The information for each token. TokenInfos []PublicTokenInfo `tfsdk:"token_infos" tf:"optional"` } +func (newState *ListPublicTokensResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListPublicTokensResponse) { +} + +func (newState *ListPublicTokensResponse) SyncEffectiveFieldsDuringRead(existingState ListPublicTokensResponse) { +} + // List all tokens type ListTokenManagementRequest struct { // User ID of the user that created the token. @@ -853,12 +1435,24 @@ type ListTokenManagementRequest struct { CreatedByUsername types.String `tfsdk:"-"` } +func (newState *ListTokenManagementRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListTokenManagementRequest) { +} + +func (newState *ListTokenManagementRequest) SyncEffectiveFieldsDuringRead(existingState ListTokenManagementRequest) { +} + // Tokens were successfully returned. type ListTokensResponse struct { // Token metadata of each user-created token in the workspace TokenInfos []TokenInfo `tfsdk:"token_infos" tf:"optional"` } +func (newState *ListTokensResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListTokensResponse) { +} + +func (newState *ListTokensResponse) SyncEffectiveFieldsDuringRead(existingState ListTokensResponse) { +} + type MicrosoftTeamsConfig struct { // [Input-Only] URL for Microsoft Teams. Url types.String `tfsdk:"url" tf:"optional"` @@ -866,6 +1460,12 @@ type MicrosoftTeamsConfig struct { UrlSet types.Bool `tfsdk:"url_set" tf:"optional"` } +func (newState *MicrosoftTeamsConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan MicrosoftTeamsConfig) { +} + +func (newState *MicrosoftTeamsConfig) SyncEffectiveFieldsDuringRead(existingState MicrosoftTeamsConfig) { +} + // The stable AWS IP CIDR blocks. You can use these to configure the firewall of // your resources to allow traffic from your Databricks workspace. type NccAwsStableIpRule struct { @@ -874,6 +1474,12 @@ type NccAwsStableIpRule struct { CidrBlocks []types.String `tfsdk:"cidr_blocks" tf:"optional"` } +func (newState *NccAwsStableIpRule) SyncEffectiveFieldsDuringCreateOrUpdate(plan NccAwsStableIpRule) { +} + +func (newState *NccAwsStableIpRule) SyncEffectiveFieldsDuringRead(existingState NccAwsStableIpRule) { +} + type NccAzurePrivateEndpointRule struct { // The current status of this private endpoint. The private endpoint rules // are effective only if the connection state is `ESTABLISHED`. Remember @@ -888,15 +1494,20 @@ type NccAzurePrivateEndpointRule struct { // DISCONNECTED: Connection was removed by the private link resource owner, // the private endpoint becomes informative and should be deleted for // clean-up. - ConnectionState types.String `tfsdk:"connection_state" tf:"optional"` + ConnectionState types.String `tfsdk:"connection_state" tf:"optional"` + EffectiveConnectionState types.String `tfsdk:"effective_connection_state" tf:"computed,optional"` // Time in epoch milliseconds when this object was created. - CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + EffectiveCreationTime types.Int64 `tfsdk:"effective_creation_time" tf:"computed,optional"` // Whether this private endpoint is deactivated. - Deactivated types.Bool `tfsdk:"deactivated" tf:"optional"` + Deactivated types.Bool `tfsdk:"deactivated" tf:"optional"` + EffectiveDeactivated types.Bool `tfsdk:"effective_deactivated" tf:"computed,optional"` // Time in epoch milliseconds when this object was deactivated. - DeactivatedAt types.Int64 `tfsdk:"deactivated_at" tf:"optional"` + DeactivatedAt types.Int64 `tfsdk:"deactivated_at" tf:"optional"` + EffectiveDeactivatedAt types.Int64 `tfsdk:"effective_deactivated_at" tf:"computed,optional"` // The name of the Azure private endpoint resource. - EndpointName types.String `tfsdk:"endpoint_name" tf:"optional"` + EndpointName types.String `tfsdk:"endpoint_name" tf:"optional"` + EffectiveEndpointName types.String `tfsdk:"effective_endpoint_name" tf:"computed,optional"` // 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`. @@ -907,9 +1518,52 @@ type NccAzurePrivateEndpointRule struct { // The Azure resource ID of the target resource. ResourceId types.String `tfsdk:"resource_id" tf:"optional"` // The ID of a private endpoint rule. - RuleId types.String `tfsdk:"rule_id" tf:"optional"` + RuleId types.String `tfsdk:"rule_id" tf:"optional"` + EffectiveRuleId types.String `tfsdk:"effective_rule_id" tf:"computed,optional"` // Time in epoch milliseconds when this object was updated. - UpdatedTime types.Int64 `tfsdk:"updated_time" tf:"optional"` + UpdatedTime types.Int64 `tfsdk:"updated_time" tf:"optional"` + EffectiveUpdatedTime types.Int64 `tfsdk:"effective_updated_time" tf:"computed,optional"` +} + +func (newState *NccAzurePrivateEndpointRule) SyncEffectiveFieldsDuringCreateOrUpdate(plan NccAzurePrivateEndpointRule) { + newState.EffectiveConnectionState = newState.ConnectionState + newState.ConnectionState = plan.ConnectionState + newState.EffectiveCreationTime = newState.CreationTime + newState.CreationTime = plan.CreationTime + newState.EffectiveDeactivated = newState.Deactivated + newState.Deactivated = plan.Deactivated + newState.EffectiveDeactivatedAt = newState.DeactivatedAt + newState.DeactivatedAt = plan.DeactivatedAt + newState.EffectiveEndpointName = newState.EndpointName + newState.EndpointName = plan.EndpointName + newState.EffectiveRuleId = newState.RuleId + newState.RuleId = plan.RuleId + newState.EffectiveUpdatedTime = newState.UpdatedTime + newState.UpdatedTime = plan.UpdatedTime +} + +func (newState *NccAzurePrivateEndpointRule) SyncEffectiveFieldsDuringRead(existingState NccAzurePrivateEndpointRule) { + if existingState.EffectiveConnectionState.ValueString() == newState.ConnectionState.ValueString() { + newState.ConnectionState = existingState.ConnectionState + } + if existingState.EffectiveCreationTime.ValueInt64() == newState.CreationTime.ValueInt64() { + newState.CreationTime = existingState.CreationTime + } + if existingState.EffectiveDeactivated.ValueBool() == newState.Deactivated.ValueBool() { + newState.Deactivated = existingState.Deactivated + } + if existingState.EffectiveDeactivatedAt.ValueInt64() == newState.DeactivatedAt.ValueInt64() { + newState.DeactivatedAt = existingState.DeactivatedAt + } + if existingState.EffectiveEndpointName.ValueString() == newState.EndpointName.ValueString() { + newState.EndpointName = existingState.EndpointName + } + if existingState.EffectiveRuleId.ValueString() == newState.RuleId.ValueString() { + newState.RuleId = existingState.RuleId + } + if existingState.EffectiveUpdatedTime.ValueInt64() == newState.UpdatedTime.ValueInt64() { + newState.UpdatedTime = existingState.UpdatedTime + } } // The stable Azure service endpoints. You can configure the firewall of your @@ -925,18 +1579,31 @@ type NccAzureServiceEndpointRule struct { TargetServices []types.String `tfsdk:"target_services" tf:"optional"` } +func (newState *NccAzureServiceEndpointRule) SyncEffectiveFieldsDuringCreateOrUpdate(plan NccAzureServiceEndpointRule) { +} + +func (newState *NccAzureServiceEndpointRule) SyncEffectiveFieldsDuringRead(existingState NccAzureServiceEndpointRule) { +} + // The network connectivity rules that apply to network traffic from your // serverless compute resources. type NccEgressConfig 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 []NccEgressDefaultRules `tfsdk:"default_rules" tf:"optional,object"` + DefaultRules []NccEgressDefaultRules `tfsdk:"default_rules" tf:"optional,object"` + EffectiveDefaultRules []NccEgressDefaultRules `tfsdk:"effective_default_rules" tf:"computed,optional"` // The network connectivity rules that configured for each destinations. // These rules override default rules. TargetRules []NccEgressTargetRules `tfsdk:"target_rules" tf:"optional,object"` } +func (newState *NccEgressConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan NccEgressConfig) { +} + +func (newState *NccEgressConfig) SyncEffectiveFieldsDuringRead(existingState NccEgressConfig) { +} + // 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. @@ -951,17 +1618,30 @@ type NccEgressDefaultRules struct { AzureServiceEndpointRule []NccAzureServiceEndpointRule `tfsdk:"azure_service_endpoint_rule" tf:"optional,object"` } +func (newState *NccEgressDefaultRules) SyncEffectiveFieldsDuringCreateOrUpdate(plan NccEgressDefaultRules) { +} + +func (newState *NccEgressDefaultRules) SyncEffectiveFieldsDuringRead(existingState NccEgressDefaultRules) { +} + // The network connectivity rules that configured for each destinations. These // rules override default rules. type NccEgressTargetRules struct { AzurePrivateEndpointRules []NccAzurePrivateEndpointRule `tfsdk:"azure_private_endpoint_rules" tf:"optional"` } +func (newState *NccEgressTargetRules) SyncEffectiveFieldsDuringCreateOrUpdate(plan NccEgressTargetRules) { +} + +func (newState *NccEgressTargetRules) SyncEffectiveFieldsDuringRead(existingState NccEgressTargetRules) { +} + type NetworkConnectivityConfiguration struct { // The Databricks account ID that hosts the credential. AccountId types.String `tfsdk:"account_id" tf:"optional"` // Time in epoch milliseconds when this object was created. - CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + CreationTime types.Int64 `tfsdk:"creation_time" tf:"optional"` + EffectiveCreationTime types.Int64 `tfsdk:"effective_creation_time" tf:"computed,optional"` // The network connectivity rules that apply to network traffic from your // serverless compute resources. EgressConfig []NccEgressConfig `tfsdk:"egress_config" tf:"optional,object"` @@ -971,13 +1651,36 @@ type NetworkConnectivityConfiguration struct { // `^[0-9a-zA-Z-_]{3,30}$`. Name types.String `tfsdk:"name" tf:"optional"` // Databricks network connectivity configuration ID. - NetworkConnectivityConfigId types.String `tfsdk:"network_connectivity_config_id" tf:"optional"` + NetworkConnectivityConfigId types.String `tfsdk:"network_connectivity_config_id" tf:"optional"` + EffectiveNetworkConnectivityConfigId types.String `tfsdk:"effective_network_connectivity_config_id" tf:"computed,optional"` // The region for the network connectivity configuration. Only workspaces in // the same region can be attached to the network connectivity // configuration. Region types.String `tfsdk:"region" tf:"optional"` // Time in epoch milliseconds when this object was updated. - UpdatedTime types.Int64 `tfsdk:"updated_time" tf:"optional"` + UpdatedTime types.Int64 `tfsdk:"updated_time" tf:"optional"` + EffectiveUpdatedTime types.Int64 `tfsdk:"effective_updated_time" tf:"computed,optional"` +} + +func (newState *NetworkConnectivityConfiguration) SyncEffectiveFieldsDuringCreateOrUpdate(plan NetworkConnectivityConfiguration) { + newState.EffectiveCreationTime = newState.CreationTime + newState.CreationTime = plan.CreationTime + newState.EffectiveNetworkConnectivityConfigId = newState.NetworkConnectivityConfigId + newState.NetworkConnectivityConfigId = plan.NetworkConnectivityConfigId + newState.EffectiveUpdatedTime = newState.UpdatedTime + newState.UpdatedTime = plan.UpdatedTime +} + +func (newState *NetworkConnectivityConfiguration) SyncEffectiveFieldsDuringRead(existingState NetworkConnectivityConfiguration) { + if existingState.EffectiveCreationTime.ValueInt64() == newState.CreationTime.ValueInt64() { + newState.CreationTime = existingState.CreationTime + } + if existingState.EffectiveNetworkConnectivityConfigId.ValueString() == newState.NetworkConnectivityConfigId.ValueString() { + newState.NetworkConnectivityConfigId = existingState.NetworkConnectivityConfigId + } + if existingState.EffectiveUpdatedTime.ValueInt64() == newState.UpdatedTime.ValueInt64() { + newState.UpdatedTime = existingState.UpdatedTime + } } type NotificationDestination struct { @@ -994,6 +1697,12 @@ type NotificationDestination struct { Id types.String `tfsdk:"id" tf:"optional"` } +func (newState *NotificationDestination) SyncEffectiveFieldsDuringCreateOrUpdate(plan NotificationDestination) { +} + +func (newState *NotificationDestination) SyncEffectiveFieldsDuringRead(existingState NotificationDestination) { +} + type PagerdutyConfig struct { // [Input-Only] Integration key for PagerDuty. IntegrationKey types.String `tfsdk:"integration_key" tf:"optional"` @@ -1001,12 +1710,24 @@ type PagerdutyConfig struct { IntegrationKeySet types.Bool `tfsdk:"integration_key_set" tf:"optional"` } +func (newState *PagerdutyConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan PagerdutyConfig) { +} + +func (newState *PagerdutyConfig) SyncEffectiveFieldsDuringRead(existingState PagerdutyConfig) { +} + // Partition by workspace or account type PartitionId struct { // The ID of the workspace. WorkspaceId types.Int64 `tfsdk:"workspaceId" tf:"optional"` } +func (newState *PartitionId) SyncEffectiveFieldsDuringCreateOrUpdate(plan PartitionId) { +} + +func (newState *PartitionId) SyncEffectiveFieldsDuringRead(existingState PartitionId) { +} + type PersonalComputeMessage struct { // ON: Grants all users in all workspaces access to the Personal Compute // default policy, allowing all users to create single-machine compute @@ -1018,6 +1739,12 @@ type PersonalComputeMessage struct { Value types.String `tfsdk:"value" tf:""` } +func (newState *PersonalComputeMessage) SyncEffectiveFieldsDuringCreateOrUpdate(plan PersonalComputeMessage) { +} + +func (newState *PersonalComputeMessage) SyncEffectiveFieldsDuringRead(existingState PersonalComputeMessage) { +} + type PersonalComputeSetting struct { // etag used for versioning. The response is at least as fresh as the eTag // provided. This is used for optimistic concurrency control as a way to @@ -1037,6 +1764,12 @@ type PersonalComputeSetting struct { SettingName types.String `tfsdk:"setting_name" tf:"optional"` } +func (newState *PersonalComputeSetting) SyncEffectiveFieldsDuringCreateOrUpdate(plan PersonalComputeSetting) { +} + +func (newState *PersonalComputeSetting) SyncEffectiveFieldsDuringRead(existingState PersonalComputeSetting) { +} + type PublicTokenInfo struct { // Comment the token was created with, if applicable. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -1049,6 +1782,12 @@ type PublicTokenInfo struct { TokenId types.String `tfsdk:"token_id" tf:"optional"` } +func (newState *PublicTokenInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan PublicTokenInfo) { +} + +func (newState *PublicTokenInfo) SyncEffectiveFieldsDuringRead(existingState PublicTokenInfo) { +} + // Details required to replace an IP access list. type ReplaceIpAccessList struct { // Specifies whether this IP access list is enabled. @@ -1068,13 +1807,31 @@ type ReplaceIpAccessList struct { ListType types.String `tfsdk:"list_type" tf:""` } +func (newState *ReplaceIpAccessList) SyncEffectiveFieldsDuringCreateOrUpdate(plan ReplaceIpAccessList) { +} + +func (newState *ReplaceIpAccessList) SyncEffectiveFieldsDuringRead(existingState ReplaceIpAccessList) { +} + type ReplaceResponse struct { } +func (newState *ReplaceResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ReplaceResponse) { +} + +func (newState *ReplaceResponse) SyncEffectiveFieldsDuringRead(existingState ReplaceResponse) { +} + type RestrictWorkspaceAdminsMessage struct { Status types.String `tfsdk:"status" tf:""` } +func (newState *RestrictWorkspaceAdminsMessage) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestrictWorkspaceAdminsMessage) { +} + +func (newState *RestrictWorkspaceAdminsMessage) SyncEffectiveFieldsDuringRead(existingState RestrictWorkspaceAdminsMessage) { +} + type RestrictWorkspaceAdminsSetting struct { // etag used for versioning. The response is at least as fresh as the eTag // provided. This is used for optimistic concurrency control as a way to @@ -1094,17 +1851,41 @@ type RestrictWorkspaceAdminsSetting struct { SettingName types.String `tfsdk:"setting_name" tf:"optional"` } +func (newState *RestrictWorkspaceAdminsSetting) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestrictWorkspaceAdminsSetting) { +} + +func (newState *RestrictWorkspaceAdminsSetting) SyncEffectiveFieldsDuringRead(existingState RestrictWorkspaceAdminsSetting) { +} + type RevokeTokenRequest struct { // The ID of the token to be revoked. TokenId types.String `tfsdk:"token_id" tf:""` } +func (newState *RevokeTokenRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RevokeTokenRequest) { +} + +func (newState *RevokeTokenRequest) SyncEffectiveFieldsDuringRead(existingState RevokeTokenRequest) { +} + type RevokeTokenResponse struct { } +func (newState *RevokeTokenResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RevokeTokenResponse) { +} + +func (newState *RevokeTokenResponse) SyncEffectiveFieldsDuringRead(existingState RevokeTokenResponse) { +} + type SetStatusResponse struct { } +func (newState *SetStatusResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetStatusResponse) { +} + +func (newState *SetStatusResponse) SyncEffectiveFieldsDuringRead(existingState SetStatusResponse) { +} + type SlackConfig struct { // [Input-Only] URL for Slack destination. Url types.String `tfsdk:"url" tf:"optional"` @@ -1112,11 +1893,23 @@ type SlackConfig struct { UrlSet types.Bool `tfsdk:"url_set" tf:"optional"` } +func (newState *SlackConfig) SyncEffectiveFieldsDuringCreateOrUpdate(plan SlackConfig) { +} + +func (newState *SlackConfig) SyncEffectiveFieldsDuringRead(existingState SlackConfig) { +} + type StringMessage struct { // Represents a generic string value. Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *StringMessage) SyncEffectiveFieldsDuringCreateOrUpdate(plan StringMessage) { +} + +func (newState *StringMessage) SyncEffectiveFieldsDuringRead(existingState StringMessage) { +} + type TokenAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -1128,6 +1921,12 @@ type TokenAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *TokenAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan TokenAccessControlRequest) { +} + +func (newState *TokenAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState TokenAccessControlRequest) { +} + type TokenAccessControlResponse struct { // All permissions. AllPermissions []TokenPermission `tfsdk:"all_permissions" tf:"optional"` @@ -1141,6 +1940,12 @@ type TokenAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *TokenAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan TokenAccessControlResponse) { +} + +func (newState *TokenAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState TokenAccessControlResponse) { +} + type TokenInfo struct { // Comment that describes the purpose of the token, specified by the token // creator. @@ -1161,6 +1966,12 @@ type TokenInfo struct { WorkspaceId types.Int64 `tfsdk:"workspace_id" tf:"optional"` } +func (newState *TokenInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan TokenInfo) { +} + +func (newState *TokenInfo) SyncEffectiveFieldsDuringRead(existingState TokenInfo) { +} + type TokenPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -1169,6 +1980,12 @@ type TokenPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *TokenPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan TokenPermission) { +} + +func (newState *TokenPermission) SyncEffectiveFieldsDuringRead(existingState TokenPermission) { +} + type TokenPermissions struct { AccessControlList []TokenAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -1177,16 +1994,34 @@ type TokenPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *TokenPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan TokenPermissions) { +} + +func (newState *TokenPermissions) SyncEffectiveFieldsDuringRead(existingState TokenPermissions) { +} + type TokenPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *TokenPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan TokenPermissionsDescription) { +} + +func (newState *TokenPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState TokenPermissionsDescription) { +} + type TokenPermissionsRequest struct { AccessControlList []TokenAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` } +func (newState *TokenPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan TokenPermissionsRequest) { +} + +func (newState *TokenPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState TokenPermissionsRequest) { +} + // Details required to update a setting. type UpdateAutomaticClusterUpdateSettingRequest struct { // This should always be set to true for Settings API. Added for AIP @@ -1201,6 +2036,12 @@ type UpdateAutomaticClusterUpdateSettingRequest struct { Setting []AutomaticClusterUpdateSetting `tfsdk:"setting" tf:"object"` } +func (newState *UpdateAutomaticClusterUpdateSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateAutomaticClusterUpdateSettingRequest) { +} + +func (newState *UpdateAutomaticClusterUpdateSettingRequest) SyncEffectiveFieldsDuringRead(existingState UpdateAutomaticClusterUpdateSettingRequest) { +} + // Details required to update a setting. type UpdateComplianceSecurityProfileSettingRequest struct { // This should always be set to true for Settings API. Added for AIP @@ -1215,6 +2056,12 @@ type UpdateComplianceSecurityProfileSettingRequest struct { Setting []ComplianceSecurityProfileSetting `tfsdk:"setting" tf:"object"` } +func (newState *UpdateComplianceSecurityProfileSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateComplianceSecurityProfileSettingRequest) { +} + +func (newState *UpdateComplianceSecurityProfileSettingRequest) SyncEffectiveFieldsDuringRead(existingState UpdateComplianceSecurityProfileSettingRequest) { +} + // Details required to update a setting. type UpdateCspEnablementAccountSettingRequest struct { // This should always be set to true for Settings API. Added for AIP @@ -1229,6 +2076,12 @@ type UpdateCspEnablementAccountSettingRequest struct { Setting []CspEnablementAccountSetting `tfsdk:"setting" tf:"object"` } +func (newState *UpdateCspEnablementAccountSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateCspEnablementAccountSettingRequest) { +} + +func (newState *UpdateCspEnablementAccountSettingRequest) SyncEffectiveFieldsDuringRead(existingState UpdateCspEnablementAccountSettingRequest) { +} + // Details required to update a setting. type UpdateDefaultNamespaceSettingRequest struct { // This should always be set to true for Settings API. Added for AIP @@ -1251,6 +2104,12 @@ type UpdateDefaultNamespaceSettingRequest struct { Setting []DefaultNamespaceSetting `tfsdk:"setting" tf:"object"` } +func (newState *UpdateDefaultNamespaceSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateDefaultNamespaceSettingRequest) { +} + +func (newState *UpdateDefaultNamespaceSettingRequest) SyncEffectiveFieldsDuringRead(existingState UpdateDefaultNamespaceSettingRequest) { +} + // Details required to update a setting. type UpdateDisableLegacyAccessRequest struct { // This should always be set to true for Settings API. Added for AIP @@ -1265,6 +2124,32 @@ type UpdateDisableLegacyAccessRequest struct { Setting []DisableLegacyAccess `tfsdk:"setting" tf:"object"` } +func (newState *UpdateDisableLegacyAccessRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateDisableLegacyAccessRequest) { +} + +func (newState *UpdateDisableLegacyAccessRequest) SyncEffectiveFieldsDuringRead(existingState UpdateDisableLegacyAccessRequest) { +} + +// Details required to update a setting. +type UpdateDisableLegacyDbfsRequest struct { + // This should always be set to true for Settings API. Added for AIP + // compliance. + AllowMissing types.Bool `tfsdk:"allow_missing" tf:""` + // Field mask is required to be passed into the PATCH request. Field mask + // specifies which fields of the setting payload will be updated. The field + // mask needs to be supplied as single string. To specify multiple fields in + // the field mask, use comma as the separator (no space). + FieldMask types.String `tfsdk:"field_mask" tf:""` + + Setting []DisableLegacyDbfs `tfsdk:"setting" tf:"object"` +} + +func (newState *UpdateDisableLegacyDbfsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateDisableLegacyDbfsRequest) { +} + +func (newState *UpdateDisableLegacyDbfsRequest) SyncEffectiveFieldsDuringRead(existingState UpdateDisableLegacyDbfsRequest) { +} + // Details required to update a setting. type UpdateDisableLegacyFeaturesRequest struct { // This should always be set to true for Settings API. Added for AIP @@ -1279,6 +2164,12 @@ type UpdateDisableLegacyFeaturesRequest struct { Setting []DisableLegacyFeatures `tfsdk:"setting" tf:"object"` } +func (newState *UpdateDisableLegacyFeaturesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateDisableLegacyFeaturesRequest) { +} + +func (newState *UpdateDisableLegacyFeaturesRequest) SyncEffectiveFieldsDuringRead(existingState UpdateDisableLegacyFeaturesRequest) { +} + // Details required to update a setting. type UpdateEnhancedSecurityMonitoringSettingRequest struct { // This should always be set to true for Settings API. Added for AIP @@ -1293,6 +2184,12 @@ type UpdateEnhancedSecurityMonitoringSettingRequest struct { Setting []EnhancedSecurityMonitoringSetting `tfsdk:"setting" tf:"object"` } +func (newState *UpdateEnhancedSecurityMonitoringSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateEnhancedSecurityMonitoringSettingRequest) { +} + +func (newState *UpdateEnhancedSecurityMonitoringSettingRequest) SyncEffectiveFieldsDuringRead(existingState UpdateEnhancedSecurityMonitoringSettingRequest) { +} + // Details required to update a setting. type UpdateEsmEnablementAccountSettingRequest struct { // This should always be set to true for Settings API. Added for AIP @@ -1307,6 +2204,12 @@ type UpdateEsmEnablementAccountSettingRequest struct { Setting []EsmEnablementAccountSetting `tfsdk:"setting" tf:"object"` } +func (newState *UpdateEsmEnablementAccountSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateEsmEnablementAccountSettingRequest) { +} + +func (newState *UpdateEsmEnablementAccountSettingRequest) SyncEffectiveFieldsDuringRead(existingState UpdateEsmEnablementAccountSettingRequest) { +} + // Details required to update an IP access list. type UpdateIpAccessList struct { // Specifies whether this IP access list is enabled. @@ -1326,6 +2229,12 @@ type UpdateIpAccessList struct { ListType types.String `tfsdk:"list_type" tf:"optional"` } +func (newState *UpdateIpAccessList) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateIpAccessList) { +} + +func (newState *UpdateIpAccessList) SyncEffectiveFieldsDuringRead(existingState UpdateIpAccessList) { +} + type UpdateNotificationDestinationRequest struct { // The configuration for the notification destination. Must wrap EXACTLY one // of the nested configs. @@ -1336,6 +2245,12 @@ type UpdateNotificationDestinationRequest struct { Id types.String `tfsdk:"-"` } +func (newState *UpdateNotificationDestinationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateNotificationDestinationRequest) { +} + +func (newState *UpdateNotificationDestinationRequest) SyncEffectiveFieldsDuringRead(existingState UpdateNotificationDestinationRequest) { +} + // Details required to update a setting. type UpdatePersonalComputeSettingRequest struct { // This should always be set to true for Settings API. Added for AIP @@ -1350,9 +2265,21 @@ type UpdatePersonalComputeSettingRequest struct { Setting []PersonalComputeSetting `tfsdk:"setting" tf:"object"` } +func (newState *UpdatePersonalComputeSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdatePersonalComputeSettingRequest) { +} + +func (newState *UpdatePersonalComputeSettingRequest) SyncEffectiveFieldsDuringRead(existingState UpdatePersonalComputeSettingRequest) { +} + type UpdateResponse struct { } +func (newState *UpdateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateResponse) { +} + +func (newState *UpdateResponse) SyncEffectiveFieldsDuringRead(existingState UpdateResponse) { +} + // Details required to update a setting. type UpdateRestrictWorkspaceAdminsSettingRequest struct { // This should always be set to true for Settings API. Added for AIP @@ -1366,3 +2293,9 @@ type UpdateRestrictWorkspaceAdminsSettingRequest struct { Setting []RestrictWorkspaceAdminsSetting `tfsdk:"setting" tf:"object"` } + +func (newState *UpdateRestrictWorkspaceAdminsSettingRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateRestrictWorkspaceAdminsSettingRequest) { +} + +func (newState *UpdateRestrictWorkspaceAdminsSettingRequest) SyncEffectiveFieldsDuringRead(existingState UpdateRestrictWorkspaceAdminsSettingRequest) { +} diff --git a/internal/service/sharing_tf/model.go b/internal/service/sharing_tf/model.go index d83c38ff9b..1cb5022027 100755 --- a/internal/service/sharing_tf/model.go +++ b/internal/service/sharing_tf/model.go @@ -29,6 +29,12 @@ type CentralCleanRoomInfo struct { StationRegion types.String `tfsdk:"station_region" tf:"optional"` } +func (newState *CentralCleanRoomInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CentralCleanRoomInfo) { +} + +func (newState *CentralCleanRoomInfo) SyncEffectiveFieldsDuringRead(existingState CentralCleanRoomInfo) { +} + type CleanRoomAssetInfo struct { // Time at which this asset was added, in epoch milliseconds. AddedAt types.Int64 `tfsdk:"added_at" tf:"optional"` @@ -42,6 +48,12 @@ type CleanRoomAssetInfo struct { UpdatedAt types.Int64 `tfsdk:"updated_at" tf:"optional"` } +func (newState *CleanRoomAssetInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CleanRoomAssetInfo) { +} + +func (newState *CleanRoomAssetInfo) SyncEffectiveFieldsDuringRead(existingState CleanRoomAssetInfo) { +} + type CleanRoomCatalog struct { // Name of the catalog in the clean room station. Empty for notebooks. CatalogName types.String `tfsdk:"catalog_name" tf:"optional"` @@ -51,6 +63,12 @@ type CleanRoomCatalog struct { Tables []SharedDataObject `tfsdk:"tables" tf:"optional"` } +func (newState *CleanRoomCatalog) SyncEffectiveFieldsDuringCreateOrUpdate(plan CleanRoomCatalog) { +} + +func (newState *CleanRoomCatalog) SyncEffectiveFieldsDuringRead(existingState CleanRoomCatalog) { +} + type CleanRoomCatalogUpdate struct { // The name of the catalog to update assets. CatalogName types.String `tfsdk:"catalog_name" tf:"optional"` @@ -58,6 +76,12 @@ type CleanRoomCatalogUpdate struct { Updates []SharedDataObjectUpdate `tfsdk:"updates" tf:"optional,object"` } +func (newState *CleanRoomCatalogUpdate) SyncEffectiveFieldsDuringCreateOrUpdate(plan CleanRoomCatalogUpdate) { +} + +func (newState *CleanRoomCatalogUpdate) SyncEffectiveFieldsDuringRead(existingState CleanRoomCatalogUpdate) { +} + type CleanRoomCollaboratorInfo struct { // The global Unity Catalog metastore id of the collaborator. Also known as // the sharing identifier. The identifier is of format @@ -69,6 +93,12 @@ type CleanRoomCollaboratorInfo struct { OrganizationName types.String `tfsdk:"organization_name" tf:"optional"` } +func (newState *CleanRoomCollaboratorInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CleanRoomCollaboratorInfo) { +} + +func (newState *CleanRoomCollaboratorInfo) SyncEffectiveFieldsDuringRead(existingState CleanRoomCollaboratorInfo) { +} + type CleanRoomInfo struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -90,6 +120,12 @@ type CleanRoomInfo struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *CleanRoomInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CleanRoomInfo) { +} + +func (newState *CleanRoomInfo) SyncEffectiveFieldsDuringRead(existingState CleanRoomInfo) { +} + type CleanRoomNotebookInfo struct { // The base64 representation of the notebook content in HTML. NotebookContent types.String `tfsdk:"notebook_content" tf:"optional"` @@ -97,6 +133,12 @@ type CleanRoomNotebookInfo struct { NotebookName types.String `tfsdk:"notebook_name" tf:"optional"` } +func (newState *CleanRoomNotebookInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CleanRoomNotebookInfo) { +} + +func (newState *CleanRoomNotebookInfo) SyncEffectiveFieldsDuringRead(existingState CleanRoomNotebookInfo) { +} + type CleanRoomTableInfo struct { // Name of parent catalog. CatalogName types.String `tfsdk:"catalog_name" tf:"optional"` @@ -111,6 +153,12 @@ type CleanRoomTableInfo struct { SchemaName types.String `tfsdk:"schema_name" tf:"optional"` } +func (newState *CleanRoomTableInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CleanRoomTableInfo) { +} + +func (newState *CleanRoomTableInfo) SyncEffectiveFieldsDuringRead(existingState CleanRoomTableInfo) { +} + type ColumnInfo struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -138,6 +186,12 @@ type ColumnInfo struct { TypeText types.String `tfsdk:"type_text" tf:"optional"` } +func (newState *ColumnInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ColumnInfo) { +} + +func (newState *ColumnInfo) SyncEffectiveFieldsDuringRead(existingState ColumnInfo) { +} + type ColumnMask struct { // The full name of the column mask SQL UDF. FunctionName types.String `tfsdk:"function_name" tf:"optional"` @@ -148,6 +202,12 @@ type ColumnMask struct { UsingColumnNames []types.String `tfsdk:"using_column_names" tf:"optional"` } +func (newState *ColumnMask) SyncEffectiveFieldsDuringCreateOrUpdate(plan ColumnMask) { +} + +func (newState *ColumnMask) SyncEffectiveFieldsDuringRead(existingState ColumnMask) { +} + type CreateCleanRoom struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -157,6 +217,12 @@ type CreateCleanRoom struct { RemoteDetailedInfo []CentralCleanRoomInfo `tfsdk:"remote_detailed_info" tf:"object"` } +func (newState *CreateCleanRoom) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCleanRoom) { +} + +func (newState *CreateCleanRoom) SyncEffectiveFieldsDuringRead(existingState CreateCleanRoom) { +} + type CreateProvider struct { // The delta sharing authentication type. AuthenticationType types.String `tfsdk:"authentication_type" tf:""` @@ -169,6 +235,12 @@ type CreateProvider struct { RecipientProfileStr types.String `tfsdk:"recipient_profile_str" tf:"optional"` } +func (newState *CreateProvider) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateProvider) { +} + +func (newState *CreateProvider) SyncEffectiveFieldsDuringRead(existingState CreateProvider) { +} + type CreateRecipient struct { // The delta sharing authentication type. AuthenticationType types.String `tfsdk:"authentication_type" tf:""` @@ -194,6 +266,12 @@ type CreateRecipient struct { SharingCode types.String `tfsdk:"sharing_code" tf:"optional"` } +func (newState *CreateRecipient) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateRecipient) { +} + +func (newState *CreateRecipient) SyncEffectiveFieldsDuringRead(existingState CreateRecipient) { +} + type CreateShare struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -203,42 +281,90 @@ type CreateShare struct { StorageRoot types.String `tfsdk:"storage_root" tf:"optional"` } +func (newState *CreateShare) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateShare) { +} + +func (newState *CreateShare) SyncEffectiveFieldsDuringRead(existingState CreateShare) { +} + // Delete a clean room type DeleteCleanRoomRequest struct { // The name of the clean room. Name types.String `tfsdk:"-"` } +func (newState *DeleteCleanRoomRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteCleanRoomRequest) { +} + +func (newState *DeleteCleanRoomRequest) SyncEffectiveFieldsDuringRead(existingState DeleteCleanRoomRequest) { +} + // Delete a provider type DeleteProviderRequest struct { // Name of the provider. Name types.String `tfsdk:"-"` } +func (newState *DeleteProviderRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteProviderRequest) { +} + +func (newState *DeleteProviderRequest) SyncEffectiveFieldsDuringRead(existingState DeleteProviderRequest) { +} + // Delete a share recipient type DeleteRecipientRequest struct { // Name of the recipient. Name types.String `tfsdk:"-"` } +func (newState *DeleteRecipientRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRecipientRequest) { +} + +func (newState *DeleteRecipientRequest) SyncEffectiveFieldsDuringRead(existingState DeleteRecipientRequest) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + // Delete a share type DeleteShareRequest struct { // The name of the share. Name types.String `tfsdk:"-"` } +func (newState *DeleteShareRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteShareRequest) { +} + +func (newState *DeleteShareRequest) SyncEffectiveFieldsDuringRead(existingState DeleteShareRequest) { +} + // Get a share activation URL type GetActivationUrlInfoRequest struct { // The one time activation url. It also accepts activation token. ActivationUrl types.String `tfsdk:"-"` } +func (newState *GetActivationUrlInfoRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetActivationUrlInfoRequest) { +} + +func (newState *GetActivationUrlInfoRequest) SyncEffectiveFieldsDuringRead(existingState GetActivationUrlInfoRequest) { +} + type GetActivationUrlInfoResponse struct { } +func (newState *GetActivationUrlInfoResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetActivationUrlInfoResponse) { +} + +func (newState *GetActivationUrlInfoResponse) SyncEffectiveFieldsDuringRead(existingState GetActivationUrlInfoResponse) { +} + // Get a clean room type GetCleanRoomRequest struct { // Whether to include remote details (central) on the clean room. @@ -247,18 +373,36 @@ type GetCleanRoomRequest struct { Name types.String `tfsdk:"-"` } +func (newState *GetCleanRoomRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetCleanRoomRequest) { +} + +func (newState *GetCleanRoomRequest) SyncEffectiveFieldsDuringRead(existingState GetCleanRoomRequest) { +} + // Get a provider type GetProviderRequest struct { // Name of the provider. Name types.String `tfsdk:"-"` } +func (newState *GetProviderRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetProviderRequest) { +} + +func (newState *GetProviderRequest) SyncEffectiveFieldsDuringRead(existingState GetProviderRequest) { +} + // Get a share recipient type GetRecipientRequest struct { // Name of the recipient. Name types.String `tfsdk:"-"` } +func (newState *GetRecipientRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRecipientRequest) { +} + +func (newState *GetRecipientRequest) SyncEffectiveFieldsDuringRead(existingState GetRecipientRequest) { +} + type GetRecipientSharePermissionsResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -268,6 +412,12 @@ type GetRecipientSharePermissionsResponse struct { PermissionsOut []ShareToPrivilegeAssignment `tfsdk:"permissions_out" tf:"optional"` } +func (newState *GetRecipientSharePermissionsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRecipientSharePermissionsResponse) { +} + +func (newState *GetRecipientSharePermissionsResponse) SyncEffectiveFieldsDuringRead(existingState GetRecipientSharePermissionsResponse) { +} + // Get a share type GetShareRequest struct { // Query for data to include in the share. @@ -276,11 +426,23 @@ type GetShareRequest struct { Name types.String `tfsdk:"-"` } +func (newState *GetShareRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetShareRequest) { +} + +func (newState *GetShareRequest) SyncEffectiveFieldsDuringRead(existingState GetShareRequest) { +} + type IpAccessList struct { // Allowed IP Addresses in CIDR notation. Limit of 100. AllowedIpAddresses []types.String `tfsdk:"allowed_ip_addresses" tf:"optional"` } +func (newState *IpAccessList) SyncEffectiveFieldsDuringCreateOrUpdate(plan IpAccessList) { +} + +func (newState *IpAccessList) SyncEffectiveFieldsDuringRead(existingState IpAccessList) { +} + // List clean rooms type ListCleanRoomsRequest struct { // Maximum number of clean rooms to return. If not set, all the clean rooms @@ -294,6 +456,12 @@ type ListCleanRoomsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListCleanRoomsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListCleanRoomsRequest) { +} + +func (newState *ListCleanRoomsRequest) SyncEffectiveFieldsDuringRead(existingState ListCleanRoomsRequest) { +} + type ListCleanRoomsResponse struct { // An array of clean rooms. Remote details (central) are not included. CleanRooms []CleanRoomInfo `tfsdk:"clean_rooms" tf:"optional"` @@ -303,6 +471,12 @@ type ListCleanRoomsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListCleanRoomsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListCleanRoomsResponse) { +} + +func (newState *ListCleanRoomsResponse) SyncEffectiveFieldsDuringRead(existingState ListCleanRoomsResponse) { +} + type ListProviderSharesResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -312,6 +486,12 @@ type ListProviderSharesResponse struct { Shares []ProviderShare `tfsdk:"shares" tf:"optional"` } +func (newState *ListProviderSharesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListProviderSharesResponse) { +} + +func (newState *ListProviderSharesResponse) SyncEffectiveFieldsDuringRead(existingState ListProviderSharesResponse) { +} + // List providers type ListProvidersRequest struct { // If not provided, all providers will be returned. If no providers exist @@ -331,6 +511,12 @@ type ListProvidersRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListProvidersRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListProvidersRequest) { +} + +func (newState *ListProvidersRequest) SyncEffectiveFieldsDuringRead(existingState ListProvidersRequest) { +} + type ListProvidersResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -340,6 +526,12 @@ type ListProvidersResponse struct { Providers []ProviderInfo `tfsdk:"providers" tf:"optional"` } +func (newState *ListProvidersResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListProvidersResponse) { +} + +func (newState *ListProvidersResponse) SyncEffectiveFieldsDuringRead(existingState ListProvidersResponse) { +} + // List share recipients type ListRecipientsRequest struct { // If not provided, all recipients will be returned. If no recipients exist @@ -359,6 +551,12 @@ type ListRecipientsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListRecipientsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListRecipientsRequest) { +} + +func (newState *ListRecipientsRequest) SyncEffectiveFieldsDuringRead(existingState ListRecipientsRequest) { +} + type ListRecipientsResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -368,6 +566,12 @@ type ListRecipientsResponse struct { Recipients []RecipientInfo `tfsdk:"recipients" tf:"optional"` } +func (newState *ListRecipientsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListRecipientsResponse) { +} + +func (newState *ListRecipientsResponse) SyncEffectiveFieldsDuringRead(existingState ListRecipientsResponse) { +} + // List shares by Provider type ListSharesRequest struct { // Maximum number of shares to return. - when set to 0, the page length is @@ -386,6 +590,12 @@ type ListSharesRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListSharesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSharesRequest) { +} + +func (newState *ListSharesRequest) SyncEffectiveFieldsDuringRead(existingState ListSharesRequest) { +} + type ListSharesResponse struct { // Opaque token to retrieve the next page of results. Absent if there are no // more pages. __page_token__ should be set to this value for the next @@ -395,9 +605,21 @@ type ListSharesResponse struct { Shares []ShareInfo `tfsdk:"shares" tf:"optional"` } +func (newState *ListSharesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSharesResponse) { +} + +func (newState *ListSharesResponse) SyncEffectiveFieldsDuringRead(existingState ListSharesResponse) { +} + type Partition struct { // An array of partition values. - Values []PartitionValue `tfsdk:"values" tf:"optional"` + Values []PartitionValue `tfsdk:"value" tf:"optional"` +} + +func (newState *Partition) SyncEffectiveFieldsDuringCreateOrUpdate(plan Partition) { +} + +func (newState *Partition) SyncEffectiveFieldsDuringRead(existingState Partition) { } type PartitionValue struct { @@ -415,6 +637,12 @@ type PartitionValue struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *PartitionValue) SyncEffectiveFieldsDuringCreateOrUpdate(plan PartitionValue) { +} + +func (newState *PartitionValue) SyncEffectiveFieldsDuringRead(existingState PartitionValue) { +} + type PrivilegeAssignment struct { // The principal (user email address or group name). Principal types.String `tfsdk:"principal" tf:"optional"` @@ -422,6 +650,12 @@ type PrivilegeAssignment struct { Privileges []types.String `tfsdk:"privileges" tf:"optional"` } +func (newState *PrivilegeAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan PrivilegeAssignment) { +} + +func (newState *PrivilegeAssignment) SyncEffectiveFieldsDuringRead(existingState PrivilegeAssignment) { +} + type ProviderInfo struct { // The delta sharing authentication type. AuthenticationType types.String `tfsdk:"authentication_type" tf:"optional"` @@ -460,11 +694,23 @@ type ProviderInfo struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *ProviderInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ProviderInfo) { +} + +func (newState *ProviderInfo) SyncEffectiveFieldsDuringRead(existingState ProviderInfo) { +} + type ProviderShare struct { // The name of the Provider Share. Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *ProviderShare) SyncEffectiveFieldsDuringCreateOrUpdate(plan ProviderShare) { +} + +func (newState *ProviderShare) SyncEffectiveFieldsDuringRead(existingState ProviderShare) { +} + type RecipientInfo struct { // A boolean status field showing whether the Recipient's activation URL has // been exercised or not. @@ -513,6 +759,12 @@ type RecipientInfo struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *RecipientInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan RecipientInfo) { +} + +func (newState *RecipientInfo) SyncEffectiveFieldsDuringRead(existingState RecipientInfo) { +} + type RecipientProfile struct { // The token used to authorize the recipient. BearerToken types.String `tfsdk:"bearer_token" tf:"optional"` @@ -522,6 +774,12 @@ type RecipientProfile struct { ShareCredentialsVersion types.Int64 `tfsdk:"share_credentials_version" tf:"optional"` } +func (newState *RecipientProfile) SyncEffectiveFieldsDuringCreateOrUpdate(plan RecipientProfile) { +} + +func (newState *RecipientProfile) SyncEffectiveFieldsDuringRead(existingState RecipientProfile) { +} + type RecipientTokenInfo struct { // Full activation URL to retrieve the access token. It will be empty if the // token is already retrieved. @@ -540,12 +798,24 @@ type RecipientTokenInfo struct { UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` } +func (newState *RecipientTokenInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan RecipientTokenInfo) { +} + +func (newState *RecipientTokenInfo) SyncEffectiveFieldsDuringRead(existingState RecipientTokenInfo) { +} + // Get an access token type RetrieveTokenRequest struct { // The one time activation url. It also accepts activation token. ActivationUrl types.String `tfsdk:"-"` } +func (newState *RetrieveTokenRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RetrieveTokenRequest) { +} + +func (newState *RetrieveTokenRequest) SyncEffectiveFieldsDuringRead(existingState RetrieveTokenRequest) { +} + type RetrieveTokenResponse struct { // The token used to authorize the recipient. BearerToken types.String `tfsdk:"bearerToken" tf:"optional"` @@ -557,6 +827,12 @@ type RetrieveTokenResponse struct { ShareCredentialsVersion types.Int64 `tfsdk:"shareCredentialsVersion" tf:"optional"` } +func (newState *RetrieveTokenResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RetrieveTokenResponse) { +} + +func (newState *RetrieveTokenResponse) SyncEffectiveFieldsDuringRead(existingState RetrieveTokenResponse) { +} + type RotateRecipientToken struct { // The expiration time of the bearer token in ISO 8601 format. This will set // the expiration_time of existing token only to a smaller timestamp, it @@ -567,6 +843,12 @@ type RotateRecipientToken struct { Name types.String `tfsdk:"-"` } +func (newState *RotateRecipientToken) SyncEffectiveFieldsDuringCreateOrUpdate(plan RotateRecipientToken) { +} + +func (newState *RotateRecipientToken) SyncEffectiveFieldsDuringRead(existingState RotateRecipientToken) { +} + // An object with __properties__ containing map of key-value properties attached // to the securable. type SecurablePropertiesKvPairs struct { @@ -574,27 +856,45 @@ type SecurablePropertiesKvPairs struct { Properties map[string]types.String `tfsdk:"properties" tf:""` } +func (newState *SecurablePropertiesKvPairs) SyncEffectiveFieldsDuringCreateOrUpdate(plan SecurablePropertiesKvPairs) { +} + +func (newState *SecurablePropertiesKvPairs) SyncEffectiveFieldsDuringRead(existingState SecurablePropertiesKvPairs) { +} + type ShareInfo struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` // Time at which this share was created, in epoch milliseconds. - CreatedAt types.Int64 `tfsdk:"created_at" tf:"optional"` + CreatedAt types.Int64 `tfsdk:"created_at" tf:"computed,optional"` // Username of share creator. - CreatedBy types.String `tfsdk:"created_by" tf:"optional"` + CreatedBy types.String `tfsdk:"created_by" tf:"computed,optional"` // Name of the share. Name types.String `tfsdk:"name" tf:"optional"` // A list of shared data objects within the share. - Objects []SharedDataObject `tfsdk:"objects" tf:"optional"` + Objects []SharedDataObject `tfsdk:"object" tf:"optional"` // Username of current owner of share. - Owner types.String `tfsdk:"owner" tf:"optional"` + Owner types.String `tfsdk:"owner" tf:"optional"` + EffectiveOwner types.String `tfsdk:"effective_owner" tf:"computed,optional"` // Storage Location URL (full path) for the share. StorageLocation types.String `tfsdk:"storage_location" tf:"optional"` // Storage root URL for the share. StorageRoot types.String `tfsdk:"storage_root" tf:"optional"` // Time at which this share was updated, in epoch milliseconds. - UpdatedAt types.Int64 `tfsdk:"updated_at" tf:"optional"` + UpdatedAt types.Int64 `tfsdk:"updated_at" tf:"computed,optional"` // Username of share updater. - UpdatedBy types.String `tfsdk:"updated_by" tf:"optional"` + UpdatedBy types.String `tfsdk:"updated_by" tf:"computed,optional"` +} + +func (newState *ShareInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ShareInfo) { + newState.EffectiveOwner = newState.Owner + newState.Owner = plan.Owner +} + +func (newState *ShareInfo) SyncEffectiveFieldsDuringRead(existingState ShareInfo) { + if existingState.EffectiveOwner.ValueString() == newState.Owner.ValueString() { + newState.Owner = existingState.Owner + } } // Get recipient share permissions @@ -615,6 +915,12 @@ type SharePermissionsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *SharePermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan SharePermissionsRequest) { +} + +func (newState *SharePermissionsRequest) SyncEffectiveFieldsDuringRead(existingState SharePermissionsRequest) { +} + type ShareToPrivilegeAssignment struct { // The privileges assigned to the principal. PrivilegeAssignments []PrivilegeAssignment `tfsdk:"privilege_assignments" tf:"optional"` @@ -622,14 +928,21 @@ type ShareToPrivilegeAssignment struct { ShareName types.String `tfsdk:"share_name" tf:"optional"` } +func (newState *ShareToPrivilegeAssignment) SyncEffectiveFieldsDuringCreateOrUpdate(plan ShareToPrivilegeAssignment) { +} + +func (newState *ShareToPrivilegeAssignment) SyncEffectiveFieldsDuringRead(existingState ShareToPrivilegeAssignment) { +} + type SharedDataObject struct { // The time when this data object is added to the share, in epoch // milliseconds. - AddedAt types.Int64 `tfsdk:"added_at" tf:"optional"` + AddedAt types.Int64 `tfsdk:"added_at" tf:"computed,optional"` // Username of the sharer. - AddedBy types.String `tfsdk:"added_by" tf:"optional"` + AddedBy types.String `tfsdk:"added_by" tf:"computed,optional"` // Whether to enable cdf or indicate if cdf is enabled on the shared object. - CdfEnabled types.Bool `tfsdk:"cdf_enabled" tf:"optional"` + CdfEnabled types.Bool `tfsdk:"cdf_enabled" tf:"optional"` + EffectiveCdfEnabled types.Bool `tfsdk:"effective_cdf_enabled" tf:"computed,optional"` // A user-provided comment when adding the data object to the share. // [Update:OPT] Comment types.String `tfsdk:"comment" tf:"optional"` @@ -641,19 +954,21 @@ type SharedDataObject struct { DataObjectType types.String `tfsdk:"data_object_type" tf:"optional"` // Whether to enable or disable sharing of data history. If not specified, // the default is **DISABLED**. - HistoryDataSharingStatus types.String `tfsdk:"history_data_sharing_status" tf:"optional"` + HistoryDataSharingStatus types.String `tfsdk:"history_data_sharing_status" tf:"optional"` + EffectiveHistoryDataSharingStatus types.String `tfsdk:"effective_history_data_sharing_status" tf:"computed,optional"` // A fully qualified name that uniquely identifies a data object. // // For example, a table's fully qualified name is in the format of // `..`. Name types.String `tfsdk:"name" tf:""` // Array of partitions for the shared data. - Partitions []Partition `tfsdk:"partitions" tf:"optional"` + Partitions []Partition `tfsdk:"partition" tf:"optional"` // A user-provided new name for the data object within the share. If this // new name is not provided, the object's original name will be used as the // `shared_as` name. The `shared_as` name must be unique within a share. For // tables, the new name must follow the format of `.
`. - SharedAs types.String `tfsdk:"shared_as" tf:"optional"` + SharedAs types.String `tfsdk:"shared_as" tf:"optional"` + EffectiveSharedAs types.String `tfsdk:"effective_shared_as" tf:"computed,optional"` // The start version associated with the object. This allows data providers // to control the lowest object version that is accessible by clients. If // specified, clients can query snapshots or changes for versions >= @@ -661,9 +976,10 @@ type SharedDataObject struct { // version of the object at the time it was added to the share. // // NOTE: The start_version should be <= the `current` version of the object. - StartVersion types.Int64 `tfsdk:"start_version" tf:"optional"` + StartVersion types.Int64 `tfsdk:"start_version" tf:"optional"` + EffectiveStartVersion types.Int64 `tfsdk:"effective_start_version" tf:"computed,optional"` // One of: **ACTIVE**, **PERMISSION_DENIED**. - Status types.String `tfsdk:"status" tf:"optional"` + Status types.String `tfsdk:"status" tf:"computed,optional"` // A user-provided new name for the data object within the share. If this // new name is not provided, the object's original name will be used as the // `string_shared_as` name. The `string_shared_as` name must be unique @@ -672,6 +988,32 @@ type SharedDataObject struct { StringSharedAs types.String `tfsdk:"string_shared_as" tf:"optional"` } +func (newState *SharedDataObject) SyncEffectiveFieldsDuringCreateOrUpdate(plan SharedDataObject) { + newState.EffectiveCdfEnabled = newState.CdfEnabled + newState.CdfEnabled = plan.CdfEnabled + newState.EffectiveHistoryDataSharingStatus = newState.HistoryDataSharingStatus + newState.HistoryDataSharingStatus = plan.HistoryDataSharingStatus + newState.EffectiveSharedAs = newState.SharedAs + newState.SharedAs = plan.SharedAs + newState.EffectiveStartVersion = newState.StartVersion + newState.StartVersion = plan.StartVersion +} + +func (newState *SharedDataObject) SyncEffectiveFieldsDuringRead(existingState SharedDataObject) { + if existingState.EffectiveCdfEnabled.ValueBool() == newState.CdfEnabled.ValueBool() { + newState.CdfEnabled = existingState.CdfEnabled + } + if existingState.EffectiveHistoryDataSharingStatus.ValueString() == newState.HistoryDataSharingStatus.ValueString() { + newState.HistoryDataSharingStatus = existingState.HistoryDataSharingStatus + } + if existingState.EffectiveSharedAs.ValueString() == newState.SharedAs.ValueString() { + newState.SharedAs = existingState.SharedAs + } + if existingState.EffectiveStartVersion.ValueInt64() == newState.StartVersion.ValueInt64() { + newState.StartVersion = existingState.StartVersion + } +} + type SharedDataObjectUpdate struct { // One of: **ADD**, **REMOVE**, **UPDATE**. Action types.String `tfsdk:"action" tf:"optional"` @@ -679,6 +1021,12 @@ type SharedDataObjectUpdate struct { DataObject []SharedDataObject `tfsdk:"data_object" tf:"optional,object"` } +func (newState *SharedDataObjectUpdate) SyncEffectiveFieldsDuringCreateOrUpdate(plan SharedDataObjectUpdate) { +} + +func (newState *SharedDataObjectUpdate) SyncEffectiveFieldsDuringRead(existingState SharedDataObjectUpdate) { +} + type UpdateCleanRoom struct { // Array of shared data object updates. CatalogUpdates []CleanRoomCatalogUpdate `tfsdk:"catalog_updates" tf:"optional"` @@ -690,9 +1038,21 @@ type UpdateCleanRoom struct { Owner types.String `tfsdk:"owner" tf:"optional"` } +func (newState *UpdateCleanRoom) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateCleanRoom) { +} + +func (newState *UpdateCleanRoom) SyncEffectiveFieldsDuringRead(existingState UpdateCleanRoom) { +} + type UpdatePermissionsResponse struct { } +func (newState *UpdatePermissionsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdatePermissionsResponse) { +} + +func (newState *UpdatePermissionsResponse) SyncEffectiveFieldsDuringRead(existingState UpdatePermissionsResponse) { +} + type UpdateProvider struct { // Description about the provider. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -707,6 +1067,12 @@ type UpdateProvider struct { RecipientProfileStr types.String `tfsdk:"recipient_profile_str" tf:"optional"` } +func (newState *UpdateProvider) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateProvider) { +} + +func (newState *UpdateProvider) SyncEffectiveFieldsDuringRead(existingState UpdateProvider) { +} + type UpdateRecipient struct { // Description about the recipient. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -727,9 +1093,21 @@ type UpdateRecipient struct { PropertiesKvpairs []SecurablePropertiesKvPairs `tfsdk:"properties_kvpairs" tf:"optional,object"` } +func (newState *UpdateRecipient) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateRecipient) { +} + +func (newState *UpdateRecipient) SyncEffectiveFieldsDuringRead(existingState UpdateRecipient) { +} + type UpdateResponse struct { } +func (newState *UpdateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateResponse) { +} + +func (newState *UpdateResponse) SyncEffectiveFieldsDuringRead(existingState UpdateResponse) { +} + type UpdateShare struct { // User-provided free-form text description. Comment types.String `tfsdk:"comment" tf:"optional"` @@ -738,13 +1116,25 @@ type UpdateShare struct { // New name for the share. NewName types.String `tfsdk:"new_name" tf:"optional"` // Username of current owner of share. - Owner types.String `tfsdk:"owner" tf:"optional"` + Owner types.String `tfsdk:"owner" tf:"optional"` + EffectiveOwner types.String `tfsdk:"effective_owner" tf:"computed,optional"` // Storage root URL for the share. StorageRoot types.String `tfsdk:"storage_root" tf:"optional"` // Array of shared data object updates. Updates []SharedDataObjectUpdate `tfsdk:"updates" tf:"optional"` } +func (newState *UpdateShare) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateShare) { + newState.EffectiveOwner = newState.Owner + newState.Owner = plan.Owner +} + +func (newState *UpdateShare) SyncEffectiveFieldsDuringRead(existingState UpdateShare) { + if existingState.EffectiveOwner.ValueString() == newState.Owner.ValueString() { + newState.Owner = existingState.Owner + } +} + type UpdateSharePermissions struct { // Array of permission changes. Changes catalog.PermissionsChange `tfsdk:"changes" tf:"optional"` @@ -763,3 +1153,9 @@ type UpdateSharePermissions struct { // Opaque pagination token to go to next page based on previous query. PageToken types.String `tfsdk:"-"` } + +func (newState *UpdateSharePermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateSharePermissions) { +} + +func (newState *UpdateSharePermissions) SyncEffectiveFieldsDuringRead(existingState UpdateSharePermissions) { +} diff --git a/internal/service/sql_tf/model.go b/internal/service/sql_tf/model.go index 18cf637b87..b961f17901 100755 --- a/internal/service/sql_tf/model.go +++ b/internal/service/sql_tf/model.go @@ -23,6 +23,12 @@ type AccessControl struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *AccessControl) SyncEffectiveFieldsDuringCreateOrUpdate(plan AccessControl) { +} + +func (newState *AccessControl) SyncEffectiveFieldsDuringRead(existingState AccessControl) { +} + type Alert struct { // Trigger conditions of the alert. Condition []AlertCondition `tfsdk:"condition" tf:"optional,object"` @@ -45,6 +51,8 @@ type Alert struct { Id types.String `tfsdk:"id" tf:"optional"` // The workspace state of the alert. Used for tracking trashed status. LifecycleState types.String `tfsdk:"lifecycle_state" tf:"optional"` + // Whether to notify alert subscribers when alert returns back to normal. + NotifyOnOk types.Bool `tfsdk:"notify_on_ok" tf:"optional"` // The owner's username. This field is set to "Unavailable" if the user has // been deleted. OwnerUserName types.String `tfsdk:"owner_user_name" tf:"optional"` @@ -67,6 +75,12 @@ type Alert struct { UpdateTime types.String `tfsdk:"update_time" tf:"optional"` } +func (newState *Alert) SyncEffectiveFieldsDuringCreateOrUpdate(plan Alert) { +} + +func (newState *Alert) SyncEffectiveFieldsDuringRead(existingState Alert) { +} + type AlertCondition struct { // Alert state if result is empty. EmptyResultState types.String `tfsdk:"empty_result_state" tf:"optional"` @@ -79,18 +93,42 @@ type AlertCondition struct { Threshold []AlertConditionThreshold `tfsdk:"threshold" tf:"optional,object"` } +func (newState *AlertCondition) SyncEffectiveFieldsDuringCreateOrUpdate(plan AlertCondition) { +} + +func (newState *AlertCondition) SyncEffectiveFieldsDuringRead(existingState AlertCondition) { +} + type AlertConditionOperand struct { Column []AlertOperandColumn `tfsdk:"column" tf:"optional,object"` } +func (newState *AlertConditionOperand) SyncEffectiveFieldsDuringCreateOrUpdate(plan AlertConditionOperand) { +} + +func (newState *AlertConditionOperand) SyncEffectiveFieldsDuringRead(existingState AlertConditionOperand) { +} + type AlertConditionThreshold struct { Value []AlertOperandValue `tfsdk:"value" tf:"optional,object"` } +func (newState *AlertConditionThreshold) SyncEffectiveFieldsDuringCreateOrUpdate(plan AlertConditionThreshold) { +} + +func (newState *AlertConditionThreshold) SyncEffectiveFieldsDuringRead(existingState AlertConditionThreshold) { +} + type AlertOperandColumn struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *AlertOperandColumn) SyncEffectiveFieldsDuringCreateOrUpdate(plan AlertOperandColumn) { +} + +func (newState *AlertOperandColumn) SyncEffectiveFieldsDuringRead(existingState AlertOperandColumn) { +} + type AlertOperandValue struct { BoolValue types.Bool `tfsdk:"bool_value" tf:"optional"` @@ -99,6 +137,12 @@ type AlertOperandValue struct { StringValue types.String `tfsdk:"string_value" tf:"optional"` } +func (newState *AlertOperandValue) SyncEffectiveFieldsDuringCreateOrUpdate(plan AlertOperandValue) { +} + +func (newState *AlertOperandValue) SyncEffectiveFieldsDuringRead(existingState AlertOperandValue) { +} + // Alert configuration options. type AlertOptions struct { // Name of column in the query result to compare in alert evaluation. @@ -127,6 +171,12 @@ type AlertOptions struct { Value any `tfsdk:"value" tf:""` } +func (newState *AlertOptions) SyncEffectiveFieldsDuringCreateOrUpdate(plan AlertOptions) { +} + +func (newState *AlertOptions) SyncEffectiveFieldsDuringRead(existingState AlertOptions) { +} + type AlertQuery struct { // The timestamp when this query was created. CreatedAt types.String `tfsdk:"created_at" tf:"optional"` @@ -169,6 +219,12 @@ type AlertQuery struct { UserId types.Int64 `tfsdk:"user_id" tf:"optional"` } +func (newState *AlertQuery) SyncEffectiveFieldsDuringCreateOrUpdate(plan AlertQuery) { +} + +func (newState *AlertQuery) SyncEffectiveFieldsDuringRead(existingState AlertQuery) { +} + // Describes metadata for a particular chunk, within a result set; this // structure is used both within a manifest, and when fetching individual chunk // data or links. @@ -184,6 +240,12 @@ type BaseChunkInfo struct { RowOffset types.Int64 `tfsdk:"row_offset" tf:"optional"` } +func (newState *BaseChunkInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan BaseChunkInfo) { +} + +func (newState *BaseChunkInfo) SyncEffectiveFieldsDuringRead(existingState BaseChunkInfo) { +} + // Cancel statement execution type CancelExecutionRequest struct { // The statement ID is returned upon successfully submitting a SQL @@ -191,9 +253,21 @@ type CancelExecutionRequest struct { StatementId types.String `tfsdk:"-"` } +func (newState *CancelExecutionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CancelExecutionRequest) { +} + +func (newState *CancelExecutionRequest) SyncEffectiveFieldsDuringRead(existingState CancelExecutionRequest) { +} + type CancelExecutionResponse struct { } +func (newState *CancelExecutionResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CancelExecutionResponse) { +} + +func (newState *CancelExecutionResponse) SyncEffectiveFieldsDuringRead(existingState CancelExecutionResponse) { +} + // Configures the channel name and DBSQL version of the warehouse. // CHANNEL_NAME_CUSTOM should be chosen only when `dbsql_version` is specified. type Channel struct { @@ -202,6 +276,12 @@ type Channel struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *Channel) SyncEffectiveFieldsDuringCreateOrUpdate(plan Channel) { +} + +func (newState *Channel) SyncEffectiveFieldsDuringRead(existingState Channel) { +} + // Details about a Channel. type ChannelInfo struct { // DB SQL Version the Channel is mapped to. @@ -210,6 +290,12 @@ type ChannelInfo struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *ChannelInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ChannelInfo) { +} + +func (newState *ChannelInfo) SyncEffectiveFieldsDuringRead(existingState ChannelInfo) { +} + type ColumnInfo struct { // The name of the column. Name types.String `tfsdk:"name" tf:"optional"` @@ -230,6 +316,12 @@ type ColumnInfo struct { TypeText types.String `tfsdk:"type_text" tf:"optional"` } +func (newState *ColumnInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ColumnInfo) { +} + +func (newState *ColumnInfo) SyncEffectiveFieldsDuringRead(existingState ColumnInfo) { +} + type CreateAlert struct { // Name of the alert. Name types.String `tfsdk:"name" tf:""` @@ -245,10 +337,22 @@ type CreateAlert struct { Rearm types.Int64 `tfsdk:"rearm" tf:"optional"` } +func (newState *CreateAlert) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateAlert) { +} + +func (newState *CreateAlert) SyncEffectiveFieldsDuringRead(existingState CreateAlert) { +} + type CreateAlertRequest struct { Alert []CreateAlertRequestAlert `tfsdk:"alert" tf:"optional,object"` } +func (newState *CreateAlertRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateAlertRequest) { +} + +func (newState *CreateAlertRequest) SyncEffectiveFieldsDuringRead(existingState CreateAlertRequest) { +} + type CreateAlertRequestAlert struct { // Trigger conditions of the alert. Condition []AlertCondition `tfsdk:"condition" tf:"optional,object"` @@ -265,6 +369,8 @@ type CreateAlertRequestAlert struct { CustomSubject types.String `tfsdk:"custom_subject" tf:"optional"` // The display name of the alert. DisplayName types.String `tfsdk:"display_name" tf:"optional"` + // Whether to notify alert subscribers when alert returns back to normal. + NotifyOnOk types.Bool `tfsdk:"notify_on_ok" tf:"optional"` // The workspace path of the folder containing the alert. ParentPath types.String `tfsdk:"parent_path" tf:"optional"` // UUID of the query attached to the alert. @@ -275,10 +381,22 @@ type CreateAlertRequestAlert struct { SecondsToRetrigger types.Int64 `tfsdk:"seconds_to_retrigger" tf:"optional"` } +func (newState *CreateAlertRequestAlert) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateAlertRequestAlert) { +} + +func (newState *CreateAlertRequestAlert) SyncEffectiveFieldsDuringRead(existingState CreateAlertRequestAlert) { +} + type CreateQueryRequest struct { Query []CreateQueryRequestQuery `tfsdk:"query" tf:"optional,object"` } +func (newState *CreateQueryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateQueryRequest) { +} + +func (newState *CreateQueryRequest) SyncEffectiveFieldsDuringRead(existingState CreateQueryRequest) { +} + type CreateQueryRequestQuery struct { // Whether to apply a 1000 row limit to the query result. ApplyAutoLimit types.Bool `tfsdk:"apply_auto_limit" tf:"optional"` @@ -306,6 +424,12 @@ type CreateQueryRequestQuery struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *CreateQueryRequestQuery) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateQueryRequestQuery) { +} + +func (newState *CreateQueryRequestQuery) SyncEffectiveFieldsDuringRead(existingState CreateQueryRequestQuery) { +} + // Add visualization to a query type CreateQueryVisualizationsLegacyRequest struct { // A short description of this visualization. This is not displayed in the @@ -324,10 +448,22 @@ type CreateQueryVisualizationsLegacyRequest struct { Type types.String `tfsdk:"type" tf:""` } +func (newState *CreateQueryVisualizationsLegacyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateQueryVisualizationsLegacyRequest) { +} + +func (newState *CreateQueryVisualizationsLegacyRequest) SyncEffectiveFieldsDuringRead(existingState CreateQueryVisualizationsLegacyRequest) { +} + type CreateVisualizationRequest struct { Visualization []CreateVisualizationRequestVisualization `tfsdk:"visualization" tf:"optional,object"` } +func (newState *CreateVisualizationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateVisualizationRequest) { +} + +func (newState *CreateVisualizationRequest) SyncEffectiveFieldsDuringRead(existingState CreateVisualizationRequest) { +} + type CreateVisualizationRequestVisualization struct { // The display name of the visualization. DisplayName types.String `tfsdk:"display_name" tf:"optional"` @@ -345,6 +481,12 @@ type CreateVisualizationRequestVisualization struct { Type types.String `tfsdk:"type" tf:"optional"` } +func (newState *CreateVisualizationRequestVisualization) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateVisualizationRequestVisualization) { +} + +func (newState *CreateVisualizationRequestVisualization) SyncEffectiveFieldsDuringRead(existingState CreateVisualizationRequestVisualization) { +} + type CreateWarehouseRequest struct { // The amount of time in minutes that a SQL warehouse must be idle (i.e., no // RUNNING queries) before it is automatically stopped. @@ -409,11 +551,23 @@ type CreateWarehouseRequest struct { WarehouseType types.String `tfsdk:"warehouse_type" tf:"optional"` } +func (newState *CreateWarehouseRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateWarehouseRequest) { +} + +func (newState *CreateWarehouseRequest) SyncEffectiveFieldsDuringRead(existingState CreateWarehouseRequest) { +} + type CreateWarehouseResponse struct { // Id for the SQL warehouse. This value is unique across all SQL warehouses. Id types.String `tfsdk:"id" tf:"optional"` } +func (newState *CreateWarehouseResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateWarehouseResponse) { +} + +func (newState *CreateWarehouseResponse) SyncEffectiveFieldsDuringRead(existingState CreateWarehouseResponse) { +} + type CreateWidget struct { // Dashboard ID returned by :method:dashboards/create. DashboardId types.String `tfsdk:"dashboard_id" tf:""` @@ -431,6 +585,12 @@ type CreateWidget struct { Width types.Int64 `tfsdk:"width" tf:""` } +func (newState *CreateWidget) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateWidget) { +} + +func (newState *CreateWidget) SyncEffectiveFieldsDuringRead(existingState CreateWidget) { +} + // A JSON representing a dashboard containing widgets of visualizations and text // boxes. type Dashboard struct { @@ -480,6 +640,12 @@ type Dashboard struct { Widgets []Widget `tfsdk:"widgets" tf:"optional"` } +func (newState *Dashboard) SyncEffectiveFieldsDuringCreateOrUpdate(plan Dashboard) { +} + +func (newState *Dashboard) SyncEffectiveFieldsDuringRead(existingState Dashboard) { +} + type DashboardEditContent struct { DashboardId types.String `tfsdk:"-"` // The title of this dashboard that appears in list views and at the top of @@ -493,6 +659,12 @@ type DashboardEditContent struct { Tags []types.String `tfsdk:"tags" tf:"optional"` } +func (newState *DashboardEditContent) SyncEffectiveFieldsDuringCreateOrUpdate(plan DashboardEditContent) { +} + +func (newState *DashboardEditContent) SyncEffectiveFieldsDuringRead(existingState DashboardEditContent) { +} + type DashboardOptions struct { // The timestamp when this dashboard was moved to trash. Only present when // the `is_archived` property is `true`. Trashed items are deleted after @@ -500,6 +672,12 @@ type DashboardOptions struct { MovedToTrashAt types.String `tfsdk:"moved_to_trash_at" tf:"optional"` } +func (newState *DashboardOptions) SyncEffectiveFieldsDuringCreateOrUpdate(plan DashboardOptions) { +} + +func (newState *DashboardOptions) SyncEffectiveFieldsDuringRead(existingState DashboardOptions) { +} + type DashboardPostContent struct { // Indicates whether the dashboard filters are enabled DashboardFiltersEnabled types.Bool `tfsdk:"dashboard_filters_enabled" tf:"optional"` @@ -519,6 +697,12 @@ type DashboardPostContent struct { Tags []types.String `tfsdk:"tags" tf:"optional"` } +func (newState *DashboardPostContent) SyncEffectiveFieldsDuringCreateOrUpdate(plan DashboardPostContent) { +} + +func (newState *DashboardPostContent) SyncEffectiveFieldsDuringRead(existingState DashboardPostContent) { +} + // A JSON object representing a DBSQL data source / SQL warehouse. type DataSource struct { // Data source ID maps to the ID of the data source used by the resource and @@ -547,12 +731,24 @@ type DataSource struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *DataSource) SyncEffectiveFieldsDuringCreateOrUpdate(plan DataSource) { +} + +func (newState *DataSource) SyncEffectiveFieldsDuringRead(existingState DataSource) { +} + type DateRange struct { End types.String `tfsdk:"end" tf:""` Start types.String `tfsdk:"start" tf:""` } +func (newState *DateRange) SyncEffectiveFieldsDuringCreateOrUpdate(plan DateRange) { +} + +func (newState *DateRange) SyncEffectiveFieldsDuringRead(existingState DateRange) { +} + type DateRangeValue struct { // Manually specified date-time range value. DateRangeValue []DateRange `tfsdk:"date_range_value" tf:"optional,object"` @@ -565,6 +761,12 @@ type DateRangeValue struct { StartDayOfWeek types.Int64 `tfsdk:"start_day_of_week" tf:"optional"` } +func (newState *DateRangeValue) SyncEffectiveFieldsDuringCreateOrUpdate(plan DateRangeValue) { +} + +func (newState *DateRangeValue) SyncEffectiveFieldsDuringRead(existingState DateRangeValue) { +} + type DateValue struct { // Manually specified date-time value. DateValue types.String `tfsdk:"date_value" tf:"optional"` @@ -575,50 +777,110 @@ type DateValue struct { Precision types.String `tfsdk:"precision" tf:"optional"` } +func (newState *DateValue) SyncEffectiveFieldsDuringCreateOrUpdate(plan DateValue) { +} + +func (newState *DateValue) SyncEffectiveFieldsDuringRead(existingState DateValue) { +} + // Delete an alert type DeleteAlertsLegacyRequest struct { AlertId types.String `tfsdk:"-"` } +func (newState *DeleteAlertsLegacyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAlertsLegacyRequest) { +} + +func (newState *DeleteAlertsLegacyRequest) SyncEffectiveFieldsDuringRead(existingState DeleteAlertsLegacyRequest) { +} + // Remove a dashboard type DeleteDashboardRequest struct { DashboardId types.String `tfsdk:"-"` } +func (newState *DeleteDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDashboardRequest) { +} + +func (newState *DeleteDashboardRequest) SyncEffectiveFieldsDuringRead(existingState DeleteDashboardRequest) { +} + // Remove widget type DeleteDashboardWidgetRequest struct { // Widget ID returned by :method:dashboardwidgets/create Id types.String `tfsdk:"-"` } +func (newState *DeleteDashboardWidgetRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDashboardWidgetRequest) { +} + +func (newState *DeleteDashboardWidgetRequest) SyncEffectiveFieldsDuringRead(existingState DeleteDashboardWidgetRequest) { +} + // Delete a query type DeleteQueriesLegacyRequest struct { QueryId types.String `tfsdk:"-"` } +func (newState *DeleteQueriesLegacyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteQueriesLegacyRequest) { +} + +func (newState *DeleteQueriesLegacyRequest) SyncEffectiveFieldsDuringRead(existingState DeleteQueriesLegacyRequest) { +} + // Remove visualization type DeleteQueryVisualizationsLegacyRequest struct { // Widget ID returned by :method:queryvizualisations/create Id types.String `tfsdk:"-"` } +func (newState *DeleteQueryVisualizationsLegacyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteQueryVisualizationsLegacyRequest) { +} + +func (newState *DeleteQueryVisualizationsLegacyRequest) SyncEffectiveFieldsDuringRead(existingState DeleteQueryVisualizationsLegacyRequest) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + // Remove a visualization type DeleteVisualizationRequest struct { Id types.String `tfsdk:"-"` } +func (newState *DeleteVisualizationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteVisualizationRequest) { +} + +func (newState *DeleteVisualizationRequest) SyncEffectiveFieldsDuringRead(existingState DeleteVisualizationRequest) { +} + // Delete a warehouse type DeleteWarehouseRequest struct { // Required. Id of the SQL warehouse. Id types.String `tfsdk:"-"` } +func (newState *DeleteWarehouseRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteWarehouseRequest) { +} + +func (newState *DeleteWarehouseRequest) SyncEffectiveFieldsDuringRead(existingState DeleteWarehouseRequest) { +} + type DeleteWarehouseResponse struct { } +func (newState *DeleteWarehouseResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteWarehouseResponse) { +} + +func (newState *DeleteWarehouseResponse) SyncEffectiveFieldsDuringRead(existingState DeleteWarehouseResponse) { +} + type EditAlert struct { AlertId types.String `tfsdk:"-"` // Name of the alert. @@ -633,6 +895,12 @@ type EditAlert struct { Rearm types.Int64 `tfsdk:"rearm" tf:"optional"` } +func (newState *EditAlert) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditAlert) { +} + +func (newState *EditAlert) SyncEffectiveFieldsDuringRead(existingState EditAlert) { +} + type EditWarehouseRequest struct { // The amount of time in minutes that a SQL warehouse must be idle (i.e., no // RUNNING queries) before it is automatically stopped. @@ -697,20 +965,44 @@ type EditWarehouseRequest struct { WarehouseType types.String `tfsdk:"warehouse_type" tf:"optional"` } +func (newState *EditWarehouseRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditWarehouseRequest) { +} + +func (newState *EditWarehouseRequest) SyncEffectiveFieldsDuringRead(existingState EditWarehouseRequest) { +} + type EditWarehouseResponse struct { } +func (newState *EditWarehouseResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan EditWarehouseResponse) { +} + +func (newState *EditWarehouseResponse) SyncEffectiveFieldsDuringRead(existingState EditWarehouseResponse) { +} + // Represents an empty message, similar to google.protobuf.Empty, which is not // available in the firm right now. type Empty struct { } +func (newState *Empty) SyncEffectiveFieldsDuringCreateOrUpdate(plan Empty) { +} + +func (newState *Empty) SyncEffectiveFieldsDuringRead(existingState Empty) { +} + type EndpointConfPair struct { Key types.String `tfsdk:"key" tf:"optional"` Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *EndpointConfPair) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointConfPair) { +} + +func (newState *EndpointConfPair) SyncEffectiveFieldsDuringRead(existingState EndpointConfPair) { +} + type EndpointHealth struct { // Details about errors that are causing current degraded/failed status. Details types.String `tfsdk:"details" tf:"optional"` @@ -726,6 +1018,12 @@ type EndpointHealth struct { Summary types.String `tfsdk:"summary" tf:"optional"` } +func (newState *EndpointHealth) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointHealth) { +} + +func (newState *EndpointHealth) SyncEffectiveFieldsDuringRead(existingState EndpointHealth) { +} + type EndpointInfo struct { // The amount of time in minutes that a SQL warehouse must be idle (i.e., no // RUNNING queries) before it is automatically stopped. @@ -803,16 +1101,34 @@ type EndpointInfo struct { WarehouseType types.String `tfsdk:"warehouse_type" tf:"optional"` } +func (newState *EndpointInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointInfo) { +} + +func (newState *EndpointInfo) SyncEffectiveFieldsDuringRead(existingState EndpointInfo) { +} + type EndpointTagPair struct { Key types.String `tfsdk:"key" tf:"optional"` Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *EndpointTagPair) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointTagPair) { +} + +func (newState *EndpointTagPair) SyncEffectiveFieldsDuringRead(existingState EndpointTagPair) { +} + type EndpointTags struct { CustomTags []EndpointTagPair `tfsdk:"custom_tags" tf:"optional"` } +func (newState *EndpointTags) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointTags) { +} + +func (newState *EndpointTags) SyncEffectiveFieldsDuringRead(existingState EndpointTags) { +} + type EnumValue struct { // List of valid query parameter values, newline delimited. EnumOptions types.String `tfsdk:"enum_options" tf:"optional"` @@ -822,6 +1138,12 @@ type EnumValue struct { Values []types.String `tfsdk:"values" tf:"optional"` } +func (newState *EnumValue) SyncEffectiveFieldsDuringCreateOrUpdate(plan EnumValue) { +} + +func (newState *EnumValue) SyncEffectiveFieldsDuringRead(existingState EnumValue) { +} + type ExecuteStatementRequest struct { // Applies the given byte limit to the statement's result size. Byte counts // are based on internal data representations and might not match the final @@ -948,6 +1270,12 @@ type ExecuteStatementRequest struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:""` } +func (newState *ExecuteStatementRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExecuteStatementRequest) { +} + +func (newState *ExecuteStatementRequest) SyncEffectiveFieldsDuringRead(existingState ExecuteStatementRequest) { +} + type ExternalLink struct { // The number of bytes in the result chunk. This field is not available when // using `INLINE` disposition. @@ -981,21 +1309,45 @@ type ExternalLink struct { RowOffset types.Int64 `tfsdk:"row_offset" tf:"optional"` } +func (newState *ExternalLink) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExternalLink) { +} + +func (newState *ExternalLink) SyncEffectiveFieldsDuringRead(existingState ExternalLink) { +} + // Get an alert type GetAlertRequest struct { Id types.String `tfsdk:"-"` } +func (newState *GetAlertRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAlertRequest) { +} + +func (newState *GetAlertRequest) SyncEffectiveFieldsDuringRead(existingState GetAlertRequest) { +} + // Get an alert type GetAlertsLegacyRequest struct { AlertId types.String `tfsdk:"-"` } +func (newState *GetAlertsLegacyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAlertsLegacyRequest) { +} + +func (newState *GetAlertsLegacyRequest) SyncEffectiveFieldsDuringRead(existingState GetAlertsLegacyRequest) { +} + // Retrieve a definition type GetDashboardRequest struct { DashboardId types.String `tfsdk:"-"` } +func (newState *GetDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetDashboardRequest) { +} + +func (newState *GetDashboardRequest) SyncEffectiveFieldsDuringRead(existingState GetDashboardRequest) { +} + // Get object ACL type GetDbsqlPermissionRequest struct { // Object ID. An ACL is returned for the object with this UUID. @@ -1004,16 +1356,34 @@ type GetDbsqlPermissionRequest struct { ObjectType types.String `tfsdk:"-"` } +func (newState *GetDbsqlPermissionRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetDbsqlPermissionRequest) { +} + +func (newState *GetDbsqlPermissionRequest) SyncEffectiveFieldsDuringRead(existingState GetDbsqlPermissionRequest) { +} + // Get a query definition. type GetQueriesLegacyRequest struct { QueryId types.String `tfsdk:"-"` } +func (newState *GetQueriesLegacyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetQueriesLegacyRequest) { +} + +func (newState *GetQueriesLegacyRequest) SyncEffectiveFieldsDuringRead(existingState GetQueriesLegacyRequest) { +} + // Get a query type GetQueryRequest struct { Id types.String `tfsdk:"-"` } +func (newState *GetQueryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetQueryRequest) { +} + +func (newState *GetQueryRequest) SyncEffectiveFieldsDuringRead(existingState GetQueryRequest) { +} + type GetResponse struct { AccessControlList []AccessControl `tfsdk:"access_control_list" tf:"optional"` // An object's type and UUID, separated by a forward slash (/) character. @@ -1022,6 +1392,12 @@ type GetResponse struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *GetResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetResponse) { +} + +func (newState *GetResponse) SyncEffectiveFieldsDuringRead(existingState GetResponse) { +} + // Get status, manifest, and result first chunk type GetStatementRequest struct { // The statement ID is returned upon successfully submitting a SQL @@ -1029,6 +1405,12 @@ type GetStatementRequest struct { StatementId types.String `tfsdk:"-"` } +func (newState *GetStatementRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetStatementRequest) { +} + +func (newState *GetStatementRequest) SyncEffectiveFieldsDuringRead(existingState GetStatementRequest) { +} + // Get result chunk by index type GetStatementResultChunkNRequest struct { ChunkIndex types.Int64 `tfsdk:"-"` @@ -1037,29 +1419,59 @@ type GetStatementResultChunkNRequest struct { StatementId types.String `tfsdk:"-"` } +func (newState *GetStatementResultChunkNRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetStatementResultChunkNRequest) { +} + +func (newState *GetStatementResultChunkNRequest) SyncEffectiveFieldsDuringRead(existingState GetStatementResultChunkNRequest) { +} + // Get SQL warehouse permission levels type GetWarehousePermissionLevelsRequest struct { // The SQL warehouse for which to get or manage permissions. WarehouseId types.String `tfsdk:"-"` } +func (newState *GetWarehousePermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWarehousePermissionLevelsRequest) { +} + +func (newState *GetWarehousePermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetWarehousePermissionLevelsRequest) { +} + type GetWarehousePermissionLevelsResponse struct { // Specific permission levels PermissionLevels []WarehousePermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetWarehousePermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWarehousePermissionLevelsResponse) { +} + +func (newState *GetWarehousePermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetWarehousePermissionLevelsResponse) { +} + // Get SQL warehouse permissions type GetWarehousePermissionsRequest struct { // The SQL warehouse for which to get or manage permissions. WarehouseId types.String `tfsdk:"-"` } +func (newState *GetWarehousePermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWarehousePermissionsRequest) { +} + +func (newState *GetWarehousePermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetWarehousePermissionsRequest) { +} + // Get warehouse info type GetWarehouseRequest struct { // Required. Id of the SQL warehouse. Id types.String `tfsdk:"-"` } +func (newState *GetWarehouseRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWarehouseRequest) { +} + +func (newState *GetWarehouseRequest) SyncEffectiveFieldsDuringRead(existingState GetWarehouseRequest) { +} + type GetWarehouseResponse struct { // The amount of time in minutes that a SQL warehouse must be idle (i.e., no // RUNNING queries) before it is automatically stopped. @@ -1137,6 +1549,12 @@ type GetWarehouseResponse struct { WarehouseType types.String `tfsdk:"warehouse_type" tf:"optional"` } +func (newState *GetWarehouseResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWarehouseResponse) { +} + +func (newState *GetWarehouseResponse) SyncEffectiveFieldsDuringRead(existingState GetWarehouseResponse) { +} + type GetWorkspaceWarehouseConfigResponse struct { // Optional: Channel selection details Channel []Channel `tfsdk:"channel" tf:"optional,object"` @@ -1165,6 +1583,12 @@ type GetWorkspaceWarehouseConfigResponse struct { SqlConfigurationParameters []RepeatedEndpointConfPairs `tfsdk:"sql_configuration_parameters" tf:"optional,object"` } +func (newState *GetWorkspaceWarehouseConfigResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWorkspaceWarehouseConfigResponse) { +} + +func (newState *GetWorkspaceWarehouseConfigResponse) SyncEffectiveFieldsDuringRead(existingState GetWorkspaceWarehouseConfigResponse) { +} + type LegacyAlert struct { // Timestamp when the alert was created. CreatedAt types.String `tfsdk:"created_at" tf:"optional"` @@ -1194,6 +1618,12 @@ type LegacyAlert struct { User []User `tfsdk:"user" tf:"optional,object"` } +func (newState *LegacyAlert) SyncEffectiveFieldsDuringCreateOrUpdate(plan LegacyAlert) { +} + +func (newState *LegacyAlert) SyncEffectiveFieldsDuringRead(existingState LegacyAlert) { +} + type LegacyQuery struct { // Describes whether the authenticated user is allowed to edit the // definition of this query. @@ -1265,6 +1695,12 @@ type LegacyQuery struct { Visualizations []LegacyVisualization `tfsdk:"visualizations" tf:"optional"` } +func (newState *LegacyQuery) SyncEffectiveFieldsDuringCreateOrUpdate(plan LegacyQuery) { +} + +func (newState *LegacyQuery) SyncEffectiveFieldsDuringRead(existingState LegacyQuery) { +} + // The visualization description API changes frequently and is unsupported. You // can duplicate a visualization by copying description objects received _from // the API_ and then using them to create a new one with a POST request to the @@ -1292,6 +1728,12 @@ type LegacyVisualization struct { UpdatedAt types.String `tfsdk:"updated_at" tf:"optional"` } +func (newState *LegacyVisualization) SyncEffectiveFieldsDuringCreateOrUpdate(plan LegacyVisualization) { +} + +func (newState *LegacyVisualization) SyncEffectiveFieldsDuringRead(existingState LegacyVisualization) { +} + // List alerts type ListAlertsRequest struct { PageSize types.Int64 `tfsdk:"-"` @@ -1299,12 +1741,24 @@ type ListAlertsRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListAlertsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAlertsRequest) { +} + +func (newState *ListAlertsRequest) SyncEffectiveFieldsDuringRead(existingState ListAlertsRequest) { +} + type ListAlertsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` Results []ListAlertsResponseAlert `tfsdk:"results" tf:"optional"` } +func (newState *ListAlertsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAlertsResponse) { +} + +func (newState *ListAlertsResponse) SyncEffectiveFieldsDuringRead(existingState ListAlertsResponse) { +} + type ListAlertsResponseAlert struct { // Trigger conditions of the alert. Condition []AlertCondition `tfsdk:"condition" tf:"optional,object"` @@ -1327,6 +1781,8 @@ type ListAlertsResponseAlert struct { Id types.String `tfsdk:"id" tf:"optional"` // The workspace state of the alert. Used for tracking trashed status. LifecycleState types.String `tfsdk:"lifecycle_state" tf:"optional"` + // Whether to notify alert subscribers when alert returns back to normal. + NotifyOnOk types.Bool `tfsdk:"notify_on_ok" tf:"optional"` // The owner's username. This field is set to "Unavailable" if the user has // been deleted. OwnerUserName types.String `tfsdk:"owner_user_name" tf:"optional"` @@ -1347,6 +1803,12 @@ type ListAlertsResponseAlert struct { UpdateTime types.String `tfsdk:"update_time" tf:"optional"` } +func (newState *ListAlertsResponseAlert) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAlertsResponseAlert) { +} + +func (newState *ListAlertsResponseAlert) SyncEffectiveFieldsDuringRead(existingState ListAlertsResponseAlert) { +} + // Get dashboard objects type ListDashboardsRequest struct { // Name of dashboard attribute to order by. @@ -1359,6 +1821,12 @@ type ListDashboardsRequest struct { Q types.String `tfsdk:"-"` } +func (newState *ListDashboardsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListDashboardsRequest) { +} + +func (newState *ListDashboardsRequest) SyncEffectiveFieldsDuringRead(existingState ListDashboardsRequest) { +} + // Get a list of queries type ListQueriesLegacyRequest struct { // Name of query attribute to order by. Default sort order is ascending. @@ -1384,6 +1852,12 @@ type ListQueriesLegacyRequest struct { Q types.String `tfsdk:"-"` } +func (newState *ListQueriesLegacyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListQueriesLegacyRequest) { +} + +func (newState *ListQueriesLegacyRequest) SyncEffectiveFieldsDuringRead(existingState ListQueriesLegacyRequest) { +} + // List queries type ListQueriesRequest struct { PageSize types.Int64 `tfsdk:"-"` @@ -1391,6 +1865,12 @@ type ListQueriesRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListQueriesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListQueriesRequest) { +} + +func (newState *ListQueriesRequest) SyncEffectiveFieldsDuringRead(existingState ListQueriesRequest) { +} + type ListQueriesResponse struct { // Whether there is another page of results. HasNextPage types.Bool `tfsdk:"has_next_page" tf:"optional"` @@ -1400,6 +1880,12 @@ type ListQueriesResponse struct { Res []QueryInfo `tfsdk:"res" tf:"optional"` } +func (newState *ListQueriesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListQueriesResponse) { +} + +func (newState *ListQueriesResponse) SyncEffectiveFieldsDuringRead(existingState ListQueriesResponse) { +} + // List Queries type ListQueryHistoryRequest struct { // A filter to limit query history results. This field is optional. @@ -1417,12 +1903,24 @@ type ListQueryHistoryRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListQueryHistoryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListQueryHistoryRequest) { +} + +func (newState *ListQueryHistoryRequest) SyncEffectiveFieldsDuringRead(existingState ListQueryHistoryRequest) { +} + type ListQueryObjectsResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` Results []ListQueryObjectsResponseQuery `tfsdk:"results" tf:"optional"` } +func (newState *ListQueryObjectsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListQueryObjectsResponse) { +} + +func (newState *ListQueryObjectsResponse) SyncEffectiveFieldsDuringRead(existingState ListQueryObjectsResponse) { +} + type ListQueryObjectsResponseQuery struct { // Whether to apply a 1000 row limit to the query result. ApplyAutoLimit types.Bool `tfsdk:"apply_auto_limit" tf:"optional"` @@ -1460,6 +1958,12 @@ type ListQueryObjectsResponseQuery struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *ListQueryObjectsResponseQuery) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListQueryObjectsResponseQuery) { +} + +func (newState *ListQueryObjectsResponseQuery) SyncEffectiveFieldsDuringRead(existingState ListQueryObjectsResponseQuery) { +} + type ListResponse struct { // The total number of dashboards. Count types.Int64 `tfsdk:"count" tf:"optional"` @@ -1471,6 +1975,12 @@ type ListResponse struct { Results []Dashboard `tfsdk:"results" tf:"optional"` } +func (newState *ListResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListResponse) { +} + +func (newState *ListResponse) SyncEffectiveFieldsDuringRead(existingState ListResponse) { +} + // List visualizations on a query type ListVisualizationsForQueryRequest struct { Id types.String `tfsdk:"-"` @@ -1480,12 +1990,24 @@ type ListVisualizationsForQueryRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListVisualizationsForQueryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListVisualizationsForQueryRequest) { +} + +func (newState *ListVisualizationsForQueryRequest) SyncEffectiveFieldsDuringRead(existingState ListVisualizationsForQueryRequest) { +} + type ListVisualizationsForQueryResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` Results []Visualization `tfsdk:"results" tf:"optional"` } +func (newState *ListVisualizationsForQueryResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListVisualizationsForQueryResponse) { +} + +func (newState *ListVisualizationsForQueryResponse) SyncEffectiveFieldsDuringRead(existingState ListVisualizationsForQueryResponse) { +} + // List warehouses type ListWarehousesRequest struct { // Service Principal which will be used to fetch the list of warehouses. If @@ -1493,11 +2015,23 @@ type ListWarehousesRequest struct { RunAsUserId types.Int64 `tfsdk:"-"` } +func (newState *ListWarehousesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListWarehousesRequest) { +} + +func (newState *ListWarehousesRequest) SyncEffectiveFieldsDuringRead(existingState ListWarehousesRequest) { +} + type ListWarehousesResponse struct { // A list of warehouses and their configurations. Warehouses []EndpointInfo `tfsdk:"warehouses" tf:"optional"` } +func (newState *ListWarehousesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListWarehousesResponse) { +} + +func (newState *ListWarehousesResponse) SyncEffectiveFieldsDuringRead(existingState ListWarehousesResponse) { +} + type MultiValuesOptions struct { // Character that prefixes each selected parameter value. Prefix types.String `tfsdk:"prefix" tf:"optional"` @@ -1508,10 +2042,22 @@ type MultiValuesOptions struct { Suffix types.String `tfsdk:"suffix" tf:"optional"` } +func (newState *MultiValuesOptions) SyncEffectiveFieldsDuringCreateOrUpdate(plan MultiValuesOptions) { +} + +func (newState *MultiValuesOptions) SyncEffectiveFieldsDuringRead(existingState MultiValuesOptions) { +} + type NumericValue struct { Value types.Float64 `tfsdk:"value" tf:"optional"` } +func (newState *NumericValue) SyncEffectiveFieldsDuringCreateOrUpdate(plan NumericValue) { +} + +func (newState *NumericValue) SyncEffectiveFieldsDuringRead(existingState NumericValue) { +} + type OdbcParams struct { Hostname types.String `tfsdk:"hostname" tf:"optional"` @@ -1522,6 +2068,12 @@ type OdbcParams struct { Protocol types.String `tfsdk:"protocol" tf:"optional"` } +func (newState *OdbcParams) SyncEffectiveFieldsDuringCreateOrUpdate(plan OdbcParams) { +} + +func (newState *OdbcParams) SyncEffectiveFieldsDuringRead(existingState OdbcParams) { +} + type Parameter struct { // List of valid parameter values, newline delimited. Only applies for // dropdown list parameters. @@ -1543,6 +2095,12 @@ type Parameter struct { Value any `tfsdk:"value" tf:"optional"` } +func (newState *Parameter) SyncEffectiveFieldsDuringCreateOrUpdate(plan Parameter) { +} + +func (newState *Parameter) SyncEffectiveFieldsDuringRead(existingState Parameter) { +} + type Query struct { // Whether to apply a 1000 row limit to the query result. ApplyAutoLimit types.Bool `tfsdk:"apply_auto_limit" tf:"optional"` @@ -1582,6 +2140,12 @@ type Query struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *Query) SyncEffectiveFieldsDuringCreateOrUpdate(plan Query) { +} + +func (newState *Query) SyncEffectiveFieldsDuringRead(existingState Query) { +} + type QueryBackedValue struct { // If specified, allows multiple values to be selected for this parameter. MultiValuesOptions []MultiValuesOptions `tfsdk:"multi_values_options" tf:"optional,object"` @@ -1591,6 +2155,12 @@ type QueryBackedValue struct { Values []types.String `tfsdk:"values" tf:"optional"` } +func (newState *QueryBackedValue) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryBackedValue) { +} + +func (newState *QueryBackedValue) SyncEffectiveFieldsDuringRead(existingState QueryBackedValue) { +} + type QueryEditContent struct { // Data source ID maps to the ID of the data source used by the resource and // is distinct from the warehouse ID. [Learn more] @@ -1619,6 +2189,12 @@ type QueryEditContent struct { Tags []types.String `tfsdk:"tags" tf:"optional"` } +func (newState *QueryEditContent) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryEditContent) { +} + +func (newState *QueryEditContent) SyncEffectiveFieldsDuringRead(existingState QueryEditContent) { +} + type QueryFilter struct { // A range filter for query submitted time. The time range must be <= 30 // days. @@ -1633,6 +2209,12 @@ type QueryFilter struct { WarehouseIds []types.String `tfsdk:"warehouse_ids" tf:"optional"` } +func (newState *QueryFilter) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryFilter) { +} + +func (newState *QueryFilter) SyncEffectiveFieldsDuringRead(existingState QueryFilter) { +} + type QueryInfo struct { // SQL Warehouse channel information at the time of query execution ChannelUsed []ChannelInfo `tfsdk:"channel_used" tf:"optional,object"` @@ -1685,6 +2267,12 @@ type QueryInfo struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *QueryInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryInfo) { +} + +func (newState *QueryInfo) SyncEffectiveFieldsDuringRead(existingState QueryInfo) { +} + type QueryList struct { // The total number of queries. Count types.Int64 `tfsdk:"count" tf:"optional"` @@ -1696,6 +2284,12 @@ type QueryList struct { Results []LegacyQuery `tfsdk:"results" tf:"optional"` } +func (newState *QueryList) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryList) { +} + +func (newState *QueryList) SyncEffectiveFieldsDuringRead(existingState QueryList) { +} + // A query metric that encapsulates a set of measurements for a single query. // Metrics come from the driver and are stored in the history service database. type QueryMetrics struct { @@ -1757,6 +2351,12 @@ type QueryMetrics struct { WriteRemoteBytes types.Int64 `tfsdk:"write_remote_bytes" tf:"optional"` } +func (newState *QueryMetrics) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryMetrics) { +} + +func (newState *QueryMetrics) SyncEffectiveFieldsDuringRead(existingState QueryMetrics) { +} + type QueryOptions struct { // The name of the catalog to execute this query in. Catalog types.String `tfsdk:"catalog" tf:"optional"` @@ -1770,6 +2370,12 @@ type QueryOptions struct { Schema types.String `tfsdk:"schema" tf:"optional"` } +func (newState *QueryOptions) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryOptions) { +} + +func (newState *QueryOptions) SyncEffectiveFieldsDuringRead(existingState QueryOptions) { +} + type QueryParameter struct { // Date-range query parameter value. Can only specify one of // `dynamic_date_range_value` or `date_range_value`. @@ -1792,6 +2398,12 @@ type QueryParameter struct { Title types.String `tfsdk:"title" tf:"optional"` } +func (newState *QueryParameter) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryParameter) { +} + +func (newState *QueryParameter) SyncEffectiveFieldsDuringRead(existingState QueryParameter) { +} + type QueryPostContent struct { // Data source ID maps to the ID of the data source used by the resource and // is distinct from the warehouse ID. [Learn more] @@ -1820,6 +2432,12 @@ type QueryPostContent struct { Tags []types.String `tfsdk:"tags" tf:"optional"` } +func (newState *QueryPostContent) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryPostContent) { +} + +func (newState *QueryPostContent) SyncEffectiveFieldsDuringRead(existingState QueryPostContent) { +} + type RepeatedEndpointConfPairs struct { // Deprecated: Use configuration_pairs ConfigPair []EndpointConfPair `tfsdk:"config_pair" tf:"optional"` @@ -1827,19 +2445,43 @@ type RepeatedEndpointConfPairs struct { ConfigurationPairs []EndpointConfPair `tfsdk:"configuration_pairs" tf:"optional"` } +func (newState *RepeatedEndpointConfPairs) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepeatedEndpointConfPairs) { +} + +func (newState *RepeatedEndpointConfPairs) SyncEffectiveFieldsDuringRead(existingState RepeatedEndpointConfPairs) { +} + // Restore a dashboard type RestoreDashboardRequest struct { DashboardId types.String `tfsdk:"-"` } +func (newState *RestoreDashboardRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestoreDashboardRequest) { +} + +func (newState *RestoreDashboardRequest) SyncEffectiveFieldsDuringRead(existingState RestoreDashboardRequest) { +} + // Restore a query type RestoreQueriesLegacyRequest struct { QueryId types.String `tfsdk:"-"` } +func (newState *RestoreQueriesLegacyRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestoreQueriesLegacyRequest) { +} + +func (newState *RestoreQueriesLegacyRequest) SyncEffectiveFieldsDuringRead(existingState RestoreQueriesLegacyRequest) { +} + type RestoreResponse struct { } +func (newState *RestoreResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RestoreResponse) { +} + +func (newState *RestoreResponse) SyncEffectiveFieldsDuringRead(existingState RestoreResponse) { +} + type ResultData struct { // The number of bytes in the result chunk. This field is not available when // using `INLINE` disposition. @@ -1867,6 +2509,12 @@ type ResultData struct { RowOffset types.Int64 `tfsdk:"row_offset" tf:"optional"` } +func (newState *ResultData) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResultData) { +} + +func (newState *ResultData) SyncEffectiveFieldsDuringRead(existingState ResultData) { +} + // The result manifest provides schema and metadata for the result set. type ResultManifest struct { // Array of result set chunk metadata. @@ -1887,6 +2535,12 @@ type ResultManifest struct { Truncated types.Bool `tfsdk:"truncated" tf:"optional"` } +func (newState *ResultManifest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResultManifest) { +} + +func (newState *ResultManifest) SyncEffectiveFieldsDuringRead(existingState ResultManifest) { +} + // The schema is an ordered list of column descriptions. type ResultSchema struct { ColumnCount types.Int64 `tfsdk:"column_count" tf:"optional"` @@ -1894,12 +2548,24 @@ type ResultSchema struct { Columns []ColumnInfo `tfsdk:"columns" tf:"optional"` } +func (newState *ResultSchema) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResultSchema) { +} + +func (newState *ResultSchema) SyncEffectiveFieldsDuringRead(existingState ResultSchema) { +} + type ServiceError struct { ErrorCode types.String `tfsdk:"error_code" tf:"optional"` // A brief summary of the error condition. Message types.String `tfsdk:"message" tf:"optional"` } +func (newState *ServiceError) SyncEffectiveFieldsDuringCreateOrUpdate(plan ServiceError) { +} + +func (newState *ServiceError) SyncEffectiveFieldsDuringRead(existingState ServiceError) { +} + // Set object ACL type SetRequest struct { AccessControlList []AccessControl `tfsdk:"access_control_list" tf:"optional"` @@ -1910,6 +2576,12 @@ type SetRequest struct { ObjectType types.String `tfsdk:"-"` } +func (newState *SetRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetRequest) { +} + +func (newState *SetRequest) SyncEffectiveFieldsDuringRead(existingState SetRequest) { +} + type SetResponse struct { AccessControlList []AccessControl `tfsdk:"access_control_list" tf:"optional"` // An object's type and UUID, separated by a forward slash (/) character. @@ -1918,6 +2590,12 @@ type SetResponse struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *SetResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetResponse) { +} + +func (newState *SetResponse) SyncEffectiveFieldsDuringRead(existingState SetResponse) { +} + type SetWorkspaceWarehouseConfigRequest struct { // Optional: Channel selection details Channel []Channel `tfsdk:"channel" tf:"optional,object"` @@ -1946,18 +2624,42 @@ type SetWorkspaceWarehouseConfigRequest struct { SqlConfigurationParameters []RepeatedEndpointConfPairs `tfsdk:"sql_configuration_parameters" tf:"optional,object"` } +func (newState *SetWorkspaceWarehouseConfigRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetWorkspaceWarehouseConfigRequest) { +} + +func (newState *SetWorkspaceWarehouseConfigRequest) SyncEffectiveFieldsDuringRead(existingState SetWorkspaceWarehouseConfigRequest) { +} + type SetWorkspaceWarehouseConfigResponse struct { } +func (newState *SetWorkspaceWarehouseConfigResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SetWorkspaceWarehouseConfigResponse) { +} + +func (newState *SetWorkspaceWarehouseConfigResponse) SyncEffectiveFieldsDuringRead(existingState SetWorkspaceWarehouseConfigResponse) { +} + // Start a warehouse type StartRequest struct { // Required. Id of the SQL warehouse. Id types.String `tfsdk:"-"` } +func (newState *StartRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan StartRequest) { +} + +func (newState *StartRequest) SyncEffectiveFieldsDuringRead(existingState StartRequest) { +} + type StartWarehouseResponse struct { } +func (newState *StartWarehouseResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan StartWarehouseResponse) { +} + +func (newState *StartWarehouseResponse) SyncEffectiveFieldsDuringRead(existingState StartWarehouseResponse) { +} + type StatementParameterListItem struct { // The name of a parameter marker to be substituted in the statement. Name types.String `tfsdk:"name" tf:""` @@ -1974,6 +2676,12 @@ type StatementParameterListItem struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *StatementParameterListItem) SyncEffectiveFieldsDuringCreateOrUpdate(plan StatementParameterListItem) { +} + +func (newState *StatementParameterListItem) SyncEffectiveFieldsDuringRead(existingState StatementParameterListItem) { +} + type StatementResponse struct { // The result manifest provides schema and metadata for the result set. Manifest []ResultManifest `tfsdk:"manifest" tf:"optional,object"` @@ -1987,6 +2695,12 @@ type StatementResponse struct { Status []StatementStatus `tfsdk:"status" tf:"optional,object"` } +func (newState *StatementResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan StatementResponse) { +} + +func (newState *StatementResponse) SyncEffectiveFieldsDuringRead(existingState StatementResponse) { +} + // The status response includes execution state and if relevant, error // information. type StatementStatus struct { @@ -2001,19 +2715,43 @@ type StatementStatus struct { State types.String `tfsdk:"state" tf:"optional"` } +func (newState *StatementStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan StatementStatus) { +} + +func (newState *StatementStatus) SyncEffectiveFieldsDuringRead(existingState StatementStatus) { +} + // Stop a warehouse type StopRequest struct { // Required. Id of the SQL warehouse. Id types.String `tfsdk:"-"` } +func (newState *StopRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan StopRequest) { +} + +func (newState *StopRequest) SyncEffectiveFieldsDuringRead(existingState StopRequest) { +} + type StopWarehouseResponse struct { } +func (newState *StopWarehouseResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan StopWarehouseResponse) { +} + +func (newState *StopWarehouseResponse) SyncEffectiveFieldsDuringRead(existingState StopWarehouseResponse) { +} + type Success struct { Message types.String `tfsdk:"message" tf:"optional"` } +func (newState *Success) SyncEffectiveFieldsDuringCreateOrUpdate(plan Success) { +} + +func (newState *Success) SyncEffectiveFieldsDuringRead(existingState Success) { +} + type TerminationReason struct { // status code indicating why the cluster was terminated Code types.String `tfsdk:"code" tf:"optional"` @@ -2024,10 +2762,22 @@ type TerminationReason struct { Type types.String `tfsdk:"type" tf:"optional"` } +func (newState *TerminationReason) SyncEffectiveFieldsDuringCreateOrUpdate(plan TerminationReason) { +} + +func (newState *TerminationReason) SyncEffectiveFieldsDuringRead(existingState TerminationReason) { +} + type TextValue struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *TextValue) SyncEffectiveFieldsDuringCreateOrUpdate(plan TextValue) { +} + +func (newState *TextValue) SyncEffectiveFieldsDuringRead(existingState TextValue) { +} + type TimeRange struct { // The end time in milliseconds. EndTimeMs types.Int64 `tfsdk:"end_time_ms" tf:"optional"` @@ -2035,11 +2785,23 @@ type TimeRange struct { StartTimeMs types.Int64 `tfsdk:"start_time_ms" tf:"optional"` } +func (newState *TimeRange) SyncEffectiveFieldsDuringCreateOrUpdate(plan TimeRange) { +} + +func (newState *TimeRange) SyncEffectiveFieldsDuringRead(existingState TimeRange) { +} + type TransferOwnershipObjectId struct { // Email address for the new owner, who must exist in the workspace. NewOwner types.String `tfsdk:"new_owner" tf:"optional"` } +func (newState *TransferOwnershipObjectId) SyncEffectiveFieldsDuringCreateOrUpdate(plan TransferOwnershipObjectId) { +} + +func (newState *TransferOwnershipObjectId) SyncEffectiveFieldsDuringRead(existingState TransferOwnershipObjectId) { +} + // Transfer object ownership type TransferOwnershipRequest struct { // Email address for the new owner, who must exist in the workspace. @@ -2050,16 +2812,34 @@ type TransferOwnershipRequest struct { ObjectType types.String `tfsdk:"-"` } +func (newState *TransferOwnershipRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan TransferOwnershipRequest) { +} + +func (newState *TransferOwnershipRequest) SyncEffectiveFieldsDuringRead(existingState TransferOwnershipRequest) { +} + // Delete an alert type TrashAlertRequest struct { Id types.String `tfsdk:"-"` } +func (newState *TrashAlertRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan TrashAlertRequest) { +} + +func (newState *TrashAlertRequest) SyncEffectiveFieldsDuringRead(existingState TrashAlertRequest) { +} + // Delete a query type TrashQueryRequest struct { Id types.String `tfsdk:"-"` } +func (newState *TrashQueryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan TrashQueryRequest) { +} + +func (newState *TrashQueryRequest) SyncEffectiveFieldsDuringRead(existingState TrashQueryRequest) { +} + type UpdateAlertRequest struct { Alert []UpdateAlertRequestAlert `tfsdk:"alert" tf:"optional,object"` @@ -2071,6 +2851,12 @@ type UpdateAlertRequest struct { UpdateMask types.String `tfsdk:"update_mask" tf:""` } +func (newState *UpdateAlertRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateAlertRequest) { +} + +func (newState *UpdateAlertRequest) SyncEffectiveFieldsDuringRead(existingState UpdateAlertRequest) { +} + type UpdateAlertRequestAlert struct { // Trigger conditions of the alert. Condition []AlertCondition `tfsdk:"condition" tf:"optional,object"` @@ -2087,6 +2873,8 @@ type UpdateAlertRequestAlert struct { CustomSubject types.String `tfsdk:"custom_subject" tf:"optional"` // The display name of the alert. DisplayName types.String `tfsdk:"display_name" tf:"optional"` + // Whether to notify alert subscribers when alert returns back to normal. + NotifyOnOk types.Bool `tfsdk:"notify_on_ok" tf:"optional"` // The owner's username. This field is set to "Unavailable" if the user has // been deleted. OwnerUserName types.String `tfsdk:"owner_user_name" tf:"optional"` @@ -2098,6 +2886,12 @@ type UpdateAlertRequestAlert struct { SecondsToRetrigger types.Int64 `tfsdk:"seconds_to_retrigger" tf:"optional"` } +func (newState *UpdateAlertRequestAlert) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateAlertRequestAlert) { +} + +func (newState *UpdateAlertRequestAlert) SyncEffectiveFieldsDuringRead(existingState UpdateAlertRequestAlert) { +} + type UpdateQueryRequest struct { Id types.String `tfsdk:"-"` @@ -2109,6 +2903,12 @@ type UpdateQueryRequest struct { UpdateMask types.String `tfsdk:"update_mask" tf:""` } +func (newState *UpdateQueryRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateQueryRequest) { +} + +func (newState *UpdateQueryRequest) SyncEffectiveFieldsDuringRead(existingState UpdateQueryRequest) { +} + type UpdateQueryRequestQuery struct { // Whether to apply a 1000 row limit to the query result. ApplyAutoLimit types.Bool `tfsdk:"apply_auto_limit" tf:"optional"` @@ -2136,9 +2936,21 @@ type UpdateQueryRequestQuery struct { WarehouseId types.String `tfsdk:"warehouse_id" tf:"optional"` } +func (newState *UpdateQueryRequestQuery) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateQueryRequestQuery) { +} + +func (newState *UpdateQueryRequestQuery) SyncEffectiveFieldsDuringRead(existingState UpdateQueryRequestQuery) { +} + type UpdateResponse struct { } +func (newState *UpdateResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateResponse) { +} + +func (newState *UpdateResponse) SyncEffectiveFieldsDuringRead(existingState UpdateResponse) { +} + type UpdateVisualizationRequest struct { Id types.String `tfsdk:"-"` // Field mask is required to be passed into the PATCH request. Field mask @@ -2150,6 +2962,12 @@ type UpdateVisualizationRequest struct { Visualization []UpdateVisualizationRequestVisualization `tfsdk:"visualization" tf:"optional,object"` } +func (newState *UpdateVisualizationRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateVisualizationRequest) { +} + +func (newState *UpdateVisualizationRequest) SyncEffectiveFieldsDuringRead(existingState UpdateVisualizationRequest) { +} + type UpdateVisualizationRequestVisualization struct { // The display name of the visualization. DisplayName types.String `tfsdk:"display_name" tf:"optional"` @@ -2165,6 +2983,12 @@ type UpdateVisualizationRequestVisualization struct { Type types.String `tfsdk:"type" tf:"optional"` } +func (newState *UpdateVisualizationRequestVisualization) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateVisualizationRequestVisualization) { +} + +func (newState *UpdateVisualizationRequestVisualization) SyncEffectiveFieldsDuringRead(existingState UpdateVisualizationRequestVisualization) { +} + type User struct { Email types.String `tfsdk:"email" tf:"optional"` @@ -2173,6 +2997,12 @@ type User struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *User) SyncEffectiveFieldsDuringCreateOrUpdate(plan User) { +} + +func (newState *User) SyncEffectiveFieldsDuringRead(existingState User) { +} + type Visualization struct { // The timestamp indicating when the visualization was created. CreateTime types.String `tfsdk:"create_time" tf:"optional"` @@ -2196,6 +3026,12 @@ type Visualization struct { UpdateTime types.String `tfsdk:"update_time" tf:"optional"` } +func (newState *Visualization) SyncEffectiveFieldsDuringCreateOrUpdate(plan Visualization) { +} + +func (newState *Visualization) SyncEffectiveFieldsDuringRead(existingState Visualization) { +} + type WarehouseAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -2207,6 +3043,12 @@ type WarehouseAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *WarehouseAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan WarehouseAccessControlRequest) { +} + +func (newState *WarehouseAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState WarehouseAccessControlRequest) { +} + type WarehouseAccessControlResponse struct { // All permissions. AllPermissions []WarehousePermission `tfsdk:"all_permissions" tf:"optional"` @@ -2220,6 +3062,12 @@ type WarehouseAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *WarehouseAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan WarehouseAccessControlResponse) { +} + +func (newState *WarehouseAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState WarehouseAccessControlResponse) { +} + type WarehousePermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -2228,6 +3076,12 @@ type WarehousePermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *WarehousePermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan WarehousePermission) { +} + +func (newState *WarehousePermission) SyncEffectiveFieldsDuringRead(existingState WarehousePermission) { +} + type WarehousePermissions struct { AccessControlList []WarehouseAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -2236,18 +3090,36 @@ type WarehousePermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *WarehousePermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan WarehousePermissions) { +} + +func (newState *WarehousePermissions) SyncEffectiveFieldsDuringRead(existingState WarehousePermissions) { +} + type WarehousePermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *WarehousePermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan WarehousePermissionsDescription) { +} + +func (newState *WarehousePermissionsDescription) SyncEffectiveFieldsDuringRead(existingState WarehousePermissionsDescription) { +} + type WarehousePermissionsRequest struct { AccessControlList []WarehouseAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The SQL warehouse for which to get or manage permissions. WarehouseId types.String `tfsdk:"-"` } +func (newState *WarehousePermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan WarehousePermissionsRequest) { +} + +func (newState *WarehousePermissionsRequest) SyncEffectiveFieldsDuringRead(existingState WarehousePermissionsRequest) { +} + type WarehouseTypePair struct { // If set to false the specific warehouse type will not be be allowed as a // value for warehouse_type in CreateWarehouse and EditWarehouse @@ -2256,6 +3128,12 @@ type WarehouseTypePair struct { WarehouseType types.String `tfsdk:"warehouse_type" tf:"optional"` } +func (newState *WarehouseTypePair) SyncEffectiveFieldsDuringCreateOrUpdate(plan WarehouseTypePair) { +} + +func (newState *WarehouseTypePair) SyncEffectiveFieldsDuringRead(existingState WarehouseTypePair) { +} + type Widget struct { // The unique ID for this widget. Id types.String `tfsdk:"id" tf:"optional"` @@ -2271,6 +3149,12 @@ type Widget struct { Width types.Int64 `tfsdk:"width" tf:"optional"` } +func (newState *Widget) SyncEffectiveFieldsDuringCreateOrUpdate(plan Widget) { +} + +func (newState *Widget) SyncEffectiveFieldsDuringRead(existingState Widget) { +} + type WidgetOptions struct { // Timestamp when this object was created CreatedAt types.String `tfsdk:"created_at" tf:"optional"` @@ -2291,6 +3175,12 @@ type WidgetOptions struct { UpdatedAt types.String `tfsdk:"updated_at" tf:"optional"` } +func (newState *WidgetOptions) SyncEffectiveFieldsDuringCreateOrUpdate(plan WidgetOptions) { +} + +func (newState *WidgetOptions) SyncEffectiveFieldsDuringRead(existingState WidgetOptions) { +} + // Coordinates of this widget on a dashboard. This portion of the API changes // frequently and is unsupported. type WidgetPosition struct { @@ -2305,3 +3195,9 @@ type WidgetPosition struct { // height of the widget measured in dashboard grid cells SizeY types.Int64 `tfsdk:"sizeY" tf:"optional"` } + +func (newState *WidgetPosition) SyncEffectiveFieldsDuringCreateOrUpdate(plan WidgetPosition) { +} + +func (newState *WidgetPosition) SyncEffectiveFieldsDuringRead(existingState WidgetPosition) { +} diff --git a/internal/service/vectorsearch_tf/model.go b/internal/service/vectorsearch_tf/model.go index e0590e7ad9..4c35584942 100755 --- a/internal/service/vectorsearch_tf/model.go +++ b/internal/service/vectorsearch_tf/model.go @@ -19,6 +19,12 @@ type ColumnInfo struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *ColumnInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ColumnInfo) { +} + +func (newState *ColumnInfo) SyncEffectiveFieldsDuringRead(existingState ColumnInfo) { +} + type CreateEndpoint struct { // Type of endpoint. EndpointType types.String `tfsdk:"endpoint_type" tf:""` @@ -26,6 +32,12 @@ type CreateEndpoint struct { Name types.String `tfsdk:"name" tf:""` } +func (newState *CreateEndpoint) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateEndpoint) { +} + +func (newState *CreateEndpoint) SyncEffectiveFieldsDuringRead(existingState CreateEndpoint) { +} + type CreateVectorIndexRequest struct { // Specification for Delta Sync Index. Required if `index_type` is // `DELTA_SYNC`. @@ -49,10 +61,22 @@ type CreateVectorIndexRequest struct { PrimaryKey types.String `tfsdk:"primary_key" tf:""` } +func (newState *CreateVectorIndexRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateVectorIndexRequest) { +} + +func (newState *CreateVectorIndexRequest) SyncEffectiveFieldsDuringRead(existingState CreateVectorIndexRequest) { +} + type CreateVectorIndexResponse struct { VectorIndex []VectorIndex `tfsdk:"vector_index" tf:"optional,object"` } +func (newState *CreateVectorIndexResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateVectorIndexResponse) { +} + +func (newState *CreateVectorIndexResponse) SyncEffectiveFieldsDuringRead(existingState CreateVectorIndexResponse) { +} + // Result of the upsert or delete operation. type DeleteDataResult struct { // List of primary keys for rows that failed to process. @@ -61,6 +85,12 @@ type DeleteDataResult struct { SuccessRowCount types.Int64 `tfsdk:"success_row_count" tf:"optional"` } +func (newState *DeleteDataResult) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDataResult) { +} + +func (newState *DeleteDataResult) SyncEffectiveFieldsDuringRead(existingState DeleteDataResult) { +} + // Request payload for deleting data from a vector index. type DeleteDataVectorIndexRequest struct { // Name of the vector index where data is to be deleted. Must be a Direct @@ -70,6 +100,12 @@ type DeleteDataVectorIndexRequest struct { PrimaryKeys []types.String `tfsdk:"primary_keys" tf:""` } +func (newState *DeleteDataVectorIndexRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDataVectorIndexRequest) { +} + +func (newState *DeleteDataVectorIndexRequest) SyncEffectiveFieldsDuringRead(existingState DeleteDataVectorIndexRequest) { +} + // Response to a delete data vector index request. type DeleteDataVectorIndexResponse struct { // Result of the upsert or delete operation. @@ -78,24 +114,54 @@ type DeleteDataVectorIndexResponse struct { Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *DeleteDataVectorIndexResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteDataVectorIndexResponse) { +} + +func (newState *DeleteDataVectorIndexResponse) SyncEffectiveFieldsDuringRead(existingState DeleteDataVectorIndexResponse) { +} + // Delete an endpoint type DeleteEndpointRequest struct { // Name of the endpoint EndpointName types.String `tfsdk:"-"` } +func (newState *DeleteEndpointRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteEndpointRequest) { +} + +func (newState *DeleteEndpointRequest) SyncEffectiveFieldsDuringRead(existingState DeleteEndpointRequest) { +} + type DeleteEndpointResponse struct { } +func (newState *DeleteEndpointResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteEndpointResponse) { +} + +func (newState *DeleteEndpointResponse) SyncEffectiveFieldsDuringRead(existingState DeleteEndpointResponse) { +} + // Delete an index type DeleteIndexRequest struct { // Name of the index IndexName types.String `tfsdk:"-"` } +func (newState *DeleteIndexRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteIndexRequest) { +} + +func (newState *DeleteIndexRequest) SyncEffectiveFieldsDuringRead(existingState DeleteIndexRequest) { +} + type DeleteIndexResponse struct { } +func (newState *DeleteIndexResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteIndexResponse) { +} + +func (newState *DeleteIndexResponse) SyncEffectiveFieldsDuringRead(existingState DeleteIndexResponse) { +} + type DeltaSyncVectorIndexSpecRequest struct { // [Optional] Select the columns to sync with the vector index. If you leave // this field blank, all columns from the source table are synced with the @@ -124,6 +190,12 @@ type DeltaSyncVectorIndexSpecRequest struct { SourceTable types.String `tfsdk:"source_table" tf:"optional"` } +func (newState *DeltaSyncVectorIndexSpecRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeltaSyncVectorIndexSpecRequest) { +} + +func (newState *DeltaSyncVectorIndexSpecRequest) SyncEffectiveFieldsDuringRead(existingState DeltaSyncVectorIndexSpecRequest) { +} + type DeltaSyncVectorIndexSpecResponse struct { // The columns that contain the embedding source. EmbeddingSourceColumns []EmbeddingSourceColumn `tfsdk:"embedding_source_columns" tf:"optional"` @@ -147,6 +219,12 @@ type DeltaSyncVectorIndexSpecResponse struct { SourceTable types.String `tfsdk:"source_table" tf:"optional"` } +func (newState *DeltaSyncVectorIndexSpecResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeltaSyncVectorIndexSpecResponse) { +} + +func (newState *DeltaSyncVectorIndexSpecResponse) SyncEffectiveFieldsDuringRead(existingState DeltaSyncVectorIndexSpecResponse) { +} + type DirectAccessVectorIndexSpec struct { // Contains the optional model endpoint to use during query time. EmbeddingSourceColumns []EmbeddingSourceColumn `tfsdk:"embedding_source_columns" tf:"optional"` @@ -161,6 +239,12 @@ type DirectAccessVectorIndexSpec struct { SchemaJson types.String `tfsdk:"schema_json" tf:"optional"` } +func (newState *DirectAccessVectorIndexSpec) SyncEffectiveFieldsDuringCreateOrUpdate(plan DirectAccessVectorIndexSpec) { +} + +func (newState *DirectAccessVectorIndexSpec) SyncEffectiveFieldsDuringRead(existingState DirectAccessVectorIndexSpec) { +} + type EmbeddingSourceColumn struct { // Name of the embedding model endpoint EmbeddingModelEndpointName types.String `tfsdk:"embedding_model_endpoint_name" tf:"optional"` @@ -168,6 +252,12 @@ type EmbeddingSourceColumn struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *EmbeddingSourceColumn) SyncEffectiveFieldsDuringCreateOrUpdate(plan EmbeddingSourceColumn) { +} + +func (newState *EmbeddingSourceColumn) SyncEffectiveFieldsDuringRead(existingState EmbeddingSourceColumn) { +} + type EmbeddingVectorColumn struct { // Dimension of the embedding vector EmbeddingDimension types.Int64 `tfsdk:"embedding_dimension" tf:"optional"` @@ -175,6 +265,12 @@ type EmbeddingVectorColumn struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *EmbeddingVectorColumn) SyncEffectiveFieldsDuringCreateOrUpdate(plan EmbeddingVectorColumn) { +} + +func (newState *EmbeddingVectorColumn) SyncEffectiveFieldsDuringRead(existingState EmbeddingVectorColumn) { +} + type EndpointInfo struct { // Timestamp of endpoint creation CreationTimestamp types.Int64 `tfsdk:"creation_timestamp" tf:"optional"` @@ -196,6 +292,12 @@ type EndpointInfo struct { NumIndexes types.Int64 `tfsdk:"num_indexes" tf:"optional"` } +func (newState *EndpointInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointInfo) { +} + +func (newState *EndpointInfo) SyncEffectiveFieldsDuringRead(existingState EndpointInfo) { +} + // Status information of an endpoint type EndpointStatus struct { // Additional status message @@ -204,18 +306,36 @@ type EndpointStatus struct { State types.String `tfsdk:"state" tf:"optional"` } +func (newState *EndpointStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan EndpointStatus) { +} + +func (newState *EndpointStatus) SyncEffectiveFieldsDuringRead(existingState EndpointStatus) { +} + // Get an endpoint type GetEndpointRequest struct { // Name of the endpoint EndpointName types.String `tfsdk:"-"` } +func (newState *GetEndpointRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetEndpointRequest) { +} + +func (newState *GetEndpointRequest) SyncEffectiveFieldsDuringRead(existingState GetEndpointRequest) { +} + // Get an index type GetIndexRequest struct { // Name of the index IndexName types.String `tfsdk:"-"` } +func (newState *GetIndexRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetIndexRequest) { +} + +func (newState *GetIndexRequest) SyncEffectiveFieldsDuringRead(existingState GetIndexRequest) { +} + type ListEndpointResponse struct { // An array of Endpoint objects Endpoints []EndpointInfo `tfsdk:"endpoints" tf:"optional"` @@ -224,12 +344,24 @@ type ListEndpointResponse struct { NextPageToken types.String `tfsdk:"next_page_token" tf:"optional"` } +func (newState *ListEndpointResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListEndpointResponse) { +} + +func (newState *ListEndpointResponse) SyncEffectiveFieldsDuringRead(existingState ListEndpointResponse) { +} + // List all endpoints type ListEndpointsRequest struct { // Token for pagination PageToken types.String `tfsdk:"-"` } +func (newState *ListEndpointsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListEndpointsRequest) { +} + +func (newState *ListEndpointsRequest) SyncEffectiveFieldsDuringRead(existingState ListEndpointsRequest) { +} + // List indexes type ListIndexesRequest struct { // Name of the endpoint @@ -238,10 +370,22 @@ type ListIndexesRequest struct { PageToken types.String `tfsdk:"-"` } +func (newState *ListIndexesRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListIndexesRequest) { +} + +func (newState *ListIndexesRequest) SyncEffectiveFieldsDuringRead(existingState ListIndexesRequest) { +} + type ListValue struct { Values []Value `tfsdk:"values" tf:"optional"` } +func (newState *ListValue) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListValue) { +} + +func (newState *ListValue) SyncEffectiveFieldsDuringRead(existingState ListValue) { +} + type ListVectorIndexesResponse struct { // A token that can be used to get the next page of results. If not present, // there are no more results to show. @@ -250,6 +394,12 @@ type ListVectorIndexesResponse struct { VectorIndexes []MiniVectorIndex `tfsdk:"vector_indexes" tf:"optional"` } +func (newState *ListVectorIndexesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListVectorIndexesResponse) { +} + +func (newState *ListVectorIndexesResponse) SyncEffectiveFieldsDuringRead(existingState ListVectorIndexesResponse) { +} + // Key-value pair. type MapStringValueEntry struct { // Column name. @@ -258,6 +408,12 @@ type MapStringValueEntry struct { Value []Value `tfsdk:"value" tf:"optional,object"` } +func (newState *MapStringValueEntry) SyncEffectiveFieldsDuringCreateOrUpdate(plan MapStringValueEntry) { +} + +func (newState *MapStringValueEntry) SyncEffectiveFieldsDuringRead(existingState MapStringValueEntry) { +} + type MiniVectorIndex struct { // The user who created the index. Creator types.String `tfsdk:"creator" tf:"optional"` @@ -277,6 +433,12 @@ type MiniVectorIndex struct { PrimaryKey types.String `tfsdk:"primary_key" tf:"optional"` } +func (newState *MiniVectorIndex) SyncEffectiveFieldsDuringCreateOrUpdate(plan MiniVectorIndex) { +} + +func (newState *MiniVectorIndex) SyncEffectiveFieldsDuringRead(existingState MiniVectorIndex) { +} + // Request payload for getting next page of results. type QueryVectorIndexNextPageRequest struct { // Name of the endpoint. @@ -288,6 +450,12 @@ type QueryVectorIndexNextPageRequest struct { PageToken types.String `tfsdk:"page_token" tf:"optional"` } +func (newState *QueryVectorIndexNextPageRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryVectorIndexNextPageRequest) { +} + +func (newState *QueryVectorIndexNextPageRequest) SyncEffectiveFieldsDuringRead(existingState QueryVectorIndexNextPageRequest) { +} + type QueryVectorIndexRequest struct { // List of column names to include in the response. Columns []types.String `tfsdk:"columns" tf:""` @@ -313,6 +481,12 @@ type QueryVectorIndexRequest struct { ScoreThreshold types.Float64 `tfsdk:"score_threshold" tf:"optional"` } +func (newState *QueryVectorIndexRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryVectorIndexRequest) { +} + +func (newState *QueryVectorIndexRequest) SyncEffectiveFieldsDuringRead(existingState QueryVectorIndexRequest) { +} + type QueryVectorIndexResponse struct { // Metadata about the result set. Manifest []ResultManifest `tfsdk:"manifest" tf:"optional,object"` @@ -324,6 +498,12 @@ type QueryVectorIndexResponse struct { Result []ResultData `tfsdk:"result" tf:"optional,object"` } +func (newState *QueryVectorIndexResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan QueryVectorIndexResponse) { +} + +func (newState *QueryVectorIndexResponse) SyncEffectiveFieldsDuringRead(existingState QueryVectorIndexResponse) { +} + // Data returned in the query result. type ResultData struct { // Data rows returned in the query. @@ -332,6 +512,12 @@ type ResultData struct { RowCount types.Int64 `tfsdk:"row_count" tf:"optional"` } +func (newState *ResultData) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResultData) { +} + +func (newState *ResultData) SyncEffectiveFieldsDuringRead(existingState ResultData) { +} + // Metadata about the result set. type ResultManifest struct { // Number of columns in the result set. @@ -340,6 +526,12 @@ type ResultManifest struct { Columns []ColumnInfo `tfsdk:"columns" tf:"optional"` } +func (newState *ResultManifest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ResultManifest) { +} + +func (newState *ResultManifest) SyncEffectiveFieldsDuringRead(existingState ResultManifest) { +} + // Request payload for scanning data from a vector index. type ScanVectorIndexRequest struct { // Name of the vector index to scan. @@ -350,6 +542,12 @@ type ScanVectorIndexRequest struct { NumResults types.Int64 `tfsdk:"num_results" tf:"optional"` } +func (newState *ScanVectorIndexRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ScanVectorIndexRequest) { +} + +func (newState *ScanVectorIndexRequest) SyncEffectiveFieldsDuringRead(existingState ScanVectorIndexRequest) { +} + // Response to a scan vector index request. type ScanVectorIndexResponse struct { // List of data entries @@ -358,20 +556,44 @@ type ScanVectorIndexResponse struct { LastPrimaryKey types.String `tfsdk:"last_primary_key" tf:"optional"` } +func (newState *ScanVectorIndexResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ScanVectorIndexResponse) { +} + +func (newState *ScanVectorIndexResponse) SyncEffectiveFieldsDuringRead(existingState ScanVectorIndexResponse) { +} + type Struct struct { // Data entry, corresponding to a row in a vector index. Fields []MapStringValueEntry `tfsdk:"fields" tf:"optional"` } +func (newState *Struct) SyncEffectiveFieldsDuringCreateOrUpdate(plan Struct) { +} + +func (newState *Struct) SyncEffectiveFieldsDuringRead(existingState Struct) { +} + // Synchronize an index type SyncIndexRequest struct { // Name of the vector index to synchronize. Must be a Delta Sync Index. IndexName types.String `tfsdk:"-"` } +func (newState *SyncIndexRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan SyncIndexRequest) { +} + +func (newState *SyncIndexRequest) SyncEffectiveFieldsDuringRead(existingState SyncIndexRequest) { +} + type SyncIndexResponse struct { } +func (newState *SyncIndexResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan SyncIndexResponse) { +} + +func (newState *SyncIndexResponse) SyncEffectiveFieldsDuringRead(existingState SyncIndexResponse) { +} + // Result of the upsert or delete operation. type UpsertDataResult struct { // List of primary keys for rows that failed to process. @@ -380,6 +602,12 @@ type UpsertDataResult struct { SuccessRowCount types.Int64 `tfsdk:"success_row_count" tf:"optional"` } +func (newState *UpsertDataResult) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpsertDataResult) { +} + +func (newState *UpsertDataResult) SyncEffectiveFieldsDuringRead(existingState UpsertDataResult) { +} + // Request payload for upserting data into a vector index. type UpsertDataVectorIndexRequest struct { // Name of the vector index where data is to be upserted. Must be a Direct @@ -389,6 +617,12 @@ type UpsertDataVectorIndexRequest struct { InputsJson types.String `tfsdk:"inputs_json" tf:""` } +func (newState *UpsertDataVectorIndexRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpsertDataVectorIndexRequest) { +} + +func (newState *UpsertDataVectorIndexRequest) SyncEffectiveFieldsDuringRead(existingState UpsertDataVectorIndexRequest) { +} + // Response to an upsert data vector index request. type UpsertDataVectorIndexResponse struct { // Result of the upsert or delete operation. @@ -397,6 +631,12 @@ type UpsertDataVectorIndexResponse struct { Status types.String `tfsdk:"status" tf:"optional"` } +func (newState *UpsertDataVectorIndexResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpsertDataVectorIndexResponse) { +} + +func (newState *UpsertDataVectorIndexResponse) SyncEffectiveFieldsDuringRead(existingState UpsertDataVectorIndexResponse) { +} + type Value struct { BoolValue types.Bool `tfsdk:"bool_value" tf:"optional"` @@ -411,6 +651,12 @@ type Value struct { StructValue []Struct `tfsdk:"struct_value" tf:"optional,object"` } +func (newState *Value) SyncEffectiveFieldsDuringCreateOrUpdate(plan Value) { +} + +func (newState *Value) SyncEffectiveFieldsDuringRead(existingState Value) { +} + type VectorIndex struct { // The user who created the index. Creator types.String `tfsdk:"creator" tf:"optional"` @@ -436,6 +682,12 @@ type VectorIndex struct { Status []VectorIndexStatus `tfsdk:"status" tf:"optional,object"` } +func (newState *VectorIndex) SyncEffectiveFieldsDuringCreateOrUpdate(plan VectorIndex) { +} + +func (newState *VectorIndex) SyncEffectiveFieldsDuringRead(existingState VectorIndex) { +} + type VectorIndexStatus struct { // Index API Url to be used to perform operations on the index IndexUrl types.String `tfsdk:"index_url" tf:"optional"` @@ -446,3 +698,9 @@ type VectorIndexStatus struct { // Whether the index is ready for search Ready types.Bool `tfsdk:"ready" tf:"optional"` } + +func (newState *VectorIndexStatus) SyncEffectiveFieldsDuringCreateOrUpdate(plan VectorIndexStatus) { +} + +func (newState *VectorIndexStatus) SyncEffectiveFieldsDuringRead(existingState VectorIndexStatus) { +} diff --git a/internal/service/workspace_tf/model.go b/internal/service/workspace_tf/model.go index 6845913417..058ea6da2d 100755 --- a/internal/service/workspace_tf/model.go +++ b/internal/service/workspace_tf/model.go @@ -21,6 +21,12 @@ type AclItem struct { Principal types.String `tfsdk:"principal" tf:""` } +func (newState *AclItem) SyncEffectiveFieldsDuringCreateOrUpdate(plan AclItem) { +} + +func (newState *AclItem) SyncEffectiveFieldsDuringRead(existingState AclItem) { +} + type AzureKeyVaultSecretScopeMetadata struct { // The DNS of the KeyVault DnsName types.String `tfsdk:"dns_name" tf:""` @@ -29,6 +35,12 @@ type AzureKeyVaultSecretScopeMetadata struct { ResourceId types.String `tfsdk:"resource_id" tf:""` } +func (newState *AzureKeyVaultSecretScopeMetadata) SyncEffectiveFieldsDuringCreateOrUpdate(plan AzureKeyVaultSecretScopeMetadata) { +} + +func (newState *AzureKeyVaultSecretScopeMetadata) SyncEffectiveFieldsDuringRead(existingState AzureKeyVaultSecretScopeMetadata) { +} + type CreateCredentialsRequest struct { // Git provider. This field is case-insensitive. The available Git providers // are `gitHub`, `bitbucketCloud`, `gitLab`, `azureDevOpsServices`, @@ -51,6 +63,12 @@ type CreateCredentialsRequest struct { PersonalAccessToken types.String `tfsdk:"personal_access_token" tf:"optional"` } +func (newState *CreateCredentialsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCredentialsRequest) { +} + +func (newState *CreateCredentialsRequest) SyncEffectiveFieldsDuringRead(existingState CreateCredentialsRequest) { +} + type CreateCredentialsResponse struct { // ID of the credential object in the workspace. CredentialId types.Int64 `tfsdk:"credential_id" tf:""` @@ -61,6 +79,12 @@ type CreateCredentialsResponse struct { GitUsername types.String `tfsdk:"git_username" tf:"optional"` } +func (newState *CreateCredentialsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateCredentialsResponse) { +} + +func (newState *CreateCredentialsResponse) SyncEffectiveFieldsDuringRead(existingState CreateCredentialsResponse) { +} + type CreateRepoRequest struct { // Desired path for the repo in the workspace. Almost any path in the // workspace can be chosen. If repo is created in `/Repos`, path must be in @@ -78,6 +102,12 @@ type CreateRepoRequest struct { Url types.String `tfsdk:"url" tf:""` } +func (newState *CreateRepoRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateRepoRequest) { +} + +func (newState *CreateRepoRequest) SyncEffectiveFieldsDuringRead(existingState CreateRepoRequest) { +} + type CreateRepoResponse struct { // Branch that the Git folder (repo) is checked out to. Branch types.String `tfsdk:"branch" tf:"optional"` @@ -96,6 +126,12 @@ type CreateRepoResponse struct { Url types.String `tfsdk:"url" tf:"optional"` } +func (newState *CreateRepoResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateRepoResponse) { +} + +func (newState *CreateRepoResponse) SyncEffectiveFieldsDuringRead(existingState CreateRepoResponse) { +} + type CreateScope struct { // The metadata for the secret scope if the type is `AZURE_KEYVAULT` BackendAzureKeyvault []AzureKeyVaultSecretScopeMetadata `tfsdk:"backend_azure_keyvault" tf:"optional,object"` @@ -109,9 +145,21 @@ type CreateScope struct { ScopeBackendType types.String `tfsdk:"scope_backend_type" tf:"optional"` } +func (newState *CreateScope) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateScope) { +} + +func (newState *CreateScope) SyncEffectiveFieldsDuringRead(existingState CreateScope) { +} + type CreateScopeResponse struct { } +func (newState *CreateScopeResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan CreateScopeResponse) { +} + +func (newState *CreateScopeResponse) SyncEffectiveFieldsDuringRead(existingState CreateScopeResponse) { +} + type CredentialInfo struct { // ID of the credential object in the workspace. CredentialId types.Int64 `tfsdk:"credential_id" tf:""` @@ -122,6 +170,12 @@ type CredentialInfo struct { GitUsername types.String `tfsdk:"git_username" tf:"optional"` } +func (newState *CredentialInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan CredentialInfo) { +} + +func (newState *CredentialInfo) SyncEffectiveFieldsDuringRead(existingState CredentialInfo) { +} + type Delete struct { // The absolute path of the notebook or directory. Path types.String `tfsdk:"path" tf:""` @@ -132,6 +186,12 @@ type Delete struct { Recursive types.Bool `tfsdk:"recursive" tf:"optional"` } +func (newState *Delete) SyncEffectiveFieldsDuringCreateOrUpdate(plan Delete) { +} + +func (newState *Delete) SyncEffectiveFieldsDuringRead(existingState Delete) { +} + type DeleteAcl struct { // The principal to remove an existing ACL from. Principal types.String `tfsdk:"principal" tf:""` @@ -139,38 +199,92 @@ type DeleteAcl struct { Scope types.String `tfsdk:"scope" tf:""` } +func (newState *DeleteAcl) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAcl) { +} + +func (newState *DeleteAcl) SyncEffectiveFieldsDuringRead(existingState DeleteAcl) { +} + type DeleteAclResponse struct { } +func (newState *DeleteAclResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteAclResponse) { +} + +func (newState *DeleteAclResponse) SyncEffectiveFieldsDuringRead(existingState DeleteAclResponse) { +} + // Delete a credential type DeleteCredentialsRequest struct { // The ID for the corresponding credential to access. CredentialId types.Int64 `tfsdk:"-"` } +func (newState *DeleteCredentialsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteCredentialsRequest) { +} + +func (newState *DeleteCredentialsRequest) SyncEffectiveFieldsDuringRead(existingState DeleteCredentialsRequest) { +} + type DeleteCredentialsResponse struct { } +func (newState *DeleteCredentialsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteCredentialsResponse) { +} + +func (newState *DeleteCredentialsResponse) SyncEffectiveFieldsDuringRead(existingState DeleteCredentialsResponse) { +} + // Delete a repo type DeleteRepoRequest struct { // ID of the Git folder (repo) object in the workspace. RepoId types.Int64 `tfsdk:"-"` } +func (newState *DeleteRepoRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRepoRequest) { +} + +func (newState *DeleteRepoRequest) SyncEffectiveFieldsDuringRead(existingState DeleteRepoRequest) { +} + type DeleteRepoResponse struct { } +func (newState *DeleteRepoResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteRepoResponse) { +} + +func (newState *DeleteRepoResponse) SyncEffectiveFieldsDuringRead(existingState DeleteRepoResponse) { +} + type DeleteResponse struct { } +func (newState *DeleteResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteResponse) { +} + +func (newState *DeleteResponse) SyncEffectiveFieldsDuringRead(existingState DeleteResponse) { +} + type DeleteScope struct { // Name of the scope to delete. Scope types.String `tfsdk:"scope" tf:""` } +func (newState *DeleteScope) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteScope) { +} + +func (newState *DeleteScope) SyncEffectiveFieldsDuringRead(existingState DeleteScope) { +} + type DeleteScopeResponse struct { } +func (newState *DeleteScopeResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteScopeResponse) { +} + +func (newState *DeleteScopeResponse) SyncEffectiveFieldsDuringRead(existingState DeleteScopeResponse) { +} + type DeleteSecret struct { // Name of the secret to delete. Key types.String `tfsdk:"key" tf:""` @@ -178,9 +292,21 @@ type DeleteSecret struct { Scope types.String `tfsdk:"scope" tf:""` } +func (newState *DeleteSecret) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteSecret) { +} + +func (newState *DeleteSecret) SyncEffectiveFieldsDuringRead(existingState DeleteSecret) { +} + type DeleteSecretResponse struct { } +func (newState *DeleteSecretResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan DeleteSecretResponse) { +} + +func (newState *DeleteSecretResponse) SyncEffectiveFieldsDuringRead(existingState DeleteSecretResponse) { +} + // Export a workspace object type ExportRequest struct { // This specifies the format of the exported file. By default, this is @@ -203,6 +329,12 @@ type ExportRequest struct { Path types.String `tfsdk:"-"` } +func (newState *ExportRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExportRequest) { +} + +func (newState *ExportRequest) SyncEffectiveFieldsDuringRead(existingState ExportRequest) { +} + type ExportResponse struct { // The base64-encoded content. If the limit (10MB) is exceeded, exception // with error code **MAX_NOTEBOOK_SIZE_EXCEEDED** is thrown. @@ -211,6 +343,12 @@ type ExportResponse struct { FileType types.String `tfsdk:"file_type" tf:"optional"` } +func (newState *ExportResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ExportResponse) { +} + +func (newState *ExportResponse) SyncEffectiveFieldsDuringRead(existingState ExportResponse) { +} + // Get secret ACL details type GetAclRequest struct { // The principal to fetch ACL information for. @@ -219,12 +357,24 @@ type GetAclRequest struct { Scope types.String `tfsdk:"-"` } +func (newState *GetAclRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetAclRequest) { +} + +func (newState *GetAclRequest) SyncEffectiveFieldsDuringRead(existingState GetAclRequest) { +} + // Get a credential entry type GetCredentialsRequest struct { // The ID for the corresponding credential to access. CredentialId types.Int64 `tfsdk:"-"` } +func (newState *GetCredentialsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetCredentialsRequest) { +} + +func (newState *GetCredentialsRequest) SyncEffectiveFieldsDuringRead(existingState GetCredentialsRequest) { +} + type GetCredentialsResponse struct { // ID of the credential object in the workspace. CredentialId types.Int64 `tfsdk:"credential_id" tf:""` @@ -235,29 +385,59 @@ type GetCredentialsResponse struct { GitUsername types.String `tfsdk:"git_username" tf:"optional"` } +func (newState *GetCredentialsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetCredentialsResponse) { +} + +func (newState *GetCredentialsResponse) SyncEffectiveFieldsDuringRead(existingState GetCredentialsResponse) { +} + // Get repo permission levels type GetRepoPermissionLevelsRequest struct { // The repo for which to get or manage permissions. RepoId types.String `tfsdk:"-"` } +func (newState *GetRepoPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRepoPermissionLevelsRequest) { +} + +func (newState *GetRepoPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetRepoPermissionLevelsRequest) { +} + type GetRepoPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []RepoPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetRepoPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRepoPermissionLevelsResponse) { +} + +func (newState *GetRepoPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetRepoPermissionLevelsResponse) { +} + // Get repo permissions type GetRepoPermissionsRequest struct { // The repo for which to get or manage permissions. RepoId types.String `tfsdk:"-"` } +func (newState *GetRepoPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRepoPermissionsRequest) { +} + +func (newState *GetRepoPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetRepoPermissionsRequest) { +} + // Get a repo type GetRepoRequest struct { // ID of the Git folder (repo) object in the workspace. RepoId types.Int64 `tfsdk:"-"` } +func (newState *GetRepoRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRepoRequest) { +} + +func (newState *GetRepoRequest) SyncEffectiveFieldsDuringRead(existingState GetRepoRequest) { +} + type GetRepoResponse struct { // Branch that the local version of the repo is checked out to. Branch types.String `tfsdk:"branch" tf:"optional"` @@ -275,6 +455,12 @@ type GetRepoResponse struct { Url types.String `tfsdk:"url" tf:"optional"` } +func (newState *GetRepoResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetRepoResponse) { +} + +func (newState *GetRepoResponse) SyncEffectiveFieldsDuringRead(existingState GetRepoResponse) { +} + // Get a secret type GetSecretRequest struct { // The key to fetch secret for. @@ -283,6 +469,12 @@ type GetSecretRequest struct { Scope types.String `tfsdk:"-"` } +func (newState *GetSecretRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetSecretRequest) { +} + +func (newState *GetSecretRequest) SyncEffectiveFieldsDuringRead(existingState GetSecretRequest) { +} + type GetSecretResponse struct { // A unique name to identify the secret. Key types.String `tfsdk:"key" tf:"optional"` @@ -290,12 +482,24 @@ type GetSecretResponse struct { Value types.String `tfsdk:"value" tf:"optional"` } +func (newState *GetSecretResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetSecretResponse) { +} + +func (newState *GetSecretResponse) SyncEffectiveFieldsDuringRead(existingState GetSecretResponse) { +} + // Get status type GetStatusRequest struct { // The absolute path of the notebook or directory. Path types.String `tfsdk:"-"` } +func (newState *GetStatusRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetStatusRequest) { +} + +func (newState *GetStatusRequest) SyncEffectiveFieldsDuringRead(existingState GetStatusRequest) { +} + // Get workspace object permission levels type GetWorkspaceObjectPermissionLevelsRequest struct { // The workspace object for which to get or manage permissions. @@ -304,11 +508,23 @@ type GetWorkspaceObjectPermissionLevelsRequest struct { WorkspaceObjectType types.String `tfsdk:"-"` } +func (newState *GetWorkspaceObjectPermissionLevelsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWorkspaceObjectPermissionLevelsRequest) { +} + +func (newState *GetWorkspaceObjectPermissionLevelsRequest) SyncEffectiveFieldsDuringRead(existingState GetWorkspaceObjectPermissionLevelsRequest) { +} + type GetWorkspaceObjectPermissionLevelsResponse struct { // Specific permission levels PermissionLevels []WorkspaceObjectPermissionsDescription `tfsdk:"permission_levels" tf:"optional"` } +func (newState *GetWorkspaceObjectPermissionLevelsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWorkspaceObjectPermissionLevelsResponse) { +} + +func (newState *GetWorkspaceObjectPermissionLevelsResponse) SyncEffectiveFieldsDuringRead(existingState GetWorkspaceObjectPermissionLevelsResponse) { +} + // Get workspace object permissions type GetWorkspaceObjectPermissionsRequest struct { // The workspace object for which to get or manage permissions. @@ -317,6 +533,12 @@ type GetWorkspaceObjectPermissionsRequest struct { WorkspaceObjectType types.String `tfsdk:"-"` } +func (newState *GetWorkspaceObjectPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan GetWorkspaceObjectPermissionsRequest) { +} + +func (newState *GetWorkspaceObjectPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState GetWorkspaceObjectPermissionsRequest) { +} + type Import struct { // The base64-encoded content. This has a limit of 10 MB. // @@ -350,25 +572,55 @@ type Import struct { Path types.String `tfsdk:"path" tf:""` } +func (newState *Import) SyncEffectiveFieldsDuringCreateOrUpdate(plan Import) { +} + +func (newState *Import) SyncEffectiveFieldsDuringRead(existingState Import) { +} + type ImportResponse struct { } +func (newState *ImportResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ImportResponse) { +} + +func (newState *ImportResponse) SyncEffectiveFieldsDuringRead(existingState ImportResponse) { +} + // Lists ACLs type ListAclsRequest struct { // The name of the scope to fetch ACL information from. Scope types.String `tfsdk:"-"` } +func (newState *ListAclsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAclsRequest) { +} + +func (newState *ListAclsRequest) SyncEffectiveFieldsDuringRead(existingState ListAclsRequest) { +} + type ListAclsResponse struct { // The associated ACLs rule applied to principals in the given scope. Items []AclItem `tfsdk:"items" tf:"optional"` } +func (newState *ListAclsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListAclsResponse) { +} + +func (newState *ListAclsResponse) SyncEffectiveFieldsDuringRead(existingState ListAclsResponse) { +} + type ListCredentialsResponse struct { // List of credentials. Credentials []CredentialInfo `tfsdk:"credentials" tf:"optional"` } +func (newState *ListCredentialsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListCredentialsResponse) { +} + +func (newState *ListCredentialsResponse) SyncEffectiveFieldsDuringRead(existingState ListCredentialsResponse) { +} + // Get repos type ListReposRequest struct { // Token used to get the next page of results. If not specified, returns the @@ -381,6 +633,12 @@ type ListReposRequest struct { PathPrefix types.String `tfsdk:"-"` } +func (newState *ListReposRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListReposRequest) { +} + +func (newState *ListReposRequest) SyncEffectiveFieldsDuringRead(existingState ListReposRequest) { +} + type ListReposResponse struct { // Token that can be specified as a query parameter to the `GET /repos` // endpoint to retrieve the next page of results. @@ -389,27 +647,57 @@ type ListReposResponse struct { Repos []RepoInfo `tfsdk:"repos" tf:"optional"` } +func (newState *ListReposResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListReposResponse) { +} + +func (newState *ListReposResponse) SyncEffectiveFieldsDuringRead(existingState ListReposResponse) { +} + type ListResponse struct { // List of objects. Objects []ObjectInfo `tfsdk:"objects" tf:"optional"` } +func (newState *ListResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListResponse) { +} + +func (newState *ListResponse) SyncEffectiveFieldsDuringRead(existingState ListResponse) { +} + type ListScopesResponse struct { // The available secret scopes. Scopes []SecretScope `tfsdk:"scopes" tf:"optional"` } +func (newState *ListScopesResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListScopesResponse) { +} + +func (newState *ListScopesResponse) SyncEffectiveFieldsDuringRead(existingState ListScopesResponse) { +} + // List secret keys type ListSecretsRequest struct { // The name of the scope to list secrets within. Scope types.String `tfsdk:"-"` } +func (newState *ListSecretsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSecretsRequest) { +} + +func (newState *ListSecretsRequest) SyncEffectiveFieldsDuringRead(existingState ListSecretsRequest) { +} + type ListSecretsResponse struct { // Metadata information of all secrets contained within the given scope. Secrets []SecretMetadata `tfsdk:"secrets" tf:"optional"` } +func (newState *ListSecretsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListSecretsResponse) { +} + +func (newState *ListSecretsResponse) SyncEffectiveFieldsDuringRead(existingState ListSecretsResponse) { +} + // List contents type ListWorkspaceRequest struct { // UTC timestamp in milliseconds @@ -418,6 +706,12 @@ type ListWorkspaceRequest struct { Path types.String `tfsdk:"-"` } +func (newState *ListWorkspaceRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan ListWorkspaceRequest) { +} + +func (newState *ListWorkspaceRequest) SyncEffectiveFieldsDuringRead(existingState ListWorkspaceRequest) { +} + type Mkdirs struct { // The absolute path of the directory. If the parent directories do not // exist, it will also create them. If the directory already exists, this @@ -425,9 +719,21 @@ type Mkdirs struct { Path types.String `tfsdk:"path" tf:""` } +func (newState *Mkdirs) SyncEffectiveFieldsDuringCreateOrUpdate(plan Mkdirs) { +} + +func (newState *Mkdirs) SyncEffectiveFieldsDuringRead(existingState Mkdirs) { +} + type MkdirsResponse struct { } +func (newState *MkdirsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan MkdirsResponse) { +} + +func (newState *MkdirsResponse) SyncEffectiveFieldsDuringRead(existingState MkdirsResponse) { +} + type ObjectInfo struct { // Only applicable to files. The creation UTC timestamp. CreatedAt types.Int64 `tfsdk:"created_at" tf:"optional"` @@ -453,6 +759,12 @@ type ObjectInfo struct { Size types.Int64 `tfsdk:"size" tf:"optional"` } +func (newState *ObjectInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan ObjectInfo) { +} + +func (newState *ObjectInfo) SyncEffectiveFieldsDuringRead(existingState ObjectInfo) { +} + type PutAcl struct { // The permission level applied to the principal. Permission types.String `tfsdk:"permission" tf:""` @@ -462,9 +774,21 @@ type PutAcl struct { Scope types.String `tfsdk:"scope" tf:""` } +func (newState *PutAcl) SyncEffectiveFieldsDuringCreateOrUpdate(plan PutAcl) { +} + +func (newState *PutAcl) SyncEffectiveFieldsDuringRead(existingState PutAcl) { +} + type PutAclResponse struct { } +func (newState *PutAclResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PutAclResponse) { +} + +func (newState *PutAclResponse) SyncEffectiveFieldsDuringRead(existingState PutAclResponse) { +} + type PutSecret struct { // If specified, value will be stored as bytes. BytesValue types.String `tfsdk:"bytes_value" tf:"optional"` @@ -476,9 +800,21 @@ type PutSecret struct { StringValue types.String `tfsdk:"string_value" tf:"optional"` } +func (newState *PutSecret) SyncEffectiveFieldsDuringCreateOrUpdate(plan PutSecret) { +} + +func (newState *PutSecret) SyncEffectiveFieldsDuringRead(existingState PutSecret) { +} + type PutSecretResponse struct { } +func (newState *PutSecretResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan PutSecretResponse) { +} + +func (newState *PutSecretResponse) SyncEffectiveFieldsDuringRead(existingState PutSecretResponse) { +} + type RepoAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -490,6 +826,12 @@ type RepoAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *RepoAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepoAccessControlRequest) { +} + +func (newState *RepoAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState RepoAccessControlRequest) { +} + type RepoAccessControlResponse struct { // All permissions. AllPermissions []RepoPermission `tfsdk:"all_permissions" tf:"optional"` @@ -503,6 +845,12 @@ type RepoAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *RepoAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepoAccessControlResponse) { +} + +func (newState *RepoAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState RepoAccessControlResponse) { +} + // Git folder (repo) information. type RepoInfo struct { // Name of the current git branch of the git folder (repo). @@ -521,6 +869,12 @@ type RepoInfo struct { Url types.String `tfsdk:"url" tf:"optional"` } +func (newState *RepoInfo) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepoInfo) { +} + +func (newState *RepoInfo) SyncEffectiveFieldsDuringRead(existingState RepoInfo) { +} + type RepoPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -529,6 +883,12 @@ type RepoPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *RepoPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepoPermission) { +} + +func (newState *RepoPermission) SyncEffectiveFieldsDuringRead(existingState RepoPermission) { +} + type RepoPermissions struct { AccessControlList []RepoAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -537,18 +897,36 @@ type RepoPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *RepoPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepoPermissions) { +} + +func (newState *RepoPermissions) SyncEffectiveFieldsDuringRead(existingState RepoPermissions) { +} + type RepoPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *RepoPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepoPermissionsDescription) { +} + +func (newState *RepoPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState RepoPermissionsDescription) { +} + type RepoPermissionsRequest struct { AccessControlList []RepoAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The repo for which to get or manage permissions. RepoId types.String `tfsdk:"-"` } +func (newState *RepoPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan RepoPermissionsRequest) { +} + +func (newState *RepoPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState RepoPermissionsRequest) { +} + type SecretMetadata struct { // A unique name to identify the secret. Key types.String `tfsdk:"key" tf:"optional"` @@ -556,6 +934,12 @@ type SecretMetadata struct { LastUpdatedTimestamp types.Int64 `tfsdk:"last_updated_timestamp" tf:"optional"` } +func (newState *SecretMetadata) SyncEffectiveFieldsDuringCreateOrUpdate(plan SecretMetadata) { +} + +func (newState *SecretMetadata) SyncEffectiveFieldsDuringRead(existingState SecretMetadata) { +} + type SecretScope struct { // The type of secret scope backend. BackendType types.String `tfsdk:"backend_type" tf:"optional"` @@ -565,6 +949,12 @@ type SecretScope struct { Name types.String `tfsdk:"name" tf:"optional"` } +func (newState *SecretScope) SyncEffectiveFieldsDuringCreateOrUpdate(plan SecretScope) { +} + +func (newState *SecretScope) SyncEffectiveFieldsDuringRead(existingState SecretScope) { +} + // Sparse checkout configuration, it contains options like cone patterns. type SparseCheckout struct { // List of sparse checkout cone patterns, see [cone mode handling] for @@ -574,6 +964,12 @@ type SparseCheckout struct { Patterns []types.String `tfsdk:"patterns" tf:"optional"` } +func (newState *SparseCheckout) SyncEffectiveFieldsDuringCreateOrUpdate(plan SparseCheckout) { +} + +func (newState *SparseCheckout) SyncEffectiveFieldsDuringRead(existingState SparseCheckout) { +} + // Sparse checkout configuration, it contains options like cone patterns. type SparseCheckoutUpdate struct { // List of sparse checkout cone patterns, see [cone mode handling] for @@ -583,6 +979,12 @@ type SparseCheckoutUpdate struct { Patterns []types.String `tfsdk:"patterns" tf:"optional"` } +func (newState *SparseCheckoutUpdate) SyncEffectiveFieldsDuringCreateOrUpdate(plan SparseCheckoutUpdate) { +} + +func (newState *SparseCheckoutUpdate) SyncEffectiveFieldsDuringRead(existingState SparseCheckoutUpdate) { +} + type UpdateCredentialsRequest struct { // The ID for the corresponding credential to access. CredentialId types.Int64 `tfsdk:"-"` @@ -607,9 +1009,21 @@ type UpdateCredentialsRequest struct { PersonalAccessToken types.String `tfsdk:"personal_access_token" tf:"optional"` } +func (newState *UpdateCredentialsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateCredentialsRequest) { +} + +func (newState *UpdateCredentialsRequest) SyncEffectiveFieldsDuringRead(existingState UpdateCredentialsRequest) { +} + type UpdateCredentialsResponse struct { } +func (newState *UpdateCredentialsResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateCredentialsResponse) { +} + +func (newState *UpdateCredentialsResponse) SyncEffectiveFieldsDuringRead(existingState UpdateCredentialsResponse) { +} + type UpdateRepoRequest struct { // Branch that the local version of the repo is checked out to. Branch types.String `tfsdk:"branch" tf:"optional"` @@ -625,9 +1039,21 @@ type UpdateRepoRequest struct { Tag types.String `tfsdk:"tag" tf:"optional"` } +func (newState *UpdateRepoRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateRepoRequest) { +} + +func (newState *UpdateRepoRequest) SyncEffectiveFieldsDuringRead(existingState UpdateRepoRequest) { +} + type UpdateRepoResponse struct { } +func (newState *UpdateRepoResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan UpdateRepoResponse) { +} + +func (newState *UpdateRepoResponse) SyncEffectiveFieldsDuringRead(existingState UpdateRepoResponse) { +} + type WorkspaceObjectAccessControlRequest struct { // name of the group GroupName types.String `tfsdk:"group_name" tf:"optional"` @@ -639,6 +1065,12 @@ type WorkspaceObjectAccessControlRequest struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *WorkspaceObjectAccessControlRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkspaceObjectAccessControlRequest) { +} + +func (newState *WorkspaceObjectAccessControlRequest) SyncEffectiveFieldsDuringRead(existingState WorkspaceObjectAccessControlRequest) { +} + type WorkspaceObjectAccessControlResponse struct { // All permissions. AllPermissions []WorkspaceObjectPermission `tfsdk:"all_permissions" tf:"optional"` @@ -652,6 +1084,12 @@ type WorkspaceObjectAccessControlResponse struct { UserName types.String `tfsdk:"user_name" tf:"optional"` } +func (newState *WorkspaceObjectAccessControlResponse) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkspaceObjectAccessControlResponse) { +} + +func (newState *WorkspaceObjectAccessControlResponse) SyncEffectiveFieldsDuringRead(existingState WorkspaceObjectAccessControlResponse) { +} + type WorkspaceObjectPermission struct { Inherited types.Bool `tfsdk:"inherited" tf:"optional"` @@ -660,6 +1098,12 @@ type WorkspaceObjectPermission struct { PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *WorkspaceObjectPermission) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkspaceObjectPermission) { +} + +func (newState *WorkspaceObjectPermission) SyncEffectiveFieldsDuringRead(existingState WorkspaceObjectPermission) { +} + type WorkspaceObjectPermissions struct { AccessControlList []WorkspaceObjectAccessControlResponse `tfsdk:"access_control_list" tf:"optional"` @@ -668,12 +1112,24 @@ type WorkspaceObjectPermissions struct { ObjectType types.String `tfsdk:"object_type" tf:"optional"` } +func (newState *WorkspaceObjectPermissions) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkspaceObjectPermissions) { +} + +func (newState *WorkspaceObjectPermissions) SyncEffectiveFieldsDuringRead(existingState WorkspaceObjectPermissions) { +} + type WorkspaceObjectPermissionsDescription struct { Description types.String `tfsdk:"description" tf:"optional"` // Permission level PermissionLevel types.String `tfsdk:"permission_level" tf:"optional"` } +func (newState *WorkspaceObjectPermissionsDescription) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkspaceObjectPermissionsDescription) { +} + +func (newState *WorkspaceObjectPermissionsDescription) SyncEffectiveFieldsDuringRead(existingState WorkspaceObjectPermissionsDescription) { +} + type WorkspaceObjectPermissionsRequest struct { AccessControlList []WorkspaceObjectAccessControlRequest `tfsdk:"access_control_list" tf:"optional"` // The workspace object for which to get or manage permissions. @@ -681,3 +1137,9 @@ type WorkspaceObjectPermissionsRequest struct { // The workspace object type for which to get or manage permissions. WorkspaceObjectType types.String `tfsdk:"-"` } + +func (newState *WorkspaceObjectPermissionsRequest) SyncEffectiveFieldsDuringCreateOrUpdate(plan WorkspaceObjectPermissionsRequest) { +} + +func (newState *WorkspaceObjectPermissionsRequest) SyncEffectiveFieldsDuringRead(existingState WorkspaceObjectPermissionsRequest) { +} From 5cec8a4ab37b32b2a5b258b8fe88468f3ee0c2bf Mon Sep 17 00:00:00 2001 From: Omer Lachish Date: Tue, 15 Oct 2024 15:56:03 +0200 Subject: [PATCH 2/2] bump Go SDK version --- go.mod | 4 ++-- go.sum | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/go.mod b/go.mod index 1fc08e53ba..4e97cc0d23 100644 --- a/go.mod +++ b/go.mod @@ -3,12 +3,13 @@ module github.com/databricks/terraform-provider-databricks go 1.22 require ( - github.com/databricks/databricks-sdk-go v0.48.0 + github.com/databricks/databricks-sdk-go v0.49.0 github.com/golang-jwt/jwt/v4 v4.5.0 github.com/hashicorp/go-cty v1.4.1-0.20200414143053-d3edf31b6320 github.com/hashicorp/hcl v1.0.0 github.com/hashicorp/hcl/v2 v2.22.0 github.com/hashicorp/terraform-plugin-framework v1.11.0 + github.com/hashicorp/terraform-plugin-framework-validators v0.13.0 github.com/hashicorp/terraform-plugin-go v0.23.0 github.com/hashicorp/terraform-plugin-log v0.9.0 github.com/hashicorp/terraform-plugin-mux v0.16.0 @@ -52,7 +53,6 @@ require ( github.com/hashicorp/logutils v1.0.0 // indirect github.com/hashicorp/terraform-exec v0.21.0 // indirect github.com/hashicorp/terraform-json v0.22.1 // indirect - github.com/hashicorp/terraform-plugin-framework-validators v0.13.0 // indirect github.com/hashicorp/terraform-registry-address v0.2.3 // indirect github.com/hashicorp/terraform-svchost v0.1.1 // indirect github.com/hashicorp/yamux v0.1.1 // indirect diff --git a/go.sum b/go.sum index c323c71e4c..e95a0ffe39 100644 --- a/go.sum +++ b/go.sum @@ -26,8 +26,8 @@ github.com/cloudflare/circl v1.3.7/go.mod h1:sRTcRWXGLrKw6yIGJ+l7amYJFfAXbZG0kBS github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/cyphar/filepath-securejoin v0.2.4 h1:Ugdm7cg7i6ZK6x3xDF1oEu1nfkyfH53EtKeQYTC3kyg= github.com/cyphar/filepath-securejoin v0.2.4/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4= -github.com/databricks/databricks-sdk-go v0.48.0 h1:46KtsnRo+FGhC3izUXbpL0PXBNomvsdignYDhJZlm9s= -github.com/databricks/databricks-sdk-go v0.48.0/go.mod h1:ds+zbv5mlQG7nFEU5ojLtgN/u0/9YzZmKQES/CfedzU= +github.com/databricks/databricks-sdk-go v0.49.0 h1:VBTeZZMLIuBSM4kxOCfUcW9z4FUQZY2QeNRD5qm9FUQ= +github.com/databricks/databricks-sdk-go v0.49.0/go.mod h1:ds+zbv5mlQG7nFEU5ojLtgN/u0/9YzZmKQES/CfedzU= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=