diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/CHANGELOG.md b/sdk/resourcemanager/azurearcdata/armazurearcdata/CHANGELOG.md index b5fea258da31..fdf512aafd99 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/CHANGELOG.md +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/CHANGELOG.md @@ -1,5 +1,193 @@ # Release History +## 0.8.0 (2024-09-30) +### Breaking Changes + +- Type of `ErrorResponse.Error` has been changed from `*ErrorResponseBody` to `*ErrorDetail` +- Operation `*SQLServerInstancesClient.Update` has been changed to LRO, use `*SQLServerInstancesClient.BeginUpdate` instead. +- Struct `ErrorResponseBody` has been removed + +### Features Added + +- New value `ArcSQLServerLicenseTypeLicenseOnly`, `ArcSQLServerLicenseTypePAYG`, `ArcSQLServerLicenseTypeServerCAL` added to enum type `ArcSQLServerLicenseType` +- New value `EditionTypeBusinessIntelligence` added to enum type `EditionType` +- New value `HostTypeAWSKubernetesService`, `HostTypeAWSVMWareVirtualMachine`, `HostTypeAzureKubernetesService`, `HostTypeAzureVMWareVirtualMachine`, `HostTypeAzureVirtualMachine`, `HostTypeContainer`, `HostTypeGCPKubernetesService`, `HostTypeGCPVMWareVirtualMachine` added to enum type `HostType` +- New enum type `ActivationState` with values `ActivationStateActivated`, `ActivationStateDeactivated` +- New enum type `AggregationType` with values `AggregationTypeAverage`, `AggregationTypeCount`, `AggregationTypeMaximum`, `AggregationTypeMinimum`, `AggregationTypeSum` +- New enum type `AlwaysOnRole` with values `AlwaysOnRoleAvailabilityGroupReplica`, `AlwaysOnRoleFailoverClusterInstance`, `AlwaysOnRoleFailoverClusterNode`, `AlwaysOnRoleNone` +- New enum type `ArcSQLServerAvailabilityMode` with values `ArcSQLServerAvailabilityModeASYNCHRONOUSCOMMIT`, `ArcSQLServerAvailabilityModeSYNCHRONOUSCOMMIT` +- New enum type `ArcSQLServerFailoverMode` with values `ArcSQLServerFailoverModeAUTOMATIC`, `ArcSQLServerFailoverModeEXTERNAL`, `ArcSQLServerFailoverModeMANUAL` +- New enum type `AutomatedBackupPreference` with values `AutomatedBackupPreferenceNONE`, `AutomatedBackupPreferencePRIMARY`, `AutomatedBackupPreferenceSECONDARY`, `AutomatedBackupPreferenceSECONDARYONLY` +- New enum type `BillingPlan` with values `BillingPlanPAYG`, `BillingPlanPaid` +- New enum type `ClusterType` with values `ClusterTypeNONE`, `ClusterTypeWSFC` +- New enum type `ConnectionAuth` with values `ConnectionAuthCertificate`, `ConnectionAuthCertificateWindowsKerberos`, `ConnectionAuthCertificateWindowsNTLM`, `ConnectionAuthCertificateWindowsNegotiate`, `ConnectionAuthWindowsKerberos`, `ConnectionAuthWindowsKerberosCertificate`, `ConnectionAuthWindowsNTLM`, `ConnectionAuthWindowsNTLMCertificate`, `ConnectionAuthWindowsNegotiate`, `ConnectionAuthWindowsNegotiateCertificate` +- New enum type `DatabaseCreateMode` with values `DatabaseCreateModeDefault`, `DatabaseCreateModePointInTimeRestore` +- New enum type `DatabaseState` with values `DatabaseStateCopying`, `DatabaseStateEmergency`, `DatabaseStateOffline`, `DatabaseStateOfflineSecondary`, `DatabaseStateOnline`, `DatabaseStateRecovering`, `DatabaseStateRecoveryPending`, `DatabaseStateRestoring`, `DatabaseStateSuspect` +- New enum type `DbFailover` with values `DbFailoverOFF`, `DbFailoverON` +- New enum type `DifferentialBackupHours` with values `DifferentialBackupHoursTwelve`, `DifferentialBackupHoursTwentyFour` +- New enum type `DtcSupport` with values `DtcSupportNONE`, `DtcSupportPERDB` +- New enum type `EncryptionAlgorithm` with values `EncryptionAlgorithmAES`, `EncryptionAlgorithmAESRC4`, `EncryptionAlgorithmNONE`, `EncryptionAlgorithmNONEAES`, `EncryptionAlgorithmNONEAESRC4`, `EncryptionAlgorithmNONERC4`, `EncryptionAlgorithmNONERC4AES`, `EncryptionAlgorithmRC4`, `EncryptionAlgorithmRC4AES` +- New enum type `ExecutionState` with values `ExecutionStateRunning`, `ExecutionStateWaiting` +- New enum type `FailoverGroupPartnerSyncMode` with values `FailoverGroupPartnerSyncModeAsync`, `FailoverGroupPartnerSyncModeSync` +- New enum type `FailureConditionLevel` with values `FailureConditionLevelFive`, `FailureConditionLevelFour`, `FailureConditionLevelOne`, `FailureConditionLevelThree`, `FailureConditionLevelTwo` +- New enum type `InstanceFailoverGroupRole` with values `InstanceFailoverGroupRoleForcePrimaryAllowDataLoss`, `InstanceFailoverGroupRoleForceSecondary`, `InstanceFailoverGroupRolePrimary`, `InstanceFailoverGroupRoleSecondary` +- New enum type `JobStatus` with values `JobStatusFailed`, `JobStatusInProgress`, `JobStatusNotStarted`, `JobStatusSucceeded` +- New enum type `LastExecutionStatus` with values `LastExecutionStatusCompleted`, `LastExecutionStatusFailed`, `LastExecutionStatusFaulted`, `LastExecutionStatusPostponed`, `LastExecutionStatusRescheduled`, `LastExecutionStatusSucceeded` +- New enum type `LicenseCategory` with values `LicenseCategoryCore` +- New enum type `PrimaryAllowConnections` with values `PrimaryAllowConnectionsALL`, `PrimaryAllowConnectionsREADWRITE` +- New enum type `ProvisioningState` with values `ProvisioningStateAccepted`, `ProvisioningStateCanceled`, `ProvisioningStateFailed`, `ProvisioningStateSucceeded` +- New enum type `RecommendationStatus` with values `RecommendationStatusNotReady`, `RecommendationStatusReady`, `RecommendationStatusUnknown` +- New enum type `RecoveryMode` with values `RecoveryModeBulkLogged`, `RecoveryModeFull`, `RecoveryModeSimple` +- New enum type `ReplicationPartnerType` with values `ReplicationPartnerTypeAzureSQLManagedInstance`, `ReplicationPartnerTypeAzureSQLVM`, `ReplicationPartnerTypeSQLServer`, `ReplicationPartnerTypeUnknown` +- New enum type `Result` with values `ResultFailed`, `ResultNotCompleted`, `ResultSkipped`, `ResultSucceeded`, `ResultTimedOut` +- New enum type `Role` with values `RoleALL`, `RoleNONE`, `RolePARTNER`, `RoleWITNESS` +- New enum type `SQLServerInstanceTelemetryColumnType` with values `SQLServerInstanceTelemetryColumnTypeBool`, `SQLServerInstanceTelemetryColumnTypeDatetime`, `SQLServerInstanceTelemetryColumnTypeDouble`, `SQLServerInstanceTelemetryColumnTypeGUID`, `SQLServerInstanceTelemetryColumnTypeInt`, `SQLServerInstanceTelemetryColumnTypeLong`, `SQLServerInstanceTelemetryColumnTypeString`, `SQLServerInstanceTelemetryColumnTypeTimespan` +- New enum type `ScopeType` with values `ScopeTypeResourceGroup`, `ScopeTypeSubscription`, `ScopeTypeTenant` +- New enum type `SecondaryAllowConnections` with values `SecondaryAllowConnectionsALL`, `SecondaryAllowConnectionsNO`, `SecondaryAllowConnectionsREADONLY` +- New enum type `SeedingMode` with values `SeedingModeAUTOMATIC`, `SeedingModeMANUAL` +- New enum type `SequencerState` with values `SequencerStateCompleted`, `SequencerStateCreatingSuccessors`, `SequencerStateExecutingAction`, `SequencerStateNotStarted`, `SequencerStateWaitingPredecessors` +- New enum type `ServiceType` with values `ServiceTypeEngine`, `ServiceTypePBIRS`, `ServiceTypeSSAS`, `ServiceTypeSSIS`, `ServiceTypeSSRS` +- New enum type `State` with values `StateActive`, `StateCompleted`, `StateDeleted`, `StateDisabled`, `StateEnabled`, `StateFaulted`, `StateInactive`, `StateSuspended`, `StateTerminated` +- New enum type `Version` with values `VersionSQLServer2012`, `VersionSQLServer2014` +- New function `*ClientFactory.NewFailoverGroupsClient() *FailoverGroupsClient` +- New function `*ClientFactory.NewSQLServerAvailabilityGroupsClient() *SQLServerAvailabilityGroupsClient` +- New function `*ClientFactory.NewSQLServerDatabasesClient() *SQLServerDatabasesClient` +- New function `*ClientFactory.NewSQLServerEsuLicensesClient() *SQLServerEsuLicensesClient` +- New function `*ClientFactory.NewSQLServerLicensesClient() *SQLServerLicensesClient` +- New function `NewFailoverGroupsClient(string, azcore.TokenCredential, *arm.ClientOptions) (*FailoverGroupsClient, error)` +- New function `*FailoverGroupsClient.BeginCreate(context.Context, string, string, string, FailoverGroupResource, *FailoverGroupsClientBeginCreateOptions) (*runtime.Poller[FailoverGroupsClientCreateResponse], error)` +- New function `*FailoverGroupsClient.BeginDelete(context.Context, string, string, string, *FailoverGroupsClientBeginDeleteOptions) (*runtime.Poller[FailoverGroupsClientDeleteResponse], error)` +- New function `*FailoverGroupsClient.Get(context.Context, string, string, string, *FailoverGroupsClientGetOptions) (FailoverGroupsClientGetResponse, error)` +- New function `*FailoverGroupsClient.NewListPager(string, string, *FailoverGroupsClientListOptions) *runtime.Pager[FailoverGroupsClientListResponse]` +- New function `NewSQLServerAvailabilityGroupsClient(string, azcore.TokenCredential, *arm.ClientOptions) (*SQLServerAvailabilityGroupsClient, error)` +- New function `*SQLServerAvailabilityGroupsClient.AddDatabases(context.Context, string, string, string, Databases, *SQLServerAvailabilityGroupsClientAddDatabasesOptions) (SQLServerAvailabilityGroupsClientAddDatabasesResponse, error)` +- New function `*SQLServerAvailabilityGroupsClient.Create(context.Context, string, string, string, SQLServerAvailabilityGroupResource, *SQLServerAvailabilityGroupsClientCreateOptions) (SQLServerAvailabilityGroupsClientCreateResponse, error)` +- New function `*SQLServerAvailabilityGroupsClient.BeginCreateAvailabilityGroup(context.Context, string, string, AvailabilityGroupCreateUpdateConfiguration, *SQLServerAvailabilityGroupsClientBeginCreateAvailabilityGroupOptions) (*runtime.Poller[SQLServerAvailabilityGroupsClientCreateAvailabilityGroupResponse], error)` +- New function `*SQLServerAvailabilityGroupsClient.BeginCreateDistributedAvailabilityGroup(context.Context, string, string, DistributedAvailabilityGroupCreateUpdateConfiguration, *SQLServerAvailabilityGroupsClientBeginCreateDistributedAvailabilityGroupOptions) (*runtime.Poller[SQLServerAvailabilityGroupsClientCreateDistributedAvailabilityGroupResponse], error)` +- New function `*SQLServerAvailabilityGroupsClient.BeginDelete(context.Context, string, string, string, *SQLServerAvailabilityGroupsClientBeginDeleteOptions) (*runtime.Poller[SQLServerAvailabilityGroupsClientDeleteResponse], error)` +- New function `*SQLServerAvailabilityGroupsClient.DetailView(context.Context, string, string, string, *SQLServerAvailabilityGroupsClientDetailViewOptions) (SQLServerAvailabilityGroupsClientDetailViewResponse, error)` +- New function `*SQLServerAvailabilityGroupsClient.Failover(context.Context, string, string, string, *SQLServerAvailabilityGroupsClientFailoverOptions) (SQLServerAvailabilityGroupsClientFailoverResponse, error)` +- New function `*SQLServerAvailabilityGroupsClient.ForceFailoverAllowDataLoss(context.Context, string, string, string, *SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossOptions) (SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse, error)` +- New function `*SQLServerAvailabilityGroupsClient.Get(context.Context, string, string, string, *SQLServerAvailabilityGroupsClientGetOptions) (SQLServerAvailabilityGroupsClientGetResponse, error)` +- New function `*SQLServerAvailabilityGroupsClient.NewListPager(string, string, *SQLServerAvailabilityGroupsClientListOptions) *runtime.Pager[SQLServerAvailabilityGroupsClientListResponse]` +- New function `*SQLServerAvailabilityGroupsClient.RemoveDatabases(context.Context, string, string, string, Databases, *SQLServerAvailabilityGroupsClientRemoveDatabasesOptions) (SQLServerAvailabilityGroupsClientRemoveDatabasesResponse, error)` +- New function `*SQLServerAvailabilityGroupsClient.BeginUpdate(context.Context, string, string, string, SQLServerAvailabilityGroupUpdate, *SQLServerAvailabilityGroupsClientBeginUpdateOptions) (*runtime.Poller[SQLServerAvailabilityGroupsClientUpdateResponse], error)` +- New function `NewSQLServerDatabasesClient(string, azcore.TokenCredential, *arm.ClientOptions) (*SQLServerDatabasesClient, error)` +- New function `*SQLServerDatabasesClient.Create(context.Context, string, string, string, SQLServerDatabaseResource, *SQLServerDatabasesClientCreateOptions) (SQLServerDatabasesClientCreateResponse, error)` +- New function `*SQLServerDatabasesClient.BeginDelete(context.Context, string, string, string, *SQLServerDatabasesClientBeginDeleteOptions) (*runtime.Poller[SQLServerDatabasesClientDeleteResponse], error)` +- New function `*SQLServerDatabasesClient.Get(context.Context, string, string, string, *SQLServerDatabasesClientGetOptions) (SQLServerDatabasesClientGetResponse, error)` +- New function `*SQLServerDatabasesClient.NewListPager(string, string, *SQLServerDatabasesClientListOptions) *runtime.Pager[SQLServerDatabasesClientListResponse]` +- New function `*SQLServerDatabasesClient.BeginUpdate(context.Context, string, string, string, SQLServerDatabaseUpdate, *SQLServerDatabasesClientBeginUpdateOptions) (*runtime.Poller[SQLServerDatabasesClientUpdateResponse], error)` +- New function `NewSQLServerEsuLicensesClient(string, azcore.TokenCredential, *arm.ClientOptions) (*SQLServerEsuLicensesClient, error)` +- New function `*SQLServerEsuLicensesClient.Create(context.Context, string, string, SQLServerEsuLicense, *SQLServerEsuLicensesClientCreateOptions) (SQLServerEsuLicensesClientCreateResponse, error)` +- New function `*SQLServerEsuLicensesClient.Delete(context.Context, string, string, *SQLServerEsuLicensesClientDeleteOptions) (SQLServerEsuLicensesClientDeleteResponse, error)` +- New function `*SQLServerEsuLicensesClient.Get(context.Context, string, string, *SQLServerEsuLicensesClientGetOptions) (SQLServerEsuLicensesClientGetResponse, error)` +- New function `*SQLServerEsuLicensesClient.NewListByResourceGroupPager(string, *SQLServerEsuLicensesClientListByResourceGroupOptions) *runtime.Pager[SQLServerEsuLicensesClientListByResourceGroupResponse]` +- New function `*SQLServerEsuLicensesClient.NewListPager(*SQLServerEsuLicensesClientListOptions) *runtime.Pager[SQLServerEsuLicensesClientListResponse]` +- New function `*SQLServerEsuLicensesClient.Update(context.Context, string, string, SQLServerEsuLicenseUpdate, *SQLServerEsuLicensesClientUpdateOptions) (SQLServerEsuLicensesClientUpdateResponse, error)` +- New function `*SQLServerInstancesClient.GetJobsStatus(context.Context, string, string, *SQLServerInstancesClientGetJobsStatusOptions) (SQLServerInstancesClientGetJobsStatusResponse, error)` +- New function `*SQLServerInstancesClient.BeginGetTelemetry(context.Context, string, string, SQLServerInstanceTelemetryRequest, *SQLServerInstancesClientBeginGetTelemetryOptions) (*runtime.Poller[*runtime.Pager[SQLServerInstancesClientGetTelemetryResponse]], error)` +- New function `*SQLServerInstancesClient.PostUpgrade(context.Context, string, string, *SQLServerInstancesClientPostUpgradeOptions) (SQLServerInstancesClientPostUpgradeResponse, error)` +- New function `*SQLServerInstancesClient.PreUpgrade(context.Context, string, string, *SQLServerInstancesClientPreUpgradeOptions) (SQLServerInstancesClientPreUpgradeResponse, error)` +- New function `*SQLServerInstancesClient.RunMigrationAssessment(context.Context, string, string, *SQLServerInstancesClientRunMigrationAssessmentOptions) (SQLServerInstancesClientRunMigrationAssessmentResponse, error)` +- New function `NewSQLServerLicensesClient(string, azcore.TokenCredential, *arm.ClientOptions) (*SQLServerLicensesClient, error)` +- New function `*SQLServerLicensesClient.Create(context.Context, string, string, SQLServerLicense, *SQLServerLicensesClientCreateOptions) (SQLServerLicensesClientCreateResponse, error)` +- New function `*SQLServerLicensesClient.Delete(context.Context, string, string, *SQLServerLicensesClientDeleteOptions) (SQLServerLicensesClientDeleteResponse, error)` +- New function `*SQLServerLicensesClient.Get(context.Context, string, string, *SQLServerLicensesClientGetOptions) (SQLServerLicensesClientGetResponse, error)` +- New function `*SQLServerLicensesClient.NewListByResourceGroupPager(string, *SQLServerLicensesClientListByResourceGroupOptions) *runtime.Pager[SQLServerLicensesClientListByResourceGroupResponse]` +- New function `*SQLServerLicensesClient.NewListPager(*SQLServerLicensesClientListOptions) *runtime.Pager[SQLServerLicensesClientListResponse]` +- New function `*SQLServerLicensesClient.Update(context.Context, string, string, SQLServerLicenseUpdate, *SQLServerLicensesClientUpdateOptions) (SQLServerLicensesClientUpdateResponse, error)` +- New struct `ArcSQLServerAvailabilityGroupListResult` +- New struct `ArcSQLServerDatabaseListResult` +- New struct `AvailabilityGroupConfigure` +- New struct `AvailabilityGroupCreateUpdateConfiguration` +- New struct `AvailabilityGroupCreateUpdateReplicaConfiguration` +- New struct `AvailabilityGroupInfo` +- New struct `AvailabilityGroupState` +- New struct `BackgroundJob` +- New struct `BackupPolicy` +- New struct `ClientConnection` +- New struct `DBMEndpoint` +- New struct `DataBaseMigration` +- New struct `DataBaseMigrationAssessment` +- New struct `DatabaseAssessmentsItem` +- New struct `Databases` +- New struct `DistributedAvailabilityGroupCreateUpdateAvailabilityGroupCertificateConfiguration` +- New struct `DistributedAvailabilityGroupCreateUpdateAvailabilityGroupConfiguration` +- New struct `DistributedAvailabilityGroupCreateUpdateConfiguration` +- New struct `ErrorAdditionalInfo` +- New struct `ErrorDetail` +- New struct `FailoverCluster` +- New struct `FailoverGroupListResult` +- New struct `FailoverGroupProperties` +- New struct `FailoverGroupResource` +- New struct `FailoverGroupSpec` +- New struct `K8SActiveDirectory` +- New struct `K8SActiveDirectoryConnector` +- New struct `K8SNetworkSettings` +- New struct `K8SSecurity` +- New struct `K8SSettings` +- New struct `K8StransparentDataEncryption` +- New struct `Migration` +- New struct `MigrationAssessment` +- New struct `Monitoring` +- New struct `ResourceAutoGenerated` +- New struct `SKURecommendationResults` +- New struct `SKURecommendationResultsAzureSQLDatabase` +- New struct `SKURecommendationResultsAzureSQLDatabaseTargetSKU` +- New struct `SKURecommendationResultsAzureSQLDatabaseTargetSKUCategory` +- New struct `SKURecommendationResultsAzureSQLManagedInstance` +- New struct `SKURecommendationResultsAzureSQLManagedInstanceTargetSKU` +- New struct `SKURecommendationResultsAzureSQLManagedInstanceTargetSKUCategory` +- New struct `SKURecommendationResultsAzureSQLVirtualMachine` +- New struct `SKURecommendationResultsAzureSQLVirtualMachineTargetSKU` +- New struct `SKURecommendationResultsAzureSQLVirtualMachineTargetSKUCategory` +- New struct `SKURecommendationResultsMonthlyCost` +- New struct `SKURecommendationSummary` +- New struct `SQLAvailabilityGroupDatabaseReplicaResourceProperties` +- New struct `SQLAvailabilityGroupDhcpListenerProperties` +- New struct `SQLAvailabilityGroupIPV4AddressesAndMasksPropertiesItem` +- New struct `SQLAvailabilityGroupReplicaResourceProperties` +- New struct `SQLAvailabilityGroupStaticIPListenerProperties` +- New struct `SQLServerAvailabilityGroupResource` +- New struct `SQLServerAvailabilityGroupResourceProperties` +- New struct `SQLServerAvailabilityGroupResourcePropertiesDatabases` +- New struct `SQLServerAvailabilityGroupResourcePropertiesReplicas` +- New struct `SQLServerAvailabilityGroupUpdate` +- New struct `SQLServerDatabaseResource` +- New struct `SQLServerDatabaseResourceProperties` +- New struct `SQLServerDatabaseResourcePropertiesBackupInformation` +- New struct `SQLServerDatabaseResourcePropertiesDatabaseOptions` +- New struct `SQLServerDatabaseUpdate` +- New struct `SQLServerEsuLicense` +- New struct `SQLServerEsuLicenseListResult` +- New struct `SQLServerEsuLicenseProperties` +- New struct `SQLServerEsuLicenseUpdate` +- New struct `SQLServerEsuLicenseUpdateProperties` +- New struct `SQLServerInstanceJobStatus` +- New struct `SQLServerInstanceJobsStatusRequest` +- New struct `SQLServerInstanceJobsStatusResponse` +- New struct `SQLServerInstanceRunMigrationAssessmentResponse` +- New struct `SQLServerInstanceTelemetryColumn` +- New struct `SQLServerInstanceTelemetryRequest` +- New struct `SQLServerInstanceTelemetryResponse` +- New struct `SQLServerInstanceUpdateProperties` +- New struct `SQLServerInstancesClientGetTelemetryResponse` +- New struct `SQLServerLicense` +- New struct `SQLServerLicenseListResult` +- New struct `SQLServerLicenseProperties` +- New struct `SQLServerLicenseUpdate` +- New struct `SQLServerLicenseUpdateProperties` +- New struct `SequencerAction` +- New struct `ServerAssessmentsItem` +- New struct `ServerAssessmentsPropertiesItemsItem` +- New struct `TargetReadiness` +- New struct `TrackedResourceAutoGenerated` +- New field `Security`, `Settings` in struct `SQLManagedInstanceK8SSpec` +- New field `AlwaysOnRole`, `BackupPolicy`, `ClientConnection`, `Cores`, `DatabaseMirroringEndpoint`, `DbMasterKeyExists`, `FailoverCluster`, `IsHadrEnabled`, `LastInventoryUploadTime`, `LastUsageUploadTime`, `Migration`, `Monitoring`, `ServiceType`, `TraceFlags`, `UpgradeLockedUntil` in struct `SQLServerInstanceProperties` +- New field `Properties` in struct `SQLServerInstanceUpdate` + + ## 0.7.0 (2023-11-24) ### Features Added diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/README.md b/sdk/resourcemanager/azurearcdata/armazurearcdata/README.md index 4a8f579a4094..ae4762b04dee 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/README.md +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/README.md @@ -57,7 +57,7 @@ clientFactory, err := armazurearcdata.NewClientFactory(, cred, A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory. ```go -client := clientFactory.NewSQLServerInstancesClient() +client := clientFactory.NewActiveDirectoryConnectorsClient() ``` ## Fakes diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/activedirectoryconnectors_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/activedirectoryconnectors_client.go index 24c249823c4a..cee247c8520c 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/activedirectoryconnectors_client.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/activedirectoryconnectors_client.go @@ -46,7 +46,7 @@ func NewActiveDirectoryConnectorsClient(subscriptionID string, credential azcore // BeginCreate - Creates or replaces an Active Directory connector resource. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - dataControllerName - The name of the data controller // - activeDirectoryConnectorName - The name of the Active Directory connector instance @@ -74,7 +74,7 @@ func (client *ActiveDirectoryConnectorsClient) BeginCreate(ctx context.Context, // Create - Creates or replaces an Active Directory connector resource. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *ActiveDirectoryConnectorsClient) create(ctx context.Context, resourceGroupName string, dataControllerName string, activeDirectoryConnectorName string, activeDirectoryConnectorResource ActiveDirectoryConnectorResource, options *ActiveDirectoryConnectorsClientBeginCreateOptions) (*http.Response, error) { var err error const operationName = "ActiveDirectoryConnectorsClient.BeginCreate" @@ -120,7 +120,7 @@ func (client *ActiveDirectoryConnectorsClient) createCreateRequest(ctx context.C return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} if err := runtime.MarshalAsJSON(req, activeDirectoryConnectorResource); err != nil { @@ -132,7 +132,7 @@ func (client *ActiveDirectoryConnectorsClient) createCreateRequest(ctx context.C // BeginDelete - Deletes an Active Directory connector resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - dataControllerName - The name of the data controller // - activeDirectoryConnectorName - The name of the Active Directory connector instance @@ -158,7 +158,7 @@ func (client *ActiveDirectoryConnectorsClient) BeginDelete(ctx context.Context, // Delete - Deletes an Active Directory connector resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *ActiveDirectoryConnectorsClient) deleteOperation(ctx context.Context, resourceGroupName string, dataControllerName string, activeDirectoryConnectorName string, options *ActiveDirectoryConnectorsClientBeginDeleteOptions) (*http.Response, error) { var err error const operationName = "ActiveDirectoryConnectorsClient.BeginDelete" @@ -204,7 +204,7 @@ func (client *ActiveDirectoryConnectorsClient) deleteCreateRequest(ctx context.C return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -213,7 +213,7 @@ func (client *ActiveDirectoryConnectorsClient) deleteCreateRequest(ctx context.C // Get - Retrieves an Active Directory connector resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - dataControllerName - The name of the data controller // - activeDirectoryConnectorName - The name of the Active Directory connector instance @@ -265,7 +265,7 @@ func (client *ActiveDirectoryConnectorsClient) getCreateRequest(ctx context.Cont return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -282,7 +282,7 @@ func (client *ActiveDirectoryConnectorsClient) getHandleResponse(resp *http.Resp // NewListPager - List the active directory connectors associated with the given data controller. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - dataControllerName - The name of the data controller // - options - ActiveDirectoryConnectorsClientListOptions contains the optional parameters for the ActiveDirectoryConnectorsClient.NewListPager @@ -330,7 +330,7 @@ func (client *ActiveDirectoryConnectorsClient) listCreateRequest(ctx context.Con return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/activedirectoryconnectors_client_example_test.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/activedirectoryconnectors_client_example_test.go deleted file mode 100644 index 442db827e2a1..000000000000 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/activedirectoryconnectors_client_example_test.go +++ /dev/null @@ -1,308 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armazurearcdata_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/ListByDataControllerActiveDirectoryConnector.json -func ExampleActiveDirectoryConnectorsClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewActiveDirectoryConnectorsClient().NewListPager("testrg", "testdataController", nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.ActiveDirectoryConnectorListResult = armazurearcdata.ActiveDirectoryConnectorListResult{ - // Value: []*armazurearcdata.ActiveDirectoryConnectorResource{ - // { - // Name: to.Ptr("testADConnector1"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers/activeDirectoryConnectors"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController/activeDirectoryConnectors/testADConnector1"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Properties: &armazurearcdata.ActiveDirectoryConnectorProperties{ - // Spec: &armazurearcdata.ActiveDirectoryConnectorSpec{ - // ActiveDirectory: &armazurearcdata.ActiveDirectoryConnectorDomainDetails{ - // DomainControllers: &armazurearcdata.ActiveDirectoryDomainControllers{ - // PrimaryDomainController: &armazurearcdata.ActiveDirectoryDomainController{ - // Hostname: to.Ptr("dc1.contoso.local"), - // }, - // SecondaryDomainControllers: []*armazurearcdata.ActiveDirectoryDomainController{ - // { - // Hostname: to.Ptr("dc2.contoso.local"), - // }, - // { - // Hostname: to.Ptr("dc3.contoso.local"), - // }}, - // }, - // NetbiosDomainName: to.Ptr("CONTOSO"), - // Realm: to.Ptr("CONTOSO.LOCAL"), - // ServiceAccountProvisioning: to.Ptr(armazurearcdata.AccountProvisioningModeManual), - // }, - // DNS: &armazurearcdata.ActiveDirectoryConnectorDNSDetails{ - // DomainName: to.Ptr("contoso.local"), - // NameserverIPAddresses: []*string{ - // to.Ptr("11.11.111.111"), - // to.Ptr("22.22.222.222")}, - // PreferK8SDNSForPtrLookups: to.Ptr(false), - // Replicas: to.Ptr[int64](1), - // }, - // }, - // }, - // }, - // { - // Name: to.Ptr("testADConnector2"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers/activeDirectoryConnectors"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController/activeDirectoryConnectors/testADConnector2"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Properties: &armazurearcdata.ActiveDirectoryConnectorProperties{ - // Spec: &armazurearcdata.ActiveDirectoryConnectorSpec{ - // ActiveDirectory: &armazurearcdata.ActiveDirectoryConnectorDomainDetails{ - // DomainControllers: &armazurearcdata.ActiveDirectoryDomainControllers{ - // PrimaryDomainController: &armazurearcdata.ActiveDirectoryDomainController{ - // Hostname: to.Ptr("dc4.contoso.local"), - // }, - // SecondaryDomainControllers: []*armazurearcdata.ActiveDirectoryDomainController{ - // { - // Hostname: to.Ptr("dc5.contoso.local"), - // }, - // { - // Hostname: to.Ptr("dc6.contoso.local"), - // }}, - // }, - // NetbiosDomainName: to.Ptr("CONTOSO"), - // Realm: to.Ptr("CONTOSO.LOCAL"), - // ServiceAccountProvisioning: to.Ptr(armazurearcdata.AccountProvisioningModeManual), - // }, - // DNS: &armazurearcdata.ActiveDirectoryConnectorDNSDetails{ - // DomainName: to.Ptr("contoso.local"), - // NameserverIPAddresses: []*string{ - // to.Ptr("11.11.111.111"), - // to.Ptr("22.22.222.222")}, - // PreferK8SDNSForPtrLookups: to.Ptr(false), - // Replicas: to.Ptr[int64](1), - // }, - // }, - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/CreateOrUpdateActiveDirectoryConnector.json -func ExampleActiveDirectoryConnectorsClient_BeginCreate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewActiveDirectoryConnectorsClient().BeginCreate(ctx, "testrg", "testdataController", "testADConnector", armazurearcdata.ActiveDirectoryConnectorResource{ - Properties: &armazurearcdata.ActiveDirectoryConnectorProperties{ - Spec: &armazurearcdata.ActiveDirectoryConnectorSpec{ - ActiveDirectory: &armazurearcdata.ActiveDirectoryConnectorDomainDetails{ - DomainControllers: &armazurearcdata.ActiveDirectoryDomainControllers{ - PrimaryDomainController: &armazurearcdata.ActiveDirectoryDomainController{ - Hostname: to.Ptr("dc1.contoso.local"), - }, - SecondaryDomainControllers: []*armazurearcdata.ActiveDirectoryDomainController{ - { - Hostname: to.Ptr("dc2.contoso.local"), - }, - { - Hostname: to.Ptr("dc3.contoso.local"), - }}, - }, - Realm: to.Ptr("CONTOSO.LOCAL"), - ServiceAccountProvisioning: to.Ptr(armazurearcdata.AccountProvisioningModeManual), - }, - DNS: &armazurearcdata.ActiveDirectoryConnectorDNSDetails{ - NameserverIPAddresses: []*string{ - to.Ptr("11.11.111.111"), - to.Ptr("22.22.222.222")}, - PreferK8SDNSForPtrLookups: to.Ptr(false), - Replicas: to.Ptr[int64](1), - }, - }, - }, - }, nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - res, err := poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.ActiveDirectoryConnectorResource = armazurearcdata.ActiveDirectoryConnectorResource{ - // Name: to.Ptr("testADConnector"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers/activeDirectoryConnectors"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController/activeDirectoryConnectors/testADConnector"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Properties: &armazurearcdata.ActiveDirectoryConnectorProperties{ - // Spec: &armazurearcdata.ActiveDirectoryConnectorSpec{ - // ActiveDirectory: &armazurearcdata.ActiveDirectoryConnectorDomainDetails{ - // DomainControllers: &armazurearcdata.ActiveDirectoryDomainControllers{ - // PrimaryDomainController: &armazurearcdata.ActiveDirectoryDomainController{ - // Hostname: to.Ptr("dc1.contoso.local"), - // }, - // SecondaryDomainControllers: []*armazurearcdata.ActiveDirectoryDomainController{ - // { - // Hostname: to.Ptr("dc2.contoso.local"), - // }, - // { - // Hostname: to.Ptr("dc3.contoso.local"), - // }}, - // }, - // NetbiosDomainName: to.Ptr("CONTOSO"), - // Realm: to.Ptr("CONTOSO.LOCAL"), - // ServiceAccountProvisioning: to.Ptr(armazurearcdata.AccountProvisioningModeManual), - // }, - // DNS: &armazurearcdata.ActiveDirectoryConnectorDNSDetails{ - // DomainName: to.Ptr("contoso.local"), - // NameserverIPAddresses: []*string{ - // to.Ptr("11.11.111.111"), - // to.Ptr("22.22.222.222")}, - // PreferK8SDNSForPtrLookups: to.Ptr(false), - // Replicas: to.Ptr[int64](1), - // }, - // }, - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/DeleteActiveDirectoryConnector.json -func ExampleActiveDirectoryConnectorsClient_BeginDelete() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewActiveDirectoryConnectorsClient().BeginDelete(ctx, "testrg", "testdataController", "testADConnector", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - _, err = poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/GetActiveDirectoryConnector.json -func ExampleActiveDirectoryConnectorsClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewActiveDirectoryConnectorsClient().Get(ctx, "testrg", "testdataController", "testADConnector", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.ActiveDirectoryConnectorResource = armazurearcdata.ActiveDirectoryConnectorResource{ - // Name: to.Ptr("testADConnector"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers/activeDirectoryConnectors"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController/activeDirectoryConnectors/testADConnector"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Properties: &armazurearcdata.ActiveDirectoryConnectorProperties{ - // Spec: &armazurearcdata.ActiveDirectoryConnectorSpec{ - // ActiveDirectory: &armazurearcdata.ActiveDirectoryConnectorDomainDetails{ - // DomainControllers: &armazurearcdata.ActiveDirectoryDomainControllers{ - // PrimaryDomainController: &armazurearcdata.ActiveDirectoryDomainController{ - // Hostname: to.Ptr("dc1.contoso.local"), - // }, - // SecondaryDomainControllers: []*armazurearcdata.ActiveDirectoryDomainController{ - // { - // Hostname: to.Ptr("dc2.contoso.local"), - // }, - // { - // Hostname: to.Ptr("dc3.contoso.local"), - // }}, - // }, - // NetbiosDomainName: to.Ptr("CONTOSO"), - // Realm: to.Ptr("CONTOSO.LOCAL"), - // ServiceAccountProvisioning: to.Ptr(armazurearcdata.AccountProvisioningModeManual), - // }, - // DNS: &armazurearcdata.ActiveDirectoryConnectorDNSDetails{ - // DomainName: to.Ptr("contoso.local"), - // NameserverIPAddresses: []*string{ - // to.Ptr("11.11.111.111"), - // to.Ptr("22.22.222.222")}, - // PreferK8SDNSForPtrLookups: to.Ptr(false), - // Replicas: to.Ptr[int64](1), - // }, - // }, - // }, - // } -} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/autorest.md b/sdk/resourcemanager/azurearcdata/armazurearcdata/autorest.md index d01be25fd761..3d9eed2a50e4 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/autorest.md +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/autorest.md @@ -5,9 +5,9 @@ ``` yaml azure-arm: true require: -- https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/readme.md -- https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/readme.go.md +- /mnt/vss/_work/1/s/azure-rest-api-specs/specification/azurearcdata/resource-manager/readme.md +- /mnt/vss/_work/1/s/azure-rest-api-specs/specification/azurearcdata/resource-manager/readme.go.md license-header: MICROSOFT_MIT_NO_VERSION -module-version: 0.7.0 +module-version: 0.8.0 ``` \ No newline at end of file diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/client_factory.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/client_factory.go index ae0b791b98fd..66ca7a438137 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/client_factory.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/client_factory.go @@ -17,8 +17,7 @@ import ( // Don't use this type directly, use NewClientFactory instead. type ClientFactory struct { subscriptionID string - credential azcore.TokenCredential - options *arm.ClientOptions + internal *arm.Client } // NewClientFactory creates a new instance of ClientFactory with the specified values. @@ -27,48 +26,99 @@ type ClientFactory struct { // - credential - used to authorize requests. Usually a credential from azidentity. // - options - pass nil to accept the default values. func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error) { - _, err := arm.NewClient(moduleName, moduleVersion, credential, options) + internal, err := arm.NewClient(moduleName, moduleVersion, credential, options) if err != nil { return nil, err } return &ClientFactory{ - subscriptionID: subscriptionID, credential: credential, - options: options.Clone(), + subscriptionID: subscriptionID, + internal: internal, }, nil } // NewActiveDirectoryConnectorsClient creates a new instance of ActiveDirectoryConnectorsClient. func (c *ClientFactory) NewActiveDirectoryConnectorsClient() *ActiveDirectoryConnectorsClient { - subClient, _ := NewActiveDirectoryConnectorsClient(c.subscriptionID, c.credential, c.options) - return subClient + return &ActiveDirectoryConnectorsClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } } // NewDataControllersClient creates a new instance of DataControllersClient. func (c *ClientFactory) NewDataControllersClient() *DataControllersClient { - subClient, _ := NewDataControllersClient(c.subscriptionID, c.credential, c.options) - return subClient + return &DataControllersClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} + +// NewFailoverGroupsClient creates a new instance of FailoverGroupsClient. +func (c *ClientFactory) NewFailoverGroupsClient() *FailoverGroupsClient { + return &FailoverGroupsClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } } // NewOperationsClient creates a new instance of OperationsClient. func (c *ClientFactory) NewOperationsClient() *OperationsClient { - subClient, _ := NewOperationsClient(c.credential, c.options) - return subClient + return &OperationsClient{ + internal: c.internal, + } } // NewPostgresInstancesClient creates a new instance of PostgresInstancesClient. func (c *ClientFactory) NewPostgresInstancesClient() *PostgresInstancesClient { - subClient, _ := NewPostgresInstancesClient(c.subscriptionID, c.credential, c.options) - return subClient + return &PostgresInstancesClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } } // NewSQLManagedInstancesClient creates a new instance of SQLManagedInstancesClient. func (c *ClientFactory) NewSQLManagedInstancesClient() *SQLManagedInstancesClient { - subClient, _ := NewSQLManagedInstancesClient(c.subscriptionID, c.credential, c.options) - return subClient + return &SQLManagedInstancesClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} + +// NewSQLServerAvailabilityGroupsClient creates a new instance of SQLServerAvailabilityGroupsClient. +func (c *ClientFactory) NewSQLServerAvailabilityGroupsClient() *SQLServerAvailabilityGroupsClient { + return &SQLServerAvailabilityGroupsClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} + +// NewSQLServerDatabasesClient creates a new instance of SQLServerDatabasesClient. +func (c *ClientFactory) NewSQLServerDatabasesClient() *SQLServerDatabasesClient { + return &SQLServerDatabasesClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} + +// NewSQLServerEsuLicensesClient creates a new instance of SQLServerEsuLicensesClient. +func (c *ClientFactory) NewSQLServerEsuLicensesClient() *SQLServerEsuLicensesClient { + return &SQLServerEsuLicensesClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } } // NewSQLServerInstancesClient creates a new instance of SQLServerInstancesClient. func (c *ClientFactory) NewSQLServerInstancesClient() *SQLServerInstancesClient { - subClient, _ := NewSQLServerInstancesClient(c.subscriptionID, c.credential, c.options) - return subClient + return &SQLServerInstancesClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} + +// NewSQLServerLicensesClient creates a new instance of SQLServerLicensesClient. +func (c *ClientFactory) NewSQLServerLicensesClient() *SQLServerLicensesClient { + return &SQLServerLicensesClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } } diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/constants.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/constants.go index 97c045338c68..ecf69749fee9 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/constants.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/constants.go @@ -10,7 +10,7 @@ package armazurearcdata const ( moduleName = "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" - moduleVersion = "v0.7.0" + moduleVersion = "v0.8.0" ) // AccountProvisioningMode - The service account provisioning mode for this Active Directory connector. @@ -29,6 +29,64 @@ func PossibleAccountProvisioningModeValues() []AccountProvisioningMode { } } +// ActivationState - The activation state of the license. +type ActivationState string + +const ( + ActivationStateActivated ActivationState = "Activated" + ActivationStateDeactivated ActivationState = "Deactivated" +) + +// PossibleActivationStateValues returns the possible values for the ActivationState const type. +func PossibleActivationStateValues() []ActivationState { + return []ActivationState{ + ActivationStateActivated, + ActivationStateDeactivated, + } +} + +// AggregationType - The aggregation type to use for the numerical columns in the dataset. +type AggregationType string + +const ( + AggregationTypeAverage AggregationType = "Average" + AggregationTypeCount AggregationType = "Count" + AggregationTypeMaximum AggregationType = "Maximum" + AggregationTypeMinimum AggregationType = "Minimum" + AggregationTypeSum AggregationType = "Sum" +) + +// PossibleAggregationTypeValues returns the possible values for the AggregationType const type. +func PossibleAggregationTypeValues() []AggregationType { + return []AggregationType{ + AggregationTypeAverage, + AggregationTypeCount, + AggregationTypeMaximum, + AggregationTypeMinimum, + AggregationTypeSum, + } +} + +// AlwaysOnRole - The role of the SQL Server, based on availability. +type AlwaysOnRole string + +const ( + AlwaysOnRoleAvailabilityGroupReplica AlwaysOnRole = "AvailabilityGroupReplica" + AlwaysOnRoleFailoverClusterInstance AlwaysOnRole = "FailoverClusterInstance" + AlwaysOnRoleFailoverClusterNode AlwaysOnRole = "FailoverClusterNode" + AlwaysOnRoleNone AlwaysOnRole = "None" +) + +// PossibleAlwaysOnRoleValues returns the possible values for the AlwaysOnRole const type. +func PossibleAlwaysOnRoleValues() []AlwaysOnRole { + return []AlwaysOnRole{ + AlwaysOnRoleAvailabilityGroupReplica, + AlwaysOnRoleFailoverClusterInstance, + AlwaysOnRoleFailoverClusterNode, + AlwaysOnRoleNone, + } +} + // ArcSQLManagedInstanceLicenseType - The license type to apply for this managed instance. type ArcSQLManagedInstanceLicenseType string @@ -47,14 +105,52 @@ func PossibleArcSQLManagedInstanceLicenseTypeValues() []ArcSQLManagedInstanceLic } } +// ArcSQLServerAvailabilityMode - Property that determines whether a given availability replica can run in synchronous-commit +// mode +type ArcSQLServerAvailabilityMode string + +const ( + ArcSQLServerAvailabilityModeASYNCHRONOUSCOMMIT ArcSQLServerAvailabilityMode = "ASYNCHRONOUS_COMMIT" + ArcSQLServerAvailabilityModeSYNCHRONOUSCOMMIT ArcSQLServerAvailabilityMode = "SYNCHRONOUS_COMMIT" +) + +// PossibleArcSQLServerAvailabilityModeValues returns the possible values for the ArcSQLServerAvailabilityMode const type. +func PossibleArcSQLServerAvailabilityModeValues() []ArcSQLServerAvailabilityMode { + return []ArcSQLServerAvailabilityMode{ + ArcSQLServerAvailabilityModeASYNCHRONOUSCOMMIT, + ArcSQLServerAvailabilityModeSYNCHRONOUSCOMMIT, + } +} + +// ArcSQLServerFailoverMode - Property to set the failover mode of the availability group replica +type ArcSQLServerFailoverMode string + +const ( + ArcSQLServerFailoverModeAUTOMATIC ArcSQLServerFailoverMode = "AUTOMATIC" + ArcSQLServerFailoverModeEXTERNAL ArcSQLServerFailoverMode = "EXTERNAL" + ArcSQLServerFailoverModeMANUAL ArcSQLServerFailoverMode = "MANUAL" +) + +// PossibleArcSQLServerFailoverModeValues returns the possible values for the ArcSQLServerFailoverMode const type. +func PossibleArcSQLServerFailoverModeValues() []ArcSQLServerFailoverMode { + return []ArcSQLServerFailoverMode{ + ArcSQLServerFailoverModeAUTOMATIC, + ArcSQLServerFailoverModeEXTERNAL, + ArcSQLServerFailoverModeMANUAL, + } +} + // ArcSQLServerLicenseType - SQL Server license type. type ArcSQLServerLicenseType string const ( - ArcSQLServerLicenseTypeFree ArcSQLServerLicenseType = "Free" - ArcSQLServerLicenseTypeHADR ArcSQLServerLicenseType = "HADR" - ArcSQLServerLicenseTypePaid ArcSQLServerLicenseType = "Paid" - ArcSQLServerLicenseTypeUndefined ArcSQLServerLicenseType = "Undefined" + ArcSQLServerLicenseTypeFree ArcSQLServerLicenseType = "Free" + ArcSQLServerLicenseTypeHADR ArcSQLServerLicenseType = "HADR" + ArcSQLServerLicenseTypeLicenseOnly ArcSQLServerLicenseType = "LicenseOnly" + ArcSQLServerLicenseTypePAYG ArcSQLServerLicenseType = "PAYG" + ArcSQLServerLicenseTypePaid ArcSQLServerLicenseType = "Paid" + ArcSQLServerLicenseTypeServerCAL ArcSQLServerLicenseType = "ServerCAL" + ArcSQLServerLicenseTypeUndefined ArcSQLServerLicenseType = "Undefined" ) // PossibleArcSQLServerLicenseTypeValues returns the possible values for the ArcSQLServerLicenseType const type. @@ -62,11 +158,99 @@ func PossibleArcSQLServerLicenseTypeValues() []ArcSQLServerLicenseType { return []ArcSQLServerLicenseType{ ArcSQLServerLicenseTypeFree, ArcSQLServerLicenseTypeHADR, + ArcSQLServerLicenseTypeLicenseOnly, + ArcSQLServerLicenseTypePAYG, ArcSQLServerLicenseTypePaid, + ArcSQLServerLicenseTypeServerCAL, ArcSQLServerLicenseTypeUndefined, } } +// AutomatedBackupPreference - Preferred replica for running automated backups. +type AutomatedBackupPreference string + +const ( + AutomatedBackupPreferenceNONE AutomatedBackupPreference = "NONE" + AutomatedBackupPreferencePRIMARY AutomatedBackupPreference = "PRIMARY" + AutomatedBackupPreferenceSECONDARY AutomatedBackupPreference = "SECONDARY" + AutomatedBackupPreferenceSECONDARYONLY AutomatedBackupPreference = "SECONDARY_ONLY" +) + +// PossibleAutomatedBackupPreferenceValues returns the possible values for the AutomatedBackupPreference const type. +func PossibleAutomatedBackupPreferenceValues() []AutomatedBackupPreference { + return []AutomatedBackupPreference{ + AutomatedBackupPreferenceNONE, + AutomatedBackupPreferencePRIMARY, + AutomatedBackupPreferenceSECONDARY, + AutomatedBackupPreferenceSECONDARYONLY, + } +} + +// BillingPlan - SQL Server ESU license type. +type BillingPlan string + +const ( + BillingPlanPAYG BillingPlan = "PAYG" + BillingPlanPaid BillingPlan = "Paid" +) + +// PossibleBillingPlanValues returns the possible values for the BillingPlan const type. +func PossibleBillingPlanValues() []BillingPlan { + return []BillingPlan{ + BillingPlanPAYG, + BillingPlanPaid, + } +} + +// ClusterType - Set to WSFC when availability group is on a failover cluster instance on a Windows Server failover cluster. +// Set to NONE when availability group not using WSFC for cluster coordination. +type ClusterType string + +const ( + ClusterTypeNONE ClusterType = "NONE" + ClusterTypeWSFC ClusterType = "WSFC" +) + +// PossibleClusterTypeValues returns the possible values for the ClusterType const type. +func PossibleClusterTypeValues() []ClusterType { + return []ClusterType{ + ClusterTypeNONE, + ClusterTypeWSFC, + } +} + +// ConnectionAuth - The endpoint connection authentication type(s). +type ConnectionAuth string + +const ( + ConnectionAuthCertificate ConnectionAuth = "Certificate" + ConnectionAuthCertificateWindowsKerberos ConnectionAuth = "Certificate_Windows_Kerberos" + ConnectionAuthCertificateWindowsNTLM ConnectionAuth = "Certificate_Windows_NTLM" + ConnectionAuthCertificateWindowsNegotiate ConnectionAuth = "Certificate_Windows_Negotiate" + ConnectionAuthWindowsKerberos ConnectionAuth = "Windows_Kerberos" + ConnectionAuthWindowsKerberosCertificate ConnectionAuth = "Windows_Kerberos_Certificate" + ConnectionAuthWindowsNTLM ConnectionAuth = "Windows_NTLM" + ConnectionAuthWindowsNTLMCertificate ConnectionAuth = "Windows_NTLM_Certificate" + ConnectionAuthWindowsNegotiate ConnectionAuth = "Windows_Negotiate" + ConnectionAuthWindowsNegotiateCertificate ConnectionAuth = "Windows_Negotiate_Certificate" +) + +// PossibleConnectionAuthValues returns the possible values for the ConnectionAuth const type. +func PossibleConnectionAuthValues() []ConnectionAuth { + return []ConnectionAuth{ + ConnectionAuthCertificate, + ConnectionAuthCertificateWindowsKerberos, + ConnectionAuthCertificateWindowsNTLM, + ConnectionAuthCertificateWindowsNegotiate, + ConnectionAuthWindowsKerberos, + ConnectionAuthWindowsKerberosCertificate, + ConnectionAuthWindowsNTLM, + ConnectionAuthWindowsNTLMCertificate, + ConnectionAuthWindowsNegotiate, + ConnectionAuthWindowsNegotiateCertificate, + } +} + // ConnectionStatus - The cloud connectivity status. type ConnectionStatus string @@ -107,6 +291,69 @@ func PossibleCreatedByTypeValues() []CreatedByType { } } +// DatabaseCreateMode - Database create mode. PointInTimeRestore: Create a database by restoring a point in time backup of +// an existing database. sourceDatabaseId and restorePointInTime must be specified. +type DatabaseCreateMode string + +const ( + DatabaseCreateModeDefault DatabaseCreateMode = "Default" + DatabaseCreateModePointInTimeRestore DatabaseCreateMode = "PointInTimeRestore" +) + +// PossibleDatabaseCreateModeValues returns the possible values for the DatabaseCreateMode const type. +func PossibleDatabaseCreateModeValues() []DatabaseCreateMode { + return []DatabaseCreateMode{ + DatabaseCreateModeDefault, + DatabaseCreateModePointInTimeRestore, + } +} + +// DatabaseState - State of the database. +type DatabaseState string + +const ( + DatabaseStateCopying DatabaseState = "Copying" + DatabaseStateEmergency DatabaseState = "Emergency" + DatabaseStateOffline DatabaseState = "Offline" + DatabaseStateOfflineSecondary DatabaseState = "OfflineSecondary" + DatabaseStateOnline DatabaseState = "Online" + DatabaseStateRecovering DatabaseState = "Recovering" + DatabaseStateRecoveryPending DatabaseState = "RecoveryPending" + DatabaseStateRestoring DatabaseState = "Restoring" + DatabaseStateSuspect DatabaseState = "Suspect" +) + +// PossibleDatabaseStateValues returns the possible values for the DatabaseState const type. +func PossibleDatabaseStateValues() []DatabaseState { + return []DatabaseState{ + DatabaseStateCopying, + DatabaseStateEmergency, + DatabaseStateOffline, + DatabaseStateOfflineSecondary, + DatabaseStateOnline, + DatabaseStateRecovering, + DatabaseStateRecoveryPending, + DatabaseStateRestoring, + DatabaseStateSuspect, + } +} + +// DbFailover - Specifies whether the availability group supports failover for database health conditions. +type DbFailover string + +const ( + DbFailoverOFF DbFailover = "OFF" + DbFailoverON DbFailover = "ON" +) + +// PossibleDbFailoverValues returns the possible values for the DbFailover const type. +func PossibleDbFailoverValues() []DbFailover { + return []DbFailover{ + DbFailoverOFF, + DbFailoverON, + } +} + // DefenderStatus - Status of Azure Defender. type DefenderStatus string @@ -125,21 +372,55 @@ func PossibleDefenderStatusValues() []DefenderStatus { } } +// DifferentialBackupHours - The differential backup interval in hours. +type DifferentialBackupHours int32 + +const ( + DifferentialBackupHoursTwelve DifferentialBackupHours = 12 + DifferentialBackupHoursTwentyFour DifferentialBackupHours = 24 +) + +// PossibleDifferentialBackupHoursValues returns the possible values for the DifferentialBackupHours const type. +func PossibleDifferentialBackupHoursValues() []DifferentialBackupHours { + return []DifferentialBackupHours{ + DifferentialBackupHoursTwelve, + DifferentialBackupHoursTwentyFour, + } +} + +// DtcSupport - Specifies whether DTC support has been enabled for this availability group. +type DtcSupport string + +const ( + DtcSupportNONE DtcSupport = "NONE" + DtcSupportPERDB DtcSupport = "PER_DB" +) + +// PossibleDtcSupportValues returns the possible values for the DtcSupport const type. +func PossibleDtcSupportValues() []DtcSupport { + return []DtcSupport{ + DtcSupportNONE, + DtcSupportPERDB, + } +} + // EditionType - SQL Server edition. type EditionType string const ( - EditionTypeDeveloper EditionType = "Developer" - EditionTypeEnterprise EditionType = "Enterprise" - EditionTypeEvaluation EditionType = "Evaluation" - EditionTypeExpress EditionType = "Express" - EditionTypeStandard EditionType = "Standard" - EditionTypeWeb EditionType = "Web" + EditionTypeBusinessIntelligence EditionType = "Business Intelligence" + EditionTypeDeveloper EditionType = "Developer" + EditionTypeEnterprise EditionType = "Enterprise" + EditionTypeEvaluation EditionType = "Evaluation" + EditionTypeExpress EditionType = "Express" + EditionTypeStandard EditionType = "Standard" + EditionTypeWeb EditionType = "Web" ) // PossibleEditionTypeValues returns the possible values for the EditionType const type. func PossibleEditionTypeValues() []EditionType { return []EditionType{ + EditionTypeBusinessIntelligence, EditionTypeDeveloper, EditionTypeEnterprise, EditionTypeEvaluation, @@ -149,6 +430,52 @@ func PossibleEditionTypeValues() []EditionType { } } +// EncryptionAlgorithm - The encryption algorithm(s) used by the endpoint. +type EncryptionAlgorithm string + +const ( + EncryptionAlgorithmAES EncryptionAlgorithm = "AES" + EncryptionAlgorithmAESRC4 EncryptionAlgorithm = "AES, RC4" + EncryptionAlgorithmNONE EncryptionAlgorithm = "NONE" + EncryptionAlgorithmNONEAES EncryptionAlgorithm = "NONE, AES" + EncryptionAlgorithmNONEAESRC4 EncryptionAlgorithm = "NONE, AES, RC4" + EncryptionAlgorithmNONERC4 EncryptionAlgorithm = "NONE, RC4" + EncryptionAlgorithmNONERC4AES EncryptionAlgorithm = "NONE, RC4, AES" + EncryptionAlgorithmRC4 EncryptionAlgorithm = "RC4" + EncryptionAlgorithmRC4AES EncryptionAlgorithm = "RC4, AES" +) + +// PossibleEncryptionAlgorithmValues returns the possible values for the EncryptionAlgorithm const type. +func PossibleEncryptionAlgorithmValues() []EncryptionAlgorithm { + return []EncryptionAlgorithm{ + EncryptionAlgorithmAES, + EncryptionAlgorithmAESRC4, + EncryptionAlgorithmNONE, + EncryptionAlgorithmNONEAES, + EncryptionAlgorithmNONEAESRC4, + EncryptionAlgorithmNONERC4, + EncryptionAlgorithmNONERC4AES, + EncryptionAlgorithmRC4, + EncryptionAlgorithmRC4AES, + } +} + +// ExecutionState - The execution state of the background job. +type ExecutionState string + +const ( + ExecutionStateRunning ExecutionState = "Running" + ExecutionStateWaiting ExecutionState = "Waiting" +) + +// PossibleExecutionStateValues returns the possible values for the ExecutionState const type. +func PossibleExecutionStateValues() []ExecutionState { + return []ExecutionState{ + ExecutionStateRunning, + ExecutionStateWaiting, + } +} + // ExtendedLocationTypes - The type of extendedLocation. type ExtendedLocationTypes string @@ -163,21 +490,75 @@ func PossibleExtendedLocationTypesValues() []ExtendedLocationTypes { } } +// FailoverGroupPartnerSyncMode - The partner sync mode of the SQL managed instance. +type FailoverGroupPartnerSyncMode string + +const ( + FailoverGroupPartnerSyncModeAsync FailoverGroupPartnerSyncMode = "async" + FailoverGroupPartnerSyncModeSync FailoverGroupPartnerSyncMode = "sync" +) + +// PossibleFailoverGroupPartnerSyncModeValues returns the possible values for the FailoverGroupPartnerSyncMode const type. +func PossibleFailoverGroupPartnerSyncModeValues() []FailoverGroupPartnerSyncMode { + return []FailoverGroupPartnerSyncMode{ + FailoverGroupPartnerSyncModeAsync, + FailoverGroupPartnerSyncModeSync, + } +} + +// FailureConditionLevel - User-defined failure condition level under which an automatic failover must be triggered. +type FailureConditionLevel int32 + +const ( + FailureConditionLevelFive FailureConditionLevel = 5 + FailureConditionLevelFour FailureConditionLevel = 4 + FailureConditionLevelOne FailureConditionLevel = 1 + FailureConditionLevelThree FailureConditionLevel = 3 + FailureConditionLevelTwo FailureConditionLevel = 2 +) + +// PossibleFailureConditionLevelValues returns the possible values for the FailureConditionLevel const type. +func PossibleFailureConditionLevelValues() []FailureConditionLevel { + return []FailureConditionLevel{ + FailureConditionLevelFive, + FailureConditionLevelFour, + FailureConditionLevelOne, + FailureConditionLevelThree, + FailureConditionLevelTwo, + } +} + // HostType - Type of host for Azure Arc SQL Server type HostType string const ( - HostTypeAWSVirtualMachine HostType = "AWS Virtual Machine" - HostTypeGCPVirtualMachine HostType = "GCP Virtual Machine" - HostTypeOther HostType = "Other" - HostTypePhysicalServer HostType = "Physical Server" - HostTypeVirtualMachine HostType = "Virtual Machine" + HostTypeAWSKubernetesService HostType = "AWS Kubernetes Service" + HostTypeAWSVMWareVirtualMachine HostType = "AWS VMWare Virtual Machine" + HostTypeAWSVirtualMachine HostType = "AWS Virtual Machine" + HostTypeAzureKubernetesService HostType = "Azure Kubernetes Service" + HostTypeAzureVMWareVirtualMachine HostType = "Azure VMWare Virtual Machine" + HostTypeAzureVirtualMachine HostType = "Azure Virtual Machine" + HostTypeContainer HostType = "Container" + HostTypeGCPKubernetesService HostType = "GCP Kubernetes Service" + HostTypeGCPVMWareVirtualMachine HostType = "GCP VMWare Virtual Machine" + HostTypeGCPVirtualMachine HostType = "GCP Virtual Machine" + HostTypeOther HostType = "Other" + HostTypePhysicalServer HostType = "Physical Server" + HostTypeVirtualMachine HostType = "Virtual Machine" ) // PossibleHostTypeValues returns the possible values for the HostType const type. func PossibleHostTypeValues() []HostType { return []HostType{ + HostTypeAWSKubernetesService, + HostTypeAWSVMWareVirtualMachine, HostTypeAWSVirtualMachine, + HostTypeAzureKubernetesService, + HostTypeAzureVMWareVirtualMachine, + HostTypeAzureVirtualMachine, + HostTypeContainer, + HostTypeGCPKubernetesService, + HostTypeGCPVMWareVirtualMachine, HostTypeGCPVirtualMachine, HostTypeOther, HostTypePhysicalServer, @@ -209,6 +590,84 @@ func PossibleInfrastructureValues() []Infrastructure { } } +// InstanceFailoverGroupRole - The role of the SQL managed instance in this failover group. +type InstanceFailoverGroupRole string + +const ( + InstanceFailoverGroupRoleForcePrimaryAllowDataLoss InstanceFailoverGroupRole = "force-primary-allow-data-loss" + InstanceFailoverGroupRoleForceSecondary InstanceFailoverGroupRole = "force-secondary" + InstanceFailoverGroupRolePrimary InstanceFailoverGroupRole = "primary" + InstanceFailoverGroupRoleSecondary InstanceFailoverGroupRole = "secondary" +) + +// PossibleInstanceFailoverGroupRoleValues returns the possible values for the InstanceFailoverGroupRole const type. +func PossibleInstanceFailoverGroupRoleValues() []InstanceFailoverGroupRole { + return []InstanceFailoverGroupRole{ + InstanceFailoverGroupRoleForcePrimaryAllowDataLoss, + InstanceFailoverGroupRoleForceSecondary, + InstanceFailoverGroupRolePrimary, + InstanceFailoverGroupRoleSecondary, + } +} + +// JobStatus - The status of the job. +type JobStatus string + +const ( + JobStatusFailed JobStatus = "Failed" + JobStatusInProgress JobStatus = "InProgress" + JobStatusNotStarted JobStatus = "NotStarted" + JobStatusSucceeded JobStatus = "Succeeded" +) + +// PossibleJobStatusValues returns the possible values for the JobStatus const type. +func PossibleJobStatusValues() []JobStatus { + return []JobStatus{ + JobStatusFailed, + JobStatusInProgress, + JobStatusNotStarted, + JobStatusSucceeded, + } +} + +// LastExecutionStatus - The last execution status of the background job. +type LastExecutionStatus string + +const ( + LastExecutionStatusCompleted LastExecutionStatus = "Completed" + LastExecutionStatusFailed LastExecutionStatus = "Failed" + LastExecutionStatusFaulted LastExecutionStatus = "Faulted" + LastExecutionStatusPostponed LastExecutionStatus = "Postponed" + LastExecutionStatusRescheduled LastExecutionStatus = "Rescheduled" + LastExecutionStatusSucceeded LastExecutionStatus = "Succeeded" +) + +// PossibleLastExecutionStatusValues returns the possible values for the LastExecutionStatus const type. +func PossibleLastExecutionStatusValues() []LastExecutionStatus { + return []LastExecutionStatus{ + LastExecutionStatusCompleted, + LastExecutionStatusFailed, + LastExecutionStatusFaulted, + LastExecutionStatusPostponed, + LastExecutionStatusRescheduled, + LastExecutionStatusSucceeded, + } +} + +// LicenseCategory - This property represents the choice between SQL Server Core and ESU licenses. +type LicenseCategory string + +const ( + LicenseCategoryCore LicenseCategory = "Core" +) + +// PossibleLicenseCategoryValues returns the possible values for the LicenseCategory const type. +func PossibleLicenseCategoryValues() []LicenseCategory { + return []LicenseCategory{ + LicenseCategoryCore, + } +} + // OperationOrigin - The intended executor of the operation. type OperationOrigin string @@ -225,6 +684,140 @@ func PossibleOperationOriginValues() []OperationOrigin { } } +// PrimaryAllowConnections - Whether the primary replica should allow all connections or only READ_WRITE connections (disallowing +// ReadOnly connections) +type PrimaryAllowConnections string + +const ( + PrimaryAllowConnectionsALL PrimaryAllowConnections = "ALL" + PrimaryAllowConnectionsREADWRITE PrimaryAllowConnections = "READ_WRITE" +) + +// PossiblePrimaryAllowConnectionsValues returns the possible values for the PrimaryAllowConnections const type. +func PossiblePrimaryAllowConnectionsValues() []PrimaryAllowConnections { + return []PrimaryAllowConnections{ + PrimaryAllowConnectionsALL, + PrimaryAllowConnectionsREADWRITE, + } +} + +// ProvisioningState - The provisioning state of the failover group resource. +type ProvisioningState string + +const ( + ProvisioningStateAccepted ProvisioningState = "Accepted" + ProvisioningStateCanceled ProvisioningState = "Canceled" + ProvisioningStateFailed ProvisioningState = "Failed" + ProvisioningStateSucceeded ProvisioningState = "Succeeded" +) + +// PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type. +func PossibleProvisioningStateValues() []ProvisioningState { + return []ProvisioningState{ + ProvisioningStateAccepted, + ProvisioningStateCanceled, + ProvisioningStateFailed, + ProvisioningStateSucceeded, + } +} + +// RecommendationStatus - The target recommendation Status for this database. +type RecommendationStatus string + +const ( + RecommendationStatusNotReady RecommendationStatus = "NotReady" + RecommendationStatusReady RecommendationStatus = "Ready" + RecommendationStatusUnknown RecommendationStatus = "Unknown" +) + +// PossibleRecommendationStatusValues returns the possible values for the RecommendationStatus const type. +func PossibleRecommendationStatusValues() []RecommendationStatus { + return []RecommendationStatus{ + RecommendationStatusNotReady, + RecommendationStatusReady, + RecommendationStatusUnknown, + } +} + +// RecoveryMode - Status of the database. +type RecoveryMode string + +const ( + RecoveryModeBulkLogged RecoveryMode = "Bulk-logged" + RecoveryModeFull RecoveryMode = "Full" + RecoveryModeSimple RecoveryMode = "Simple" +) + +// PossibleRecoveryModeValues returns the possible values for the RecoveryMode const type. +func PossibleRecoveryModeValues() []RecoveryMode { + return []RecoveryMode{ + RecoveryModeBulkLogged, + RecoveryModeFull, + RecoveryModeSimple, + } +} + +type ReplicationPartnerType string + +const ( + ReplicationPartnerTypeAzureSQLManagedInstance ReplicationPartnerType = "AzureSQLManagedInstance" + ReplicationPartnerTypeAzureSQLVM ReplicationPartnerType = "AzureSQLVM" + ReplicationPartnerTypeSQLServer ReplicationPartnerType = "SQLServer" + ReplicationPartnerTypeUnknown ReplicationPartnerType = "Unknown" +) + +// PossibleReplicationPartnerTypeValues returns the possible values for the ReplicationPartnerType const type. +func PossibleReplicationPartnerTypeValues() []ReplicationPartnerType { + return []ReplicationPartnerType{ + ReplicationPartnerTypeAzureSQLManagedInstance, + ReplicationPartnerTypeAzureSQLVM, + ReplicationPartnerTypeSQLServer, + ReplicationPartnerTypeUnknown, + } +} + +// Result - The result of the sequencer action. +type Result string + +const ( + ResultFailed Result = "Failed" + ResultNotCompleted Result = "NotCompleted" + ResultSkipped Result = "Skipped" + ResultSucceeded Result = "Succeeded" + ResultTimedOut Result = "TimedOut" +) + +// PossibleResultValues returns the possible values for the Result const type. +func PossibleResultValues() []Result { + return []Result{ + ResultFailed, + ResultNotCompleted, + ResultSkipped, + ResultSucceeded, + ResultTimedOut, + } +} + +// Role - Mirroring Role +type Role string + +const ( + RoleALL Role = "ALL" + RoleNONE Role = "NONE" + RolePARTNER Role = "PARTNER" + RoleWITNESS Role = "WITNESS" +) + +// PossibleRoleValues returns the possible values for the Role const type. +func PossibleRoleValues() []Role { + return []Role{ + RoleALL, + RoleNONE, + RolePARTNER, + RoleWITNESS, + } +} + // SQLManagedInstanceSKUTier - The pricing tier for the instance. type SQLManagedInstanceSKUTier string @@ -241,6 +834,34 @@ func PossibleSQLManagedInstanceSKUTierValues() []SQLManagedInstanceSKUTier { } } +// SQLServerInstanceTelemetryColumnType - The type of the telemetry column. +type SQLServerInstanceTelemetryColumnType string + +const ( + SQLServerInstanceTelemetryColumnTypeBool SQLServerInstanceTelemetryColumnType = "bool" + SQLServerInstanceTelemetryColumnTypeDatetime SQLServerInstanceTelemetryColumnType = "datetime" + SQLServerInstanceTelemetryColumnTypeDouble SQLServerInstanceTelemetryColumnType = "double" + SQLServerInstanceTelemetryColumnTypeGUID SQLServerInstanceTelemetryColumnType = "guid" + SQLServerInstanceTelemetryColumnTypeInt SQLServerInstanceTelemetryColumnType = "int" + SQLServerInstanceTelemetryColumnTypeLong SQLServerInstanceTelemetryColumnType = "long" + SQLServerInstanceTelemetryColumnTypeString SQLServerInstanceTelemetryColumnType = "string" + SQLServerInstanceTelemetryColumnTypeTimespan SQLServerInstanceTelemetryColumnType = "timespan" +) + +// PossibleSQLServerInstanceTelemetryColumnTypeValues returns the possible values for the SQLServerInstanceTelemetryColumnType const type. +func PossibleSQLServerInstanceTelemetryColumnTypeValues() []SQLServerInstanceTelemetryColumnType { + return []SQLServerInstanceTelemetryColumnType{ + SQLServerInstanceTelemetryColumnTypeBool, + SQLServerInstanceTelemetryColumnTypeDatetime, + SQLServerInstanceTelemetryColumnTypeDouble, + SQLServerInstanceTelemetryColumnTypeGUID, + SQLServerInstanceTelemetryColumnTypeInt, + SQLServerInstanceTelemetryColumnTypeLong, + SQLServerInstanceTelemetryColumnTypeString, + SQLServerInstanceTelemetryColumnTypeTimespan, + } +} + // SQLVersion - SQL Server version. type SQLVersion string @@ -266,3 +887,156 @@ func PossibleSQLVersionValues() []SQLVersion { SQLVersionUnknown, } } + +// ScopeType - The Azure scope to which the license will apply. +type ScopeType string + +const ( + ScopeTypeResourceGroup ScopeType = "ResourceGroup" + ScopeTypeSubscription ScopeType = "Subscription" + ScopeTypeTenant ScopeType = "Tenant" +) + +// PossibleScopeTypeValues returns the possible values for the ScopeType const type. +func PossibleScopeTypeValues() []ScopeType { + return []ScopeType{ + ScopeTypeResourceGroup, + ScopeTypeSubscription, + ScopeTypeTenant, + } +} + +// SecondaryAllowConnections - Whether the secondary replica should allow all connections, no connections, or only ReadOnly +// connections. +type SecondaryAllowConnections string + +const ( + SecondaryAllowConnectionsALL SecondaryAllowConnections = "ALL" + SecondaryAllowConnectionsNO SecondaryAllowConnections = "NO" + SecondaryAllowConnectionsREADONLY SecondaryAllowConnections = "READ_ONLY" +) + +// PossibleSecondaryAllowConnectionsValues returns the possible values for the SecondaryAllowConnections const type. +func PossibleSecondaryAllowConnectionsValues() []SecondaryAllowConnections { + return []SecondaryAllowConnections{ + SecondaryAllowConnectionsALL, + SecondaryAllowConnectionsNO, + SecondaryAllowConnectionsREADONLY, + } +} + +// SeedingMode - Specifies how the secondary replica will be initially seeded. AUTOMATIC enables direct seeding. This method +// will seed the secondary replica over the network. This method does not require you to backup +// and restore a copy of the primary database on the replica. MANUAL specifies manual seeding (default). This method requires +// you to create a backup of the database on the primary replica and manually +// restore that backup on the secondary replica. +type SeedingMode string + +const ( + SeedingModeAUTOMATIC SeedingMode = "AUTOMATIC" + SeedingModeMANUAL SeedingMode = "MANUAL" +) + +// PossibleSeedingModeValues returns the possible values for the SeedingMode const type. +func PossibleSeedingModeValues() []SeedingMode { + return []SeedingMode{ + SeedingModeAUTOMATIC, + SeedingModeMANUAL, + } +} + +// SequencerState - The state of the sequencer action. +type SequencerState string + +const ( + SequencerStateCompleted SequencerState = "Completed" + SequencerStateCreatingSuccessors SequencerState = "CreatingSuccessors" + SequencerStateExecutingAction SequencerState = "ExecutingAction" + SequencerStateNotStarted SequencerState = "NotStarted" + SequencerStateWaitingPredecessors SequencerState = "WaitingPredecessors" +) + +// PossibleSequencerStateValues returns the possible values for the SequencerState const type. +func PossibleSequencerStateValues() []SequencerState { + return []SequencerState{ + SequencerStateCompleted, + SequencerStateCreatingSuccessors, + SequencerStateExecutingAction, + SequencerStateNotStarted, + SequencerStateWaitingPredecessors, + } +} + +// ServiceType - Indicates if the resource represents a SQL Server engine or a SQL Server component service installed on the +// host. +type ServiceType string + +const ( + // ServiceTypeEngine - SQL Server Database Services. + ServiceTypeEngine ServiceType = "Engine" + // ServiceTypePBIRS - Power BI Report Server. + ServiceTypePBIRS ServiceType = "PBIRS" + // ServiceTypeSSAS - SQL Server Analysis Services. + ServiceTypeSSAS ServiceType = "SSAS" + // ServiceTypeSSIS - SQL Server Integration Services. + ServiceTypeSSIS ServiceType = "SSIS" + // ServiceTypeSSRS - SQL Server Reporting Services. + ServiceTypeSSRS ServiceType = "SSRS" +) + +// PossibleServiceTypeValues returns the possible values for the ServiceType const type. +func PossibleServiceTypeValues() []ServiceType { + return []ServiceType{ + ServiceTypeEngine, + ServiceTypePBIRS, + ServiceTypeSSAS, + ServiceTypeSSIS, + ServiceTypeSSRS, + } +} + +// State - The activation state of the license. +type State string + +const ( + StateActive State = "Active" + StateCompleted State = "Completed" + StateDeleted State = "Deleted" + StateDisabled State = "Disabled" + StateEnabled State = "Enabled" + StateFaulted State = "Faulted" + StateInactive State = "Inactive" + StateSuspended State = "Suspended" + StateTerminated State = "Terminated" +) + +// PossibleStateValues returns the possible values for the State const type. +func PossibleStateValues() []State { + return []State{ + StateActive, + StateCompleted, + StateDeleted, + StateDisabled, + StateEnabled, + StateFaulted, + StateInactive, + StateSuspended, + StateTerminated, + } +} + +// Version - The SQL Server version the license covers. +type Version string + +const ( + VersionSQLServer2012 Version = "SQL Server 2012" + VersionSQLServer2014 Version = "SQL Server 2014" +) + +// PossibleVersionValues returns the possible values for the Version const type. +func PossibleVersionValues() []Version { + return []Version{ + VersionSQLServer2012, + VersionSQLServer2014, + } +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/datacontrollers_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/datacontrollers_client.go index 2eb72020b226..0fd4452942e9 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/datacontrollers_client.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/datacontrollers_client.go @@ -46,7 +46,7 @@ func NewDataControllersClient(subscriptionID string, credential azcore.TokenCred // BeginDeleteDataController - Deletes a dataController resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - dataControllerName - The name of the data controller // - options - DataControllersClientBeginDeleteDataControllerOptions contains the optional parameters for the DataControllersClient.BeginDeleteDataController @@ -71,7 +71,7 @@ func (client *DataControllersClient) BeginDeleteDataController(ctx context.Conte // DeleteDataController - Deletes a dataController resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *DataControllersClient) deleteDataController(ctx context.Context, resourceGroupName string, dataControllerName string, options *DataControllersClientBeginDeleteDataControllerOptions) (*http.Response, error) { var err error const operationName = "DataControllersClient.BeginDeleteDataController" @@ -113,7 +113,7 @@ func (client *DataControllersClient) deleteDataControllerCreateRequest(ctx conte return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -122,7 +122,7 @@ func (client *DataControllersClient) deleteDataControllerCreateRequest(ctx conte // GetDataController - Retrieves a dataController resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - dataControllerName - The name of the data controller // - options - DataControllersClientGetDataControllerOptions contains the optional parameters for the DataControllersClient.GetDataController @@ -169,7 +169,7 @@ func (client *DataControllersClient) getDataControllerCreateRequest(ctx context. return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -186,7 +186,7 @@ func (client *DataControllersClient) getDataControllerHandleResponse(resp *http. // NewListInGroupPager - List dataController resources in the resource group // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - options - DataControllersClientListInGroupOptions contains the optional parameters for the DataControllersClient.NewListInGroupPager // method. @@ -229,7 +229,7 @@ func (client *DataControllersClient) listInGroupCreateRequest(ctx context.Contex return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -246,7 +246,7 @@ func (client *DataControllersClient) listInGroupHandleResponse(resp *http.Respon // NewListInSubscriptionPager - List dataController resources in the subscription // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - options - DataControllersClientListInSubscriptionOptions contains the optional parameters for the DataControllersClient.NewListInSubscriptionPager // method. func (client *DataControllersClient) NewListInSubscriptionPager(options *DataControllersClientListInSubscriptionOptions) *runtime.Pager[DataControllersClientListInSubscriptionResponse] { @@ -284,7 +284,7 @@ func (client *DataControllersClient) listInSubscriptionCreateRequest(ctx context return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -302,7 +302,7 @@ func (client *DataControllersClient) listInSubscriptionHandleResponse(resp *http // BeginPatchDataController - Updates a dataController resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - dataControllerName - The name of the data controller // - dataControllerResource - The update data controller resource @@ -329,7 +329,7 @@ func (client *DataControllersClient) BeginPatchDataController(ctx context.Contex // PatchDataController - Updates a dataController resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *DataControllersClient) patchDataController(ctx context.Context, resourceGroupName string, dataControllerName string, dataControllerResource DataControllerUpdate, options *DataControllersClientBeginPatchDataControllerOptions) (*http.Response, error) { var err error const operationName = "DataControllersClient.BeginPatchDataController" @@ -371,7 +371,7 @@ func (client *DataControllersClient) patchDataControllerCreateRequest(ctx contex return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} if err := runtime.MarshalAsJSON(req, dataControllerResource); err != nil { @@ -383,7 +383,7 @@ func (client *DataControllersClient) patchDataControllerCreateRequest(ctx contex // BeginPutDataController - Creates or replaces a dataController resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - dataControllerName - The name of the data controller // - dataControllerResource - desc @@ -410,7 +410,7 @@ func (client *DataControllersClient) BeginPutDataController(ctx context.Context, // PutDataController - Creates or replaces a dataController resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *DataControllersClient) putDataController(ctx context.Context, resourceGroupName string, dataControllerName string, dataControllerResource DataControllerResource, options *DataControllersClientBeginPutDataControllerOptions) (*http.Response, error) { var err error const operationName = "DataControllersClient.BeginPutDataController" @@ -452,7 +452,7 @@ func (client *DataControllersClient) putDataControllerCreateRequest(ctx context. return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} if err := runtime.MarshalAsJSON(req, dataControllerResource); err != nil { diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/datacontrollers_client_example_test.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/datacontrollers_client_example_test.go deleted file mode 100644 index def015b1fb66..000000000000 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/datacontrollers_client_example_test.go +++ /dev/null @@ -1,579 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armazurearcdata_test - -import ( - "context" - "log" - - "time" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/ListSubscriptionDataController.json -func ExampleDataControllersClient_NewListInSubscriptionPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewDataControllersClient().NewListInSubscriptionPager(nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.PageOfDataControllerResource = armazurearcdata.PageOfDataControllerResource{ - // Value: []*armazurearcdata.DataControllerResource{ - // { - // Name: to.Ptr("testdataController1"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController1"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.DataControllerProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // Infrastructure: to.Ptr(armazurearcdata.InfrastructureOnpremises), - // LogAnalyticsWorkspaceConfig: &armazurearcdata.LogAnalyticsWorkspaceConfig{ - // WorkspaceID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // LogsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // MetricsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // OnPremiseProperty: &armazurearcdata.OnPremiseProperty{ - // ID: to.Ptr("12345678-1234-1234-ab12-1a2b3c4d5e6f"), - // PublicSigningKey: to.Ptr("publicOnPremSigningKey"), - // SigningCertificateThumbprint: to.Ptr("Unique thumbprint returned to customer to verify the certificate they uploaded"), - // }, - // UploadServicePrincipal: &armazurearcdata.UploadServicePrincipal{ - // Authority: to.Ptr("https://login.microsoftonline.com/"), - // ClientID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // UploadWatermark: &armazurearcdata.UploadWatermark{ - // Logs: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Metrics: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Usages: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // }, - // }, - // }, - // { - // Name: to.Ptr("testdataController2"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController2"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.DataControllerProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // LogAnalyticsWorkspaceConfig: &armazurearcdata.LogAnalyticsWorkspaceConfig{ - // WorkspaceID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // LogsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // MetricsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // OnPremiseProperty: &armazurearcdata.OnPremiseProperty{ - // ID: to.Ptr("12345678-1234-1234-ab12-1a2b3c4d5e6f"), - // PublicSigningKey: to.Ptr("publicOnPremSigningKey"), - // SigningCertificateThumbprint: to.Ptr("Unique thumbprint returned to customer to verify the certificate they uploaded"), - // }, - // UploadServicePrincipal: &armazurearcdata.UploadServicePrincipal{ - // Authority: to.Ptr("https://login.microsoftonline.com/"), - // ClientID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // UploadWatermark: &armazurearcdata.UploadWatermark{ - // Logs: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Metrics: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Usages: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // }, - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/ListByResourceGroupDataController.json -func ExampleDataControllersClient_NewListInGroupPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewDataControllersClient().NewListInGroupPager("testrg", nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.PageOfDataControllerResource = armazurearcdata.PageOfDataControllerResource{ - // Value: []*armazurearcdata.DataControllerResource{ - // { - // Name: to.Ptr("testdataController1"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController1"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.DataControllerProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // Infrastructure: to.Ptr(armazurearcdata.InfrastructureOnpremises), - // LogAnalyticsWorkspaceConfig: &armazurearcdata.LogAnalyticsWorkspaceConfig{ - // WorkspaceID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // LogsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // MetricsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // OnPremiseProperty: &armazurearcdata.OnPremiseProperty{ - // ID: to.Ptr("12345678-1234-1234-ab12-1a2b3c4d5e6f"), - // PublicSigningKey: to.Ptr("publicOnPremSigningKey"), - // SigningCertificateThumbprint: to.Ptr("Unique thumbprint returned to customer to verify the certificate they uploaded"), - // }, - // UploadServicePrincipal: &armazurearcdata.UploadServicePrincipal{ - // Authority: to.Ptr("https://login.microsoftonline.com/"), - // ClientID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // UploadWatermark: &armazurearcdata.UploadWatermark{ - // Logs: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Metrics: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Usages: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // }, - // }, - // }, - // { - // Name: to.Ptr("testdataController2"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController2"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.DataControllerProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // Infrastructure: to.Ptr(armazurearcdata.InfrastructureOnpremises), - // LogAnalyticsWorkspaceConfig: &armazurearcdata.LogAnalyticsWorkspaceConfig{ - // WorkspaceID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // OnPremiseProperty: &armazurearcdata.OnPremiseProperty{ - // ID: to.Ptr("12345678-1234-1234-ab12-1a2b3c4d5e6f"), - // PublicSigningKey: to.Ptr("publicOnPremSigningKey"), - // SigningCertificateThumbprint: to.Ptr("Unique thumbprint returned to customer to verify the certificate they uploaded"), - // }, - // UploadServicePrincipal: &armazurearcdata.UploadServicePrincipal{ - // Authority: to.Ptr("https://login.microsoftonline.com/"), - // ClientID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // UploadWatermark: &armazurearcdata.UploadWatermark{ - // Logs: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Metrics: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Usages: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // }, - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/CreateOrUpdateDataController.json -func ExampleDataControllersClient_BeginPutDataController() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewDataControllersClient().BeginPutDataController(ctx, "testrg", "testdataController", armazurearcdata.DataControllerResource{ - Location: to.Ptr("northeurope"), - Tags: map[string]*string{ - "mytag": to.Ptr("myval"), - }, - ExtendedLocation: &armazurearcdata.ExtendedLocation{ - Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - }, - Properties: &armazurearcdata.DataControllerProperties{ - BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - Password: to.Ptr("********"), - Username: to.Ptr("username"), - }, - ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - Infrastructure: to.Ptr(armazurearcdata.InfrastructureOnpremises), - LogAnalyticsWorkspaceConfig: &armazurearcdata.LogAnalyticsWorkspaceConfig{ - PrimaryKey: to.Ptr("********"), - WorkspaceID: to.Ptr("00000000-1111-2222-3333-444444444444"), - }, - LogsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - Password: to.Ptr("********"), - Username: to.Ptr("username"), - }, - MetricsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - Password: to.Ptr("********"), - Username: to.Ptr("username"), - }, - OnPremiseProperty: &armazurearcdata.OnPremiseProperty{ - ID: to.Ptr("12345678-1234-1234-ab12-1a2b3c4d5e6f"), - PublicSigningKey: to.Ptr("publicOnPremSigningKey"), - }, - UploadServicePrincipal: &armazurearcdata.UploadServicePrincipal{ - Authority: to.Ptr("https://login.microsoftonline.com/"), - ClientID: to.Ptr("00000000-1111-2222-3333-444444444444"), - ClientSecret: to.Ptr("********"), - TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), - }, - UploadWatermark: &armazurearcdata.UploadWatermark{ - Logs: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t }()), - Metrics: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t }()), - Usages: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t }()), - }, - }, - }, nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - res, err := poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.DataControllerResource = armazurearcdata.DataControllerResource{ - // Name: to.Ptr("testdataController"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.DataControllerProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // Infrastructure: to.Ptr(armazurearcdata.InfrastructureOnpremises), - // LogAnalyticsWorkspaceConfig: &armazurearcdata.LogAnalyticsWorkspaceConfig{ - // WorkspaceID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // LogsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // MetricsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // OnPremiseProperty: &armazurearcdata.OnPremiseProperty{ - // ID: to.Ptr("12345678-1234-1234-ab12-1a2b3c4d5e6f"), - // PublicSigningKey: to.Ptr("publicOnPremSigningKey"), - // SigningCertificateThumbprint: to.Ptr("Unique thumbprint returned to customer to verify the certificate being uploaded"), - // }, - // UploadServicePrincipal: &armazurearcdata.UploadServicePrincipal{ - // Authority: to.Ptr("https://login.microsoftonline.com/"), - // ClientID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // UploadWatermark: &armazurearcdata.UploadWatermark{ - // Logs: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Metrics: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Usages: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // }, - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/DeleteDataController.json -func ExampleDataControllersClient_BeginDeleteDataController() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewDataControllersClient().BeginDeleteDataController(ctx, "testrg", "testdataController", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - _, err = poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/GetDataController.json -func ExampleDataControllersClient_GetDataController() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewDataControllersClient().GetDataController(ctx, "testrg", "testdataController", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.DataControllerResource = armazurearcdata.DataControllerResource{ - // Name: to.Ptr("testdataController"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.DataControllerProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // Infrastructure: to.Ptr(armazurearcdata.InfrastructureOnpremises), - // LogAnalyticsWorkspaceConfig: &armazurearcdata.LogAnalyticsWorkspaceConfig{ - // WorkspaceID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // LogsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // MetricsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // OnPremiseProperty: &armazurearcdata.OnPremiseProperty{ - // ID: to.Ptr("12345678-1234-1234-ab12-1a2b3c4d5e6f"), - // PublicSigningKey: to.Ptr("publicOnPremSigningKey"), - // SigningCertificateThumbprint: to.Ptr("Unique thumbprint returned to customer to verify the certificate they uploaded"), - // }, - // UploadServicePrincipal: &armazurearcdata.UploadServicePrincipal{ - // Authority: to.Ptr("https://login.microsoftonline.com/"), - // ClientID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // UploadWatermark: &armazurearcdata.UploadWatermark{ - // Logs: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Metrics: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Usages: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // }, - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/UpdateDataController.json -func ExampleDataControllersClient_BeginPatchDataController() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewDataControllersClient().BeginPatchDataController(ctx, "testrg", "testdataController1", armazurearcdata.DataControllerUpdate{ - Tags: map[string]*string{ - "mytag": to.Ptr("myval"), - }, - }, nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - res, err := poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.DataControllerResource = armazurearcdata.DataControllerResource{ - // Name: to.Ptr("testdataController1"), - // Type: to.Ptr("Microsoft.AzureArcData/dataControllers"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/dataControllers/testdataController1"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.DataControllerProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // Infrastructure: to.Ptr(armazurearcdata.InfrastructureOnpremises), - // LogAnalyticsWorkspaceConfig: &armazurearcdata.LogAnalyticsWorkspaceConfig{ - // WorkspaceID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // LogsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // MetricsDashboardCredential: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // OnPremiseProperty: &armazurearcdata.OnPremiseProperty{ - // ID: to.Ptr("12345678-1234-1234-ab12-1a2b3c4d5e6f"), - // PublicSigningKey: to.Ptr("publicOnPremSigningKey"), - // SigningCertificateThumbprint: to.Ptr("Unique thumbprint returned to customer to verify the certificate they uploaded"), - // }, - // UploadServicePrincipal: &armazurearcdata.UploadServicePrincipal{ - // Authority: to.Ptr("https://login.microsoftonline.com/"), - // ClientID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), - // }, - // UploadWatermark: &armazurearcdata.UploadWatermark{ - // Logs: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Metrics: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // Usages: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // }, - // }, - // } -} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/failovergroups_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/failovergroups_client.go new file mode 100644 index 000000000000..4d0dccec4951 --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/failovergroups_client.go @@ -0,0 +1,344 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package armazurearcdata + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// FailoverGroupsClient contains the methods for the FailoverGroups group. +// Don't use this type directly, use NewFailoverGroupsClient() instead. +type FailoverGroupsClient struct { + internal *arm.Client + subscriptionID string +} + +// NewFailoverGroupsClient creates a new instance of FailoverGroupsClient with the specified values. +// - subscriptionID - The ID of the Azure subscription +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewFailoverGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*FailoverGroupsClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &FailoverGroupsClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// BeginCreate - Creates or replaces a failover group resource. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlManagedInstanceName - Name of SQL Managed Instance +// - failoverGroupName - The name of the Failover Group +// - failoverGroupResource - desc +// - options - FailoverGroupsClientBeginCreateOptions contains the optional parameters for the FailoverGroupsClient.BeginCreate +// method. +func (client *FailoverGroupsClient) BeginCreate(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, failoverGroupResource FailoverGroupResource, options *FailoverGroupsClientBeginCreateOptions) (*runtime.Poller[FailoverGroupsClientCreateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.create(ctx, resourceGroupName, sqlManagedInstanceName, failoverGroupName, failoverGroupResource, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[FailoverGroupsClientCreateResponse]{ + FinalStateVia: runtime.FinalStateViaAzureAsyncOp, + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[FailoverGroupsClientCreateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Create - Creates or replaces a failover group resource. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +func (client *FailoverGroupsClient) create(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, failoverGroupResource FailoverGroupResource, options *FailoverGroupsClientBeginCreateOptions) (*http.Response, error) { + var err error + const operationName = "FailoverGroupsClient.BeginCreate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createCreateRequest(ctx, resourceGroupName, sqlManagedInstanceName, failoverGroupName, failoverGroupResource, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusCreated) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// createCreateRequest creates the Create request. +func (client *FailoverGroupsClient) createCreateRequest(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, failoverGroupResource FailoverGroupResource, options *FailoverGroupsClientBeginCreateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlManagedInstances/{sqlManagedInstanceName}/failoverGroups/{failoverGroupName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlManagedInstanceName == "" { + return nil, errors.New("parameter sqlManagedInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlManagedInstanceName}", url.PathEscape(sqlManagedInstanceName)) + if failoverGroupName == "" { + return nil, errors.New("parameter failoverGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{failoverGroupName}", url.PathEscape(failoverGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, failoverGroupResource); err != nil { + return nil, err + } + return req, nil +} + +// BeginDelete - Deletes a failover group resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlManagedInstanceName - Name of SQL Managed Instance +// - failoverGroupName - The name of the Failover Group +// - options - FailoverGroupsClientBeginDeleteOptions contains the optional parameters for the FailoverGroupsClient.BeginDelete +// method. +func (client *FailoverGroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, options *FailoverGroupsClientBeginDeleteOptions) (*runtime.Poller[FailoverGroupsClientDeleteResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.deleteOperation(ctx, resourceGroupName, sqlManagedInstanceName, failoverGroupName, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[FailoverGroupsClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[FailoverGroupsClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Delete - Deletes a failover group resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +func (client *FailoverGroupsClient) deleteOperation(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, options *FailoverGroupsClientBeginDeleteOptions) (*http.Response, error) { + var err error + const operationName = "FailoverGroupsClient.BeginDelete" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.deleteCreateRequest(ctx, resourceGroupName, sqlManagedInstanceName, failoverGroupName, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted, http.StatusNoContent) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// deleteCreateRequest creates the Delete request. +func (client *FailoverGroupsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, options *FailoverGroupsClientBeginDeleteOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlManagedInstances/{sqlManagedInstanceName}/failoverGroups/{failoverGroupName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlManagedInstanceName == "" { + return nil, errors.New("parameter sqlManagedInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlManagedInstanceName}", url.PathEscape(sqlManagedInstanceName)) + if failoverGroupName == "" { + return nil, errors.New("parameter failoverGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{failoverGroupName}", url.PathEscape(failoverGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// Get - Retrieves a failover group resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlManagedInstanceName - Name of SQL Managed Instance +// - failoverGroupName - The name of the Failover Group +// - options - FailoverGroupsClientGetOptions contains the optional parameters for the FailoverGroupsClient.Get method. +func (client *FailoverGroupsClient) Get(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, options *FailoverGroupsClientGetOptions) (FailoverGroupsClientGetResponse, error) { + var err error + const operationName = "FailoverGroupsClient.Get" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getCreateRequest(ctx, resourceGroupName, sqlManagedInstanceName, failoverGroupName, options) + if err != nil { + return FailoverGroupsClientGetResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return FailoverGroupsClientGetResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return FailoverGroupsClientGetResponse{}, err + } + resp, err := client.getHandleResponse(httpResp) + return resp, err +} + +// getCreateRequest creates the Get request. +func (client *FailoverGroupsClient) getCreateRequest(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, options *FailoverGroupsClientGetOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlManagedInstances/{sqlManagedInstanceName}/failoverGroups/{failoverGroupName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlManagedInstanceName == "" { + return nil, errors.New("parameter sqlManagedInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlManagedInstanceName}", url.PathEscape(sqlManagedInstanceName)) + if failoverGroupName == "" { + return nil, errors.New("parameter failoverGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{failoverGroupName}", url.PathEscape(failoverGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getHandleResponse handles the Get response. +func (client *FailoverGroupsClient) getHandleResponse(resp *http.Response) (FailoverGroupsClientGetResponse, error) { + result := FailoverGroupsClientGetResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.FailoverGroupResource); err != nil { + return FailoverGroupsClientGetResponse{}, err + } + return result, nil +} + +// NewListPager - List the failover groups associated with the given sql managed instance. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlManagedInstanceName - Name of SQL Managed Instance +// - options - FailoverGroupsClientListOptions contains the optional parameters for the FailoverGroupsClient.NewListPager method. +func (client *FailoverGroupsClient) NewListPager(resourceGroupName string, sqlManagedInstanceName string, options *FailoverGroupsClientListOptions) *runtime.Pager[FailoverGroupsClientListResponse] { + return runtime.NewPager(runtime.PagingHandler[FailoverGroupsClientListResponse]{ + More: func(page FailoverGroupsClientListResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *FailoverGroupsClientListResponse) (FailoverGroupsClientListResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "FailoverGroupsClient.NewListPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listCreateRequest(ctx, resourceGroupName, sqlManagedInstanceName, options) + }, nil) + if err != nil { + return FailoverGroupsClientListResponse{}, err + } + return client.listHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listCreateRequest creates the List request. +func (client *FailoverGroupsClient) listCreateRequest(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, options *FailoverGroupsClientListOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlManagedInstances/{sqlManagedInstanceName}/failoverGroups" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlManagedInstanceName == "" { + return nil, errors.New("parameter sqlManagedInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlManagedInstanceName}", url.PathEscape(sqlManagedInstanceName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listHandleResponse handles the List response. +func (client *FailoverGroupsClient) listHandleResponse(resp *http.Response) (FailoverGroupsClientListResponse, error) { + result := FailoverGroupsClientListResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.FailoverGroupListResult); err != nil { + return FailoverGroupsClientListResponse{}, err + } + return result, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/failovergroups_server.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/failovergroups_server.go new file mode 100644 index 000000000000..e2e9a2b18cb2 --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/failovergroups_server.go @@ -0,0 +1,272 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package fake + +import ( + "context" + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" + "net/http" + "net/url" + "regexp" +) + +// FailoverGroupsServer is a fake server for instances of the armazurearcdata.FailoverGroupsClient type. +type FailoverGroupsServer struct { + // BeginCreate is the fake for method FailoverGroupsClient.BeginCreate + // HTTP status codes to indicate success: http.StatusOK, http.StatusCreated + BeginCreate func(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, failoverGroupResource armazurearcdata.FailoverGroupResource, options *armazurearcdata.FailoverGroupsClientBeginCreateOptions) (resp azfake.PollerResponder[armazurearcdata.FailoverGroupsClientCreateResponse], errResp azfake.ErrorResponder) + + // BeginDelete is the fake for method FailoverGroupsClient.BeginDelete + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent + BeginDelete func(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, options *armazurearcdata.FailoverGroupsClientBeginDeleteOptions) (resp azfake.PollerResponder[armazurearcdata.FailoverGroupsClientDeleteResponse], errResp azfake.ErrorResponder) + + // Get is the fake for method FailoverGroupsClient.Get + // HTTP status codes to indicate success: http.StatusOK + Get func(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, failoverGroupName string, options *armazurearcdata.FailoverGroupsClientGetOptions) (resp azfake.Responder[armazurearcdata.FailoverGroupsClientGetResponse], errResp azfake.ErrorResponder) + + // NewListPager is the fake for method FailoverGroupsClient.NewListPager + // HTTP status codes to indicate success: http.StatusOK + NewListPager func(resourceGroupName string, sqlManagedInstanceName string, options *armazurearcdata.FailoverGroupsClientListOptions) (resp azfake.PagerResponder[armazurearcdata.FailoverGroupsClientListResponse]) +} + +// NewFailoverGroupsServerTransport creates a new instance of FailoverGroupsServerTransport with the provided implementation. +// The returned FailoverGroupsServerTransport instance is connected to an instance of armazurearcdata.FailoverGroupsClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewFailoverGroupsServerTransport(srv *FailoverGroupsServer) *FailoverGroupsServerTransport { + return &FailoverGroupsServerTransport{ + srv: srv, + beginCreate: newTracker[azfake.PollerResponder[armazurearcdata.FailoverGroupsClientCreateResponse]](), + beginDelete: newTracker[azfake.PollerResponder[armazurearcdata.FailoverGroupsClientDeleteResponse]](), + newListPager: newTracker[azfake.PagerResponder[armazurearcdata.FailoverGroupsClientListResponse]](), + } +} + +// FailoverGroupsServerTransport connects instances of armazurearcdata.FailoverGroupsClient to instances of FailoverGroupsServer. +// Don't use this type directly, use NewFailoverGroupsServerTransport instead. +type FailoverGroupsServerTransport struct { + srv *FailoverGroupsServer + beginCreate *tracker[azfake.PollerResponder[armazurearcdata.FailoverGroupsClientCreateResponse]] + beginDelete *tracker[azfake.PollerResponder[armazurearcdata.FailoverGroupsClientDeleteResponse]] + newListPager *tracker[azfake.PagerResponder[armazurearcdata.FailoverGroupsClientListResponse]] +} + +// Do implements the policy.Transporter interface for FailoverGroupsServerTransport. +func (f *FailoverGroupsServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + var resp *http.Response + var err error + + switch method { + case "FailoverGroupsClient.BeginCreate": + resp, err = f.dispatchBeginCreate(req) + case "FailoverGroupsClient.BeginDelete": + resp, err = f.dispatchBeginDelete(req) + case "FailoverGroupsClient.Get": + resp, err = f.dispatchGet(req) + case "FailoverGroupsClient.NewListPager": + resp, err = f.dispatchNewListPager(req) + default: + err = fmt.Errorf("unhandled API %s", method) + } + + if err != nil { + return nil, err + } + + return resp, nil +} + +func (f *FailoverGroupsServerTransport) dispatchBeginCreate(req *http.Request) (*http.Response, error) { + if f.srv.BeginCreate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginCreate not implemented")} + } + beginCreate := f.beginCreate.get(req) + if beginCreate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlManagedInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/failoverGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.FailoverGroupResource](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlManagedInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlManagedInstanceName")]) + if err != nil { + return nil, err + } + failoverGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("failoverGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := f.srv.BeginCreate(req.Context(), resourceGroupNameParam, sqlManagedInstanceNameParam, failoverGroupNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginCreate = &respr + f.beginCreate.add(req, beginCreate) + } + + resp, err := server.PollerResponderNext(beginCreate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusCreated}, resp.StatusCode) { + f.beginCreate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusCreated", resp.StatusCode)} + } + if !server.PollerResponderMore(beginCreate) { + f.beginCreate.remove(req) + } + + return resp, nil +} + +func (f *FailoverGroupsServerTransport) dispatchBeginDelete(req *http.Request) (*http.Response, error) { + if f.srv.BeginDelete == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginDelete not implemented")} + } + beginDelete := f.beginDelete.get(req) + if beginDelete == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlManagedInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/failoverGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlManagedInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlManagedInstanceName")]) + if err != nil { + return nil, err + } + failoverGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("failoverGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := f.srv.BeginDelete(req.Context(), resourceGroupNameParam, sqlManagedInstanceNameParam, failoverGroupNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginDelete = &respr + f.beginDelete.add(req, beginDelete) + } + + resp, err := server.PollerResponderNext(beginDelete, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted, http.StatusNoContent}, resp.StatusCode) { + f.beginDelete.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted, http.StatusNoContent", resp.StatusCode)} + } + if !server.PollerResponderMore(beginDelete) { + f.beginDelete.remove(req) + } + + return resp, nil +} + +func (f *FailoverGroupsServerTransport) dispatchGet(req *http.Request) (*http.Response, error) { + if f.srv.Get == nil { + return nil, &nonRetriableError{errors.New("fake for method Get not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlManagedInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/failoverGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlManagedInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlManagedInstanceName")]) + if err != nil { + return nil, err + } + failoverGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("failoverGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := f.srv.Get(req.Context(), resourceGroupNameParam, sqlManagedInstanceNameParam, failoverGroupNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).FailoverGroupResource, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (f *FailoverGroupsServerTransport) dispatchNewListPager(req *http.Request) (*http.Response, error) { + if f.srv.NewListPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListPager not implemented")} + } + newListPager := f.newListPager.get(req) + if newListPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlManagedInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/failoverGroups` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlManagedInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlManagedInstanceName")]) + if err != nil { + return nil, err + } + resp := f.srv.NewListPager(resourceGroupNameParam, sqlManagedInstanceNameParam, nil) + newListPager = &resp + f.newListPager.add(req, newListPager) + server.PagerResponderInjectNextLinks(newListPager, req, func(page *armazurearcdata.FailoverGroupsClientListResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + f.newListPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListPager) { + f.newListPager.remove(req) + } + return resp, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/server_factory.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/server_factory.go index 5ad7cb73ce35..edca9a27bf22 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/server_factory.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/server_factory.go @@ -19,12 +19,17 @@ import ( // ServerFactory is a fake server for instances of the armazurearcdata.ClientFactory type. type ServerFactory struct { - ActiveDirectoryConnectorsServer ActiveDirectoryConnectorsServer - DataControllersServer DataControllersServer - OperationsServer OperationsServer - PostgresInstancesServer PostgresInstancesServer - SQLManagedInstancesServer SQLManagedInstancesServer - SQLServerInstancesServer SQLServerInstancesServer + ActiveDirectoryConnectorsServer ActiveDirectoryConnectorsServer + DataControllersServer DataControllersServer + FailoverGroupsServer FailoverGroupsServer + OperationsServer OperationsServer + PostgresInstancesServer PostgresInstancesServer + SQLManagedInstancesServer SQLManagedInstancesServer + SQLServerAvailabilityGroupsServer SQLServerAvailabilityGroupsServer + SQLServerDatabasesServer SQLServerDatabasesServer + SQLServerEsuLicensesServer SQLServerEsuLicensesServer + SQLServerInstancesServer SQLServerInstancesServer + SQLServerLicensesServer SQLServerLicensesServer } // NewServerFactoryTransport creates a new instance of ServerFactoryTransport with the provided implementation. @@ -39,14 +44,19 @@ func NewServerFactoryTransport(srv *ServerFactory) *ServerFactoryTransport { // ServerFactoryTransport connects instances of armazurearcdata.ClientFactory to instances of ServerFactory. // Don't use this type directly, use NewServerFactoryTransport instead. type ServerFactoryTransport struct { - srv *ServerFactory - trMu sync.Mutex - trActiveDirectoryConnectorsServer *ActiveDirectoryConnectorsServerTransport - trDataControllersServer *DataControllersServerTransport - trOperationsServer *OperationsServerTransport - trPostgresInstancesServer *PostgresInstancesServerTransport - trSQLManagedInstancesServer *SQLManagedInstancesServerTransport - trSQLServerInstancesServer *SQLServerInstancesServerTransport + srv *ServerFactory + trMu sync.Mutex + trActiveDirectoryConnectorsServer *ActiveDirectoryConnectorsServerTransport + trDataControllersServer *DataControllersServerTransport + trFailoverGroupsServer *FailoverGroupsServerTransport + trOperationsServer *OperationsServerTransport + trPostgresInstancesServer *PostgresInstancesServerTransport + trSQLManagedInstancesServer *SQLManagedInstancesServerTransport + trSQLServerAvailabilityGroupsServer *SQLServerAvailabilityGroupsServerTransport + trSQLServerDatabasesServer *SQLServerDatabasesServerTransport + trSQLServerEsuLicensesServer *SQLServerEsuLicensesServerTransport + trSQLServerInstancesServer *SQLServerInstancesServerTransport + trSQLServerLicensesServer *SQLServerLicensesServerTransport } // Do implements the policy.Transporter interface for ServerFactoryTransport. @@ -72,6 +82,11 @@ func (s *ServerFactoryTransport) Do(req *http.Request) (*http.Response, error) { return NewDataControllersServerTransport(&s.srv.DataControllersServer) }) resp, err = s.trDataControllersServer.Do(req) + case "FailoverGroupsClient": + initServer(s, &s.trFailoverGroupsServer, func() *FailoverGroupsServerTransport { + return NewFailoverGroupsServerTransport(&s.srv.FailoverGroupsServer) + }) + resp, err = s.trFailoverGroupsServer.Do(req) case "OperationsClient": initServer(s, &s.trOperationsServer, func() *OperationsServerTransport { return NewOperationsServerTransport(&s.srv.OperationsServer) }) resp, err = s.trOperationsServer.Do(req) @@ -85,11 +100,31 @@ func (s *ServerFactoryTransport) Do(req *http.Request) (*http.Response, error) { return NewSQLManagedInstancesServerTransport(&s.srv.SQLManagedInstancesServer) }) resp, err = s.trSQLManagedInstancesServer.Do(req) + case "SQLServerAvailabilityGroupsClient": + initServer(s, &s.trSQLServerAvailabilityGroupsServer, func() *SQLServerAvailabilityGroupsServerTransport { + return NewSQLServerAvailabilityGroupsServerTransport(&s.srv.SQLServerAvailabilityGroupsServer) + }) + resp, err = s.trSQLServerAvailabilityGroupsServer.Do(req) + case "SQLServerDatabasesClient": + initServer(s, &s.trSQLServerDatabasesServer, func() *SQLServerDatabasesServerTransport { + return NewSQLServerDatabasesServerTransport(&s.srv.SQLServerDatabasesServer) + }) + resp, err = s.trSQLServerDatabasesServer.Do(req) + case "SQLServerEsuLicensesClient": + initServer(s, &s.trSQLServerEsuLicensesServer, func() *SQLServerEsuLicensesServerTransport { + return NewSQLServerEsuLicensesServerTransport(&s.srv.SQLServerEsuLicensesServer) + }) + resp, err = s.trSQLServerEsuLicensesServer.Do(req) case "SQLServerInstancesClient": initServer(s, &s.trSQLServerInstancesServer, func() *SQLServerInstancesServerTransport { return NewSQLServerInstancesServerTransport(&s.srv.SQLServerInstancesServer) }) resp, err = s.trSQLServerInstancesServer.Do(req) + case "SQLServerLicensesClient": + initServer(s, &s.trSQLServerLicensesServer, func() *SQLServerLicensesServerTransport { + return NewSQLServerLicensesServerTransport(&s.srv.SQLServerLicensesServer) + }) + resp, err = s.trSQLServerLicensesServer.Do(req) default: err = fmt.Errorf("unhandled client %s", client) } diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserveravailabilitygroups_server.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserveravailabilitygroups_server.go new file mode 100644 index 000000000000..9ed9a3992d81 --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserveravailabilitygroups_server.go @@ -0,0 +1,654 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package fake + +import ( + "context" + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" + "net/http" + "net/url" + "regexp" +) + +// SQLServerAvailabilityGroupsServer is a fake server for instances of the armazurearcdata.SQLServerAvailabilityGroupsClient type. +type SQLServerAvailabilityGroupsServer struct { + // AddDatabases is the fake for method SQLServerAvailabilityGroupsClient.AddDatabases + // HTTP status codes to indicate success: http.StatusOK + AddDatabases func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, databases armazurearcdata.Databases, options *armazurearcdata.SQLServerAvailabilityGroupsClientAddDatabasesOptions) (resp azfake.Responder[armazurearcdata.SQLServerAvailabilityGroupsClientAddDatabasesResponse], errResp azfake.ErrorResponder) + + // Create is the fake for method SQLServerAvailabilityGroupsClient.Create + // HTTP status codes to indicate success: http.StatusOK, http.StatusCreated + Create func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, sqlServerAvailabilityGroupResource armazurearcdata.SQLServerAvailabilityGroupResource, options *armazurearcdata.SQLServerAvailabilityGroupsClientCreateOptions) (resp azfake.Responder[armazurearcdata.SQLServerAvailabilityGroupsClientCreateResponse], errResp azfake.ErrorResponder) + + // BeginCreateAvailabilityGroup is the fake for method SQLServerAvailabilityGroupsClient.BeginCreateAvailabilityGroup + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted + BeginCreateAvailabilityGroup func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, createAgConfiguration armazurearcdata.AvailabilityGroupCreateUpdateConfiguration, options *armazurearcdata.SQLServerAvailabilityGroupsClientBeginCreateAvailabilityGroupOptions) (resp azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientCreateAvailabilityGroupResponse], errResp azfake.ErrorResponder) + + // BeginCreateDistributedAvailabilityGroup is the fake for method SQLServerAvailabilityGroupsClient.BeginCreateDistributedAvailabilityGroup + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted + BeginCreateDistributedAvailabilityGroup func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, createDagConfiguration armazurearcdata.DistributedAvailabilityGroupCreateUpdateConfiguration, options *armazurearcdata.SQLServerAvailabilityGroupsClientBeginCreateDistributedAvailabilityGroupOptions) (resp azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientCreateDistributedAvailabilityGroupResponse], errResp azfake.ErrorResponder) + + // BeginDelete is the fake for method SQLServerAvailabilityGroupsClient.BeginDelete + // HTTP status codes to indicate success: http.StatusAccepted, http.StatusNoContent + BeginDelete func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *armazurearcdata.SQLServerAvailabilityGroupsClientBeginDeleteOptions) (resp azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientDeleteResponse], errResp azfake.ErrorResponder) + + // DetailView is the fake for method SQLServerAvailabilityGroupsClient.DetailView + // HTTP status codes to indicate success: http.StatusOK + DetailView func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *armazurearcdata.SQLServerAvailabilityGroupsClientDetailViewOptions) (resp azfake.Responder[armazurearcdata.SQLServerAvailabilityGroupsClientDetailViewResponse], errResp azfake.ErrorResponder) + + // Failover is the fake for method SQLServerAvailabilityGroupsClient.Failover + // HTTP status codes to indicate success: http.StatusOK + Failover func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *armazurearcdata.SQLServerAvailabilityGroupsClientFailoverOptions) (resp azfake.Responder[armazurearcdata.SQLServerAvailabilityGroupsClientFailoverResponse], errResp azfake.ErrorResponder) + + // ForceFailoverAllowDataLoss is the fake for method SQLServerAvailabilityGroupsClient.ForceFailoverAllowDataLoss + // HTTP status codes to indicate success: http.StatusOK + ForceFailoverAllowDataLoss func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *armazurearcdata.SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossOptions) (resp azfake.Responder[armazurearcdata.SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse], errResp azfake.ErrorResponder) + + // Get is the fake for method SQLServerAvailabilityGroupsClient.Get + // HTTP status codes to indicate success: http.StatusOK + Get func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *armazurearcdata.SQLServerAvailabilityGroupsClientGetOptions) (resp azfake.Responder[armazurearcdata.SQLServerAvailabilityGroupsClientGetResponse], errResp azfake.ErrorResponder) + + // NewListPager is the fake for method SQLServerAvailabilityGroupsClient.NewListPager + // HTTP status codes to indicate success: http.StatusOK + NewListPager func(resourceGroupName string, sqlServerInstanceName string, options *armazurearcdata.SQLServerAvailabilityGroupsClientListOptions) (resp azfake.PagerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientListResponse]) + + // RemoveDatabases is the fake for method SQLServerAvailabilityGroupsClient.RemoveDatabases + // HTTP status codes to indicate success: http.StatusOK + RemoveDatabases func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, databases armazurearcdata.Databases, options *armazurearcdata.SQLServerAvailabilityGroupsClientRemoveDatabasesOptions) (resp azfake.Responder[armazurearcdata.SQLServerAvailabilityGroupsClientRemoveDatabasesResponse], errResp azfake.ErrorResponder) + + // BeginUpdate is the fake for method SQLServerAvailabilityGroupsClient.BeginUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted + BeginUpdate func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, sqlServerAvailabilityGroupUpdate armazurearcdata.SQLServerAvailabilityGroupUpdate, options *armazurearcdata.SQLServerAvailabilityGroupsClientBeginUpdateOptions) (resp azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientUpdateResponse], errResp azfake.ErrorResponder) +} + +// NewSQLServerAvailabilityGroupsServerTransport creates a new instance of SQLServerAvailabilityGroupsServerTransport with the provided implementation. +// The returned SQLServerAvailabilityGroupsServerTransport instance is connected to an instance of armazurearcdata.SQLServerAvailabilityGroupsClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewSQLServerAvailabilityGroupsServerTransport(srv *SQLServerAvailabilityGroupsServer) *SQLServerAvailabilityGroupsServerTransport { + return &SQLServerAvailabilityGroupsServerTransport{ + srv: srv, + beginCreateAvailabilityGroup: newTracker[azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientCreateAvailabilityGroupResponse]](), + beginCreateDistributedAvailabilityGroup: newTracker[azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientCreateDistributedAvailabilityGroupResponse]](), + beginDelete: newTracker[azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientDeleteResponse]](), + newListPager: newTracker[azfake.PagerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientListResponse]](), + beginUpdate: newTracker[azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientUpdateResponse]](), + } +} + +// SQLServerAvailabilityGroupsServerTransport connects instances of armazurearcdata.SQLServerAvailabilityGroupsClient to instances of SQLServerAvailabilityGroupsServer. +// Don't use this type directly, use NewSQLServerAvailabilityGroupsServerTransport instead. +type SQLServerAvailabilityGroupsServerTransport struct { + srv *SQLServerAvailabilityGroupsServer + beginCreateAvailabilityGroup *tracker[azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientCreateAvailabilityGroupResponse]] + beginCreateDistributedAvailabilityGroup *tracker[azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientCreateDistributedAvailabilityGroupResponse]] + beginDelete *tracker[azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientDeleteResponse]] + newListPager *tracker[azfake.PagerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientListResponse]] + beginUpdate *tracker[azfake.PollerResponder[armazurearcdata.SQLServerAvailabilityGroupsClientUpdateResponse]] +} + +// Do implements the policy.Transporter interface for SQLServerAvailabilityGroupsServerTransport. +func (s *SQLServerAvailabilityGroupsServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + var resp *http.Response + var err error + + switch method { + case "SQLServerAvailabilityGroupsClient.AddDatabases": + resp, err = s.dispatchAddDatabases(req) + case "SQLServerAvailabilityGroupsClient.Create": + resp, err = s.dispatchCreate(req) + case "SQLServerAvailabilityGroupsClient.BeginCreateAvailabilityGroup": + resp, err = s.dispatchBeginCreateAvailabilityGroup(req) + case "SQLServerAvailabilityGroupsClient.BeginCreateDistributedAvailabilityGroup": + resp, err = s.dispatchBeginCreateDistributedAvailabilityGroup(req) + case "SQLServerAvailabilityGroupsClient.BeginDelete": + resp, err = s.dispatchBeginDelete(req) + case "SQLServerAvailabilityGroupsClient.DetailView": + resp, err = s.dispatchDetailView(req) + case "SQLServerAvailabilityGroupsClient.Failover": + resp, err = s.dispatchFailover(req) + case "SQLServerAvailabilityGroupsClient.ForceFailoverAllowDataLoss": + resp, err = s.dispatchForceFailoverAllowDataLoss(req) + case "SQLServerAvailabilityGroupsClient.Get": + resp, err = s.dispatchGet(req) + case "SQLServerAvailabilityGroupsClient.NewListPager": + resp, err = s.dispatchNewListPager(req) + case "SQLServerAvailabilityGroupsClient.RemoveDatabases": + resp, err = s.dispatchRemoveDatabases(req) + case "SQLServerAvailabilityGroupsClient.BeginUpdate": + resp, err = s.dispatchBeginUpdate(req) + default: + err = fmt.Errorf("unhandled API %s", method) + } + + if err != nil { + return nil, err + } + + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchAddDatabases(req *http.Request) (*http.Response, error) { + if s.srv.AddDatabases == nil { + return nil, &nonRetriableError{errors.New("fake for method AddDatabases not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availabilityGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/addDatabases` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.Databases](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + availabilityGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("availabilityGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.AddDatabases(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, availabilityGroupNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerAvailabilityGroupResource, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchCreate(req *http.Request) (*http.Response, error) { + if s.srv.Create == nil { + return nil, &nonRetriableError{errors.New("fake for method Create not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availabilityGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerAvailabilityGroupResource](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + availabilityGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("availabilityGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Create(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, availabilityGroupNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK, http.StatusCreated}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusCreated", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerAvailabilityGroupResource, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchBeginCreateAvailabilityGroup(req *http.Request) (*http.Response, error) { + if s.srv.BeginCreateAvailabilityGroup == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginCreateAvailabilityGroup not implemented")} + } + beginCreateAvailabilityGroup := s.beginCreateAvailabilityGroup.get(req) + if beginCreateAvailabilityGroup == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/createAvailabilityGroup` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.AvailabilityGroupCreateUpdateConfiguration](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginCreateAvailabilityGroup(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginCreateAvailabilityGroup = &respr + s.beginCreateAvailabilityGroup.add(req, beginCreateAvailabilityGroup) + } + + resp, err := server.PollerResponderNext(beginCreateAvailabilityGroup, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) { + s.beginCreateAvailabilityGroup.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted", resp.StatusCode)} + } + if !server.PollerResponderMore(beginCreateAvailabilityGroup) { + s.beginCreateAvailabilityGroup.remove(req) + } + + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchBeginCreateDistributedAvailabilityGroup(req *http.Request) (*http.Response, error) { + if s.srv.BeginCreateDistributedAvailabilityGroup == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginCreateDistributedAvailabilityGroup not implemented")} + } + beginCreateDistributedAvailabilityGroup := s.beginCreateDistributedAvailabilityGroup.get(req) + if beginCreateDistributedAvailabilityGroup == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/createDistributedAvailabilityGroup` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.DistributedAvailabilityGroupCreateUpdateConfiguration](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginCreateDistributedAvailabilityGroup(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginCreateDistributedAvailabilityGroup = &respr + s.beginCreateDistributedAvailabilityGroup.add(req, beginCreateDistributedAvailabilityGroup) + } + + resp, err := server.PollerResponderNext(beginCreateDistributedAvailabilityGroup, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) { + s.beginCreateDistributedAvailabilityGroup.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted", resp.StatusCode)} + } + if !server.PollerResponderMore(beginCreateDistributedAvailabilityGroup) { + s.beginCreateDistributedAvailabilityGroup.remove(req) + } + + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchBeginDelete(req *http.Request) (*http.Response, error) { + if s.srv.BeginDelete == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginDelete not implemented")} + } + beginDelete := s.beginDelete.get(req) + if beginDelete == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availabilityGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + availabilityGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("availabilityGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginDelete(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, availabilityGroupNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginDelete = &respr + s.beginDelete.add(req, beginDelete) + } + + resp, err := server.PollerResponderNext(beginDelete, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusAccepted, http.StatusNoContent}, resp.StatusCode) { + s.beginDelete.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusAccepted, http.StatusNoContent", resp.StatusCode)} + } + if !server.PollerResponderMore(beginDelete) { + s.beginDelete.remove(req) + } + + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchDetailView(req *http.Request) (*http.Response, error) { + if s.srv.DetailView == nil { + return nil, &nonRetriableError{errors.New("fake for method DetailView not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availabilityGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/getDetailView` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + availabilityGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("availabilityGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.DetailView(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, availabilityGroupNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerAvailabilityGroupResource, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchFailover(req *http.Request) (*http.Response, error) { + if s.srv.Failover == nil { + return nil, &nonRetriableError{errors.New("fake for method Failover not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availabilityGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/failover` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + availabilityGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("availabilityGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Failover(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, availabilityGroupNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerAvailabilityGroupResource, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchForceFailoverAllowDataLoss(req *http.Request) (*http.Response, error) { + if s.srv.ForceFailoverAllowDataLoss == nil { + return nil, &nonRetriableError{errors.New("fake for method ForceFailoverAllowDataLoss not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availabilityGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/forceFailoverAllowDataLoss` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + availabilityGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("availabilityGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.ForceFailoverAllowDataLoss(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, availabilityGroupNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerAvailabilityGroupResource, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchGet(req *http.Request) (*http.Response, error) { + if s.srv.Get == nil { + return nil, &nonRetriableError{errors.New("fake for method Get not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availabilityGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + availabilityGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("availabilityGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Get(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, availabilityGroupNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerAvailabilityGroupResource, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchNewListPager(req *http.Request) (*http.Response, error) { + if s.srv.NewListPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListPager not implemented")} + } + newListPager := s.newListPager.get(req) + if newListPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availabilityGroups` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + resp := s.srv.NewListPager(resourceGroupNameParam, sqlServerInstanceNameParam, nil) + newListPager = &resp + s.newListPager.add(req, newListPager) + server.PagerResponderInjectNextLinks(newListPager, req, func(page *armazurearcdata.SQLServerAvailabilityGroupsClientListResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + s.newListPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListPager) { + s.newListPager.remove(req) + } + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchRemoveDatabases(req *http.Request) (*http.Response, error) { + if s.srv.RemoveDatabases == nil { + return nil, &nonRetriableError{errors.New("fake for method RemoveDatabases not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availabilityGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/removeDatabases` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.Databases](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + availabilityGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("availabilityGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.RemoveDatabases(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, availabilityGroupNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerAvailabilityGroupResource, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerAvailabilityGroupsServerTransport) dispatchBeginUpdate(req *http.Request) (*http.Response, error) { + if s.srv.BeginUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginUpdate not implemented")} + } + beginUpdate := s.beginUpdate.get(req) + if beginUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availabilityGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerAvailabilityGroupUpdate](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + availabilityGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("availabilityGroupName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginUpdate(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, availabilityGroupNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginUpdate = &respr + s.beginUpdate.add(req, beginUpdate) + } + + resp, err := server.PollerResponderNext(beginUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) { + s.beginUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted", resp.StatusCode)} + } + if !server.PollerResponderMore(beginUpdate) { + s.beginUpdate.remove(req) + } + + return resp, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserverdatabases_server.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserverdatabases_server.go new file mode 100644 index 000000000000..b04353fbbe16 --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserverdatabases_server.go @@ -0,0 +1,319 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package fake + +import ( + "context" + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" + "net/http" + "net/url" + "regexp" +) + +// SQLServerDatabasesServer is a fake server for instances of the armazurearcdata.SQLServerDatabasesClient type. +type SQLServerDatabasesServer struct { + // Create is the fake for method SQLServerDatabasesClient.Create + // HTTP status codes to indicate success: http.StatusOK, http.StatusCreated + Create func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, sqlServerDatabaseResource armazurearcdata.SQLServerDatabaseResource, options *armazurearcdata.SQLServerDatabasesClientCreateOptions) (resp azfake.Responder[armazurearcdata.SQLServerDatabasesClientCreateResponse], errResp azfake.ErrorResponder) + + // BeginDelete is the fake for method SQLServerDatabasesClient.BeginDelete + // HTTP status codes to indicate success: http.StatusAccepted, http.StatusNoContent + BeginDelete func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, options *armazurearcdata.SQLServerDatabasesClientBeginDeleteOptions) (resp azfake.PollerResponder[armazurearcdata.SQLServerDatabasesClientDeleteResponse], errResp azfake.ErrorResponder) + + // Get is the fake for method SQLServerDatabasesClient.Get + // HTTP status codes to indicate success: http.StatusOK + Get func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, options *armazurearcdata.SQLServerDatabasesClientGetOptions) (resp azfake.Responder[armazurearcdata.SQLServerDatabasesClientGetResponse], errResp azfake.ErrorResponder) + + // NewListPager is the fake for method SQLServerDatabasesClient.NewListPager + // HTTP status codes to indicate success: http.StatusOK + NewListPager func(resourceGroupName string, sqlServerInstanceName string, options *armazurearcdata.SQLServerDatabasesClientListOptions) (resp azfake.PagerResponder[armazurearcdata.SQLServerDatabasesClientListResponse]) + + // BeginUpdate is the fake for method SQLServerDatabasesClient.BeginUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted + BeginUpdate func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, sqlServerDatabaseUpdate armazurearcdata.SQLServerDatabaseUpdate, options *armazurearcdata.SQLServerDatabasesClientBeginUpdateOptions) (resp azfake.PollerResponder[armazurearcdata.SQLServerDatabasesClientUpdateResponse], errResp azfake.ErrorResponder) +} + +// NewSQLServerDatabasesServerTransport creates a new instance of SQLServerDatabasesServerTransport with the provided implementation. +// The returned SQLServerDatabasesServerTransport instance is connected to an instance of armazurearcdata.SQLServerDatabasesClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewSQLServerDatabasesServerTransport(srv *SQLServerDatabasesServer) *SQLServerDatabasesServerTransport { + return &SQLServerDatabasesServerTransport{ + srv: srv, + beginDelete: newTracker[azfake.PollerResponder[armazurearcdata.SQLServerDatabasesClientDeleteResponse]](), + newListPager: newTracker[azfake.PagerResponder[armazurearcdata.SQLServerDatabasesClientListResponse]](), + beginUpdate: newTracker[azfake.PollerResponder[armazurearcdata.SQLServerDatabasesClientUpdateResponse]](), + } +} + +// SQLServerDatabasesServerTransport connects instances of armazurearcdata.SQLServerDatabasesClient to instances of SQLServerDatabasesServer. +// Don't use this type directly, use NewSQLServerDatabasesServerTransport instead. +type SQLServerDatabasesServerTransport struct { + srv *SQLServerDatabasesServer + beginDelete *tracker[azfake.PollerResponder[armazurearcdata.SQLServerDatabasesClientDeleteResponse]] + newListPager *tracker[azfake.PagerResponder[armazurearcdata.SQLServerDatabasesClientListResponse]] + beginUpdate *tracker[azfake.PollerResponder[armazurearcdata.SQLServerDatabasesClientUpdateResponse]] +} + +// Do implements the policy.Transporter interface for SQLServerDatabasesServerTransport. +func (s *SQLServerDatabasesServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + var resp *http.Response + var err error + + switch method { + case "SQLServerDatabasesClient.Create": + resp, err = s.dispatchCreate(req) + case "SQLServerDatabasesClient.BeginDelete": + resp, err = s.dispatchBeginDelete(req) + case "SQLServerDatabasesClient.Get": + resp, err = s.dispatchGet(req) + case "SQLServerDatabasesClient.NewListPager": + resp, err = s.dispatchNewListPager(req) + case "SQLServerDatabasesClient.BeginUpdate": + resp, err = s.dispatchBeginUpdate(req) + default: + err = fmt.Errorf("unhandled API %s", method) + } + + if err != nil { + return nil, err + } + + return resp, nil +} + +func (s *SQLServerDatabasesServerTransport) dispatchCreate(req *http.Request) (*http.Response, error) { + if s.srv.Create == nil { + return nil, &nonRetriableError{errors.New("fake for method Create not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/databases/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerDatabaseResource](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + databaseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("databaseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Create(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, databaseNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK, http.StatusCreated}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusCreated", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerDatabaseResource, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerDatabasesServerTransport) dispatchBeginDelete(req *http.Request) (*http.Response, error) { + if s.srv.BeginDelete == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginDelete not implemented")} + } + beginDelete := s.beginDelete.get(req) + if beginDelete == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/databases/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + databaseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("databaseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginDelete(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, databaseNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginDelete = &respr + s.beginDelete.add(req, beginDelete) + } + + resp, err := server.PollerResponderNext(beginDelete, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusAccepted, http.StatusNoContent}, resp.StatusCode) { + s.beginDelete.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusAccepted, http.StatusNoContent", resp.StatusCode)} + } + if !server.PollerResponderMore(beginDelete) { + s.beginDelete.remove(req) + } + + return resp, nil +} + +func (s *SQLServerDatabasesServerTransport) dispatchGet(req *http.Request) (*http.Response, error) { + if s.srv.Get == nil { + return nil, &nonRetriableError{errors.New("fake for method Get not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/databases/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + databaseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("databaseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Get(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, databaseNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerDatabaseResource, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerDatabasesServerTransport) dispatchNewListPager(req *http.Request) (*http.Response, error) { + if s.srv.NewListPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListPager not implemented")} + } + newListPager := s.newListPager.get(req) + if newListPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/databases` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + resp := s.srv.NewListPager(resourceGroupNameParam, sqlServerInstanceNameParam, nil) + newListPager = &resp + s.newListPager.add(req, newListPager) + server.PagerResponderInjectNextLinks(newListPager, req, func(page *armazurearcdata.SQLServerDatabasesClientListResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + s.newListPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListPager) { + s.newListPager.remove(req) + } + return resp, nil +} + +func (s *SQLServerDatabasesServerTransport) dispatchBeginUpdate(req *http.Request) (*http.Response, error) { + if s.srv.BeginUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginUpdate not implemented")} + } + beginUpdate := s.beginUpdate.get(req) + if beginUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/databases/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerDatabaseUpdate](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + databaseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("databaseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginUpdate(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, databaseNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginUpdate = &respr + s.beginUpdate.add(req, beginUpdate) + } + + resp, err := server.PollerResponderNext(beginUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) { + s.beginUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted", resp.StatusCode)} + } + if !server.PollerResponderMore(beginUpdate) { + s.beginUpdate.remove(req) + } + + return resp, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserveresulicenses_server.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserveresulicenses_server.go new file mode 100644 index 000000000000..6f8feea00754 --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserveresulicenses_server.go @@ -0,0 +1,314 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package fake + +import ( + "context" + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" + "net/http" + "net/url" + "regexp" +) + +// SQLServerEsuLicensesServer is a fake server for instances of the armazurearcdata.SQLServerEsuLicensesClient type. +type SQLServerEsuLicensesServer struct { + // Create is the fake for method SQLServerEsuLicensesClient.Create + // HTTP status codes to indicate success: http.StatusOK, http.StatusCreated + Create func(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, sqlServerEsuLicense armazurearcdata.SQLServerEsuLicense, options *armazurearcdata.SQLServerEsuLicensesClientCreateOptions) (resp azfake.Responder[armazurearcdata.SQLServerEsuLicensesClientCreateResponse], errResp azfake.ErrorResponder) + + // Delete is the fake for method SQLServerEsuLicensesClient.Delete + // HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent + Delete func(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, options *armazurearcdata.SQLServerEsuLicensesClientDeleteOptions) (resp azfake.Responder[armazurearcdata.SQLServerEsuLicensesClientDeleteResponse], errResp azfake.ErrorResponder) + + // Get is the fake for method SQLServerEsuLicensesClient.Get + // HTTP status codes to indicate success: http.StatusOK + Get func(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, options *armazurearcdata.SQLServerEsuLicensesClientGetOptions) (resp azfake.Responder[armazurearcdata.SQLServerEsuLicensesClientGetResponse], errResp azfake.ErrorResponder) + + // NewListPager is the fake for method SQLServerEsuLicensesClient.NewListPager + // HTTP status codes to indicate success: http.StatusOK + NewListPager func(options *armazurearcdata.SQLServerEsuLicensesClientListOptions) (resp azfake.PagerResponder[armazurearcdata.SQLServerEsuLicensesClientListResponse]) + + // NewListByResourceGroupPager is the fake for method SQLServerEsuLicensesClient.NewListByResourceGroupPager + // HTTP status codes to indicate success: http.StatusOK + NewListByResourceGroupPager func(resourceGroupName string, options *armazurearcdata.SQLServerEsuLicensesClientListByResourceGroupOptions) (resp azfake.PagerResponder[armazurearcdata.SQLServerEsuLicensesClientListByResourceGroupResponse]) + + // Update is the fake for method SQLServerEsuLicensesClient.Update + // HTTP status codes to indicate success: http.StatusOK + Update func(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, parameters armazurearcdata.SQLServerEsuLicenseUpdate, options *armazurearcdata.SQLServerEsuLicensesClientUpdateOptions) (resp azfake.Responder[armazurearcdata.SQLServerEsuLicensesClientUpdateResponse], errResp azfake.ErrorResponder) +} + +// NewSQLServerEsuLicensesServerTransport creates a new instance of SQLServerEsuLicensesServerTransport with the provided implementation. +// The returned SQLServerEsuLicensesServerTransport instance is connected to an instance of armazurearcdata.SQLServerEsuLicensesClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewSQLServerEsuLicensesServerTransport(srv *SQLServerEsuLicensesServer) *SQLServerEsuLicensesServerTransport { + return &SQLServerEsuLicensesServerTransport{ + srv: srv, + newListPager: newTracker[azfake.PagerResponder[armazurearcdata.SQLServerEsuLicensesClientListResponse]](), + newListByResourceGroupPager: newTracker[azfake.PagerResponder[armazurearcdata.SQLServerEsuLicensesClientListByResourceGroupResponse]](), + } +} + +// SQLServerEsuLicensesServerTransport connects instances of armazurearcdata.SQLServerEsuLicensesClient to instances of SQLServerEsuLicensesServer. +// Don't use this type directly, use NewSQLServerEsuLicensesServerTransport instead. +type SQLServerEsuLicensesServerTransport struct { + srv *SQLServerEsuLicensesServer + newListPager *tracker[azfake.PagerResponder[armazurearcdata.SQLServerEsuLicensesClientListResponse]] + newListByResourceGroupPager *tracker[azfake.PagerResponder[armazurearcdata.SQLServerEsuLicensesClientListByResourceGroupResponse]] +} + +// Do implements the policy.Transporter interface for SQLServerEsuLicensesServerTransport. +func (s *SQLServerEsuLicensesServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + var resp *http.Response + var err error + + switch method { + case "SQLServerEsuLicensesClient.Create": + resp, err = s.dispatchCreate(req) + case "SQLServerEsuLicensesClient.Delete": + resp, err = s.dispatchDelete(req) + case "SQLServerEsuLicensesClient.Get": + resp, err = s.dispatchGet(req) + case "SQLServerEsuLicensesClient.NewListPager": + resp, err = s.dispatchNewListPager(req) + case "SQLServerEsuLicensesClient.NewListByResourceGroupPager": + resp, err = s.dispatchNewListByResourceGroupPager(req) + case "SQLServerEsuLicensesClient.Update": + resp, err = s.dispatchUpdate(req) + default: + err = fmt.Errorf("unhandled API %s", method) + } + + if err != nil { + return nil, err + } + + return resp, nil +} + +func (s *SQLServerEsuLicensesServerTransport) dispatchCreate(req *http.Request) (*http.Response, error) { + if s.srv.Create == nil { + return nil, &nonRetriableError{errors.New("fake for method Create not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerEsuLicenses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerEsuLicense](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerEsuLicenseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerEsuLicenseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Create(req.Context(), resourceGroupNameParam, sqlServerEsuLicenseNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK, http.StatusCreated}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusCreated", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerEsuLicense, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerEsuLicensesServerTransport) dispatchDelete(req *http.Request) (*http.Response, error) { + if s.srv.Delete == nil { + return nil, &nonRetriableError{errors.New("fake for method Delete not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerEsuLicenses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerEsuLicenseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerEsuLicenseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Delete(req.Context(), resourceGroupNameParam, sqlServerEsuLicenseNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK, http.StatusNoContent}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusNoContent", respContent.HTTPStatus)} + } + resp, err := server.NewResponse(respContent, req, nil) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerEsuLicensesServerTransport) dispatchGet(req *http.Request) (*http.Response, error) { + if s.srv.Get == nil { + return nil, &nonRetriableError{errors.New("fake for method Get not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerEsuLicenses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerEsuLicenseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerEsuLicenseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Get(req.Context(), resourceGroupNameParam, sqlServerEsuLicenseNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerEsuLicense, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerEsuLicensesServerTransport) dispatchNewListPager(req *http.Request) (*http.Response, error) { + if s.srv.NewListPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListPager not implemented")} + } + newListPager := s.newListPager.get(req) + if newListPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerEsuLicenses` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 1 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resp := s.srv.NewListPager(nil) + newListPager = &resp + s.newListPager.add(req, newListPager) + server.PagerResponderInjectNextLinks(newListPager, req, func(page *armazurearcdata.SQLServerEsuLicensesClientListResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + s.newListPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListPager) { + s.newListPager.remove(req) + } + return resp, nil +} + +func (s *SQLServerEsuLicensesServerTransport) dispatchNewListByResourceGroupPager(req *http.Request) (*http.Response, error) { + if s.srv.NewListByResourceGroupPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListByResourceGroupPager not implemented")} + } + newListByResourceGroupPager := s.newListByResourceGroupPager.get(req) + if newListByResourceGroupPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerEsuLicenses` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 2 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + resp := s.srv.NewListByResourceGroupPager(resourceGroupNameParam, nil) + newListByResourceGroupPager = &resp + s.newListByResourceGroupPager.add(req, newListByResourceGroupPager) + server.PagerResponderInjectNextLinks(newListByResourceGroupPager, req, func(page *armazurearcdata.SQLServerEsuLicensesClientListByResourceGroupResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListByResourceGroupPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + s.newListByResourceGroupPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListByResourceGroupPager) { + s.newListByResourceGroupPager.remove(req) + } + return resp, nil +} + +func (s *SQLServerEsuLicensesServerTransport) dispatchUpdate(req *http.Request) (*http.Response, error) { + if s.srv.Update == nil { + return nil, &nonRetriableError{errors.New("fake for method Update not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerEsuLicenses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerEsuLicenseUpdate](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerEsuLicenseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerEsuLicenseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Update(req.Context(), resourceGroupNameParam, sqlServerEsuLicenseNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerEsuLicense, req) + if err != nil { + return nil, err + } + return resp, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserverinstances_server.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserverinstances_server.go index 0f23189694b8..6785cfb6bc03 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserverinstances_server.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserverinstances_server.go @@ -19,6 +19,7 @@ import ( "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" "net/http" "net/url" + "reflect" "regexp" ) @@ -36,6 +37,14 @@ type SQLServerInstancesServer struct { // HTTP status codes to indicate success: http.StatusOK Get func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *armazurearcdata.SQLServerInstancesClientGetOptions) (resp azfake.Responder[armazurearcdata.SQLServerInstancesClientGetResponse], errResp azfake.ErrorResponder) + // GetJobsStatus is the fake for method SQLServerInstancesClient.GetJobsStatus + // HTTP status codes to indicate success: http.StatusOK + GetJobsStatus func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *armazurearcdata.SQLServerInstancesClientGetJobsStatusOptions) (resp azfake.Responder[armazurearcdata.SQLServerInstancesClientGetJobsStatusResponse], errResp azfake.ErrorResponder) + + // BeginGetTelemetry is the fake for method SQLServerInstancesClient.BeginGetTelemetry + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted + BeginGetTelemetry func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, sqlServerInstanceTelemetryRequest armazurearcdata.SQLServerInstanceTelemetryRequest, options *armazurearcdata.SQLServerInstancesClientBeginGetTelemetryOptions) (resp azfake.PollerResponder[azfake.PagerResponder[armazurearcdata.SQLServerInstancesClientGetTelemetryResponse]], errResp azfake.ErrorResponder) + // NewListPager is the fake for method SQLServerInstancesClient.NewListPager // HTTP status codes to indicate success: http.StatusOK NewListPager func(options *armazurearcdata.SQLServerInstancesClientListOptions) (resp azfake.PagerResponder[armazurearcdata.SQLServerInstancesClientListResponse]) @@ -44,9 +53,21 @@ type SQLServerInstancesServer struct { // HTTP status codes to indicate success: http.StatusOK NewListByResourceGroupPager func(resourceGroupName string, options *armazurearcdata.SQLServerInstancesClientListByResourceGroupOptions) (resp azfake.PagerResponder[armazurearcdata.SQLServerInstancesClientListByResourceGroupResponse]) - // Update is the fake for method SQLServerInstancesClient.Update + // PostUpgrade is the fake for method SQLServerInstancesClient.PostUpgrade + // HTTP status codes to indicate success: http.StatusOK + PostUpgrade func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *armazurearcdata.SQLServerInstancesClientPostUpgradeOptions) (resp azfake.Responder[armazurearcdata.SQLServerInstancesClientPostUpgradeResponse], errResp azfake.ErrorResponder) + + // PreUpgrade is the fake for method SQLServerInstancesClient.PreUpgrade // HTTP status codes to indicate success: http.StatusOK - Update func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, parameters armazurearcdata.SQLServerInstanceUpdate, options *armazurearcdata.SQLServerInstancesClientUpdateOptions) (resp azfake.Responder[armazurearcdata.SQLServerInstancesClientUpdateResponse], errResp azfake.ErrorResponder) + PreUpgrade func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *armazurearcdata.SQLServerInstancesClientPreUpgradeOptions) (resp azfake.Responder[armazurearcdata.SQLServerInstancesClientPreUpgradeResponse], errResp azfake.ErrorResponder) + + // RunMigrationAssessment is the fake for method SQLServerInstancesClient.RunMigrationAssessment + // HTTP status codes to indicate success: http.StatusOK + RunMigrationAssessment func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *armazurearcdata.SQLServerInstancesClientRunMigrationAssessmentOptions) (resp azfake.Responder[armazurearcdata.SQLServerInstancesClientRunMigrationAssessmentResponse], errResp azfake.ErrorResponder) + + // BeginUpdate is the fake for method SQLServerInstancesClient.BeginUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted + BeginUpdate func(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, parameters armazurearcdata.SQLServerInstanceUpdate, options *armazurearcdata.SQLServerInstancesClientBeginUpdateOptions) (resp azfake.PollerResponder[armazurearcdata.SQLServerInstancesClientUpdateResponse], errResp azfake.ErrorResponder) } // NewSQLServerInstancesServerTransport creates a new instance of SQLServerInstancesServerTransport with the provided implementation. @@ -57,8 +78,10 @@ func NewSQLServerInstancesServerTransport(srv *SQLServerInstancesServer) *SQLSer srv: srv, beginCreate: newTracker[azfake.PollerResponder[armazurearcdata.SQLServerInstancesClientCreateResponse]](), beginDelete: newTracker[azfake.PollerResponder[armazurearcdata.SQLServerInstancesClientDeleteResponse]](), + beginGetTelemetry: newTracker[azfake.PollerResponder[azfake.PagerResponder[armazurearcdata.SQLServerInstancesClientGetTelemetryResponse]]](), newListPager: newTracker[azfake.PagerResponder[armazurearcdata.SQLServerInstancesClientListResponse]](), newListByResourceGroupPager: newTracker[azfake.PagerResponder[armazurearcdata.SQLServerInstancesClientListByResourceGroupResponse]](), + beginUpdate: newTracker[azfake.PollerResponder[armazurearcdata.SQLServerInstancesClientUpdateResponse]](), } } @@ -68,8 +91,10 @@ type SQLServerInstancesServerTransport struct { srv *SQLServerInstancesServer beginCreate *tracker[azfake.PollerResponder[armazurearcdata.SQLServerInstancesClientCreateResponse]] beginDelete *tracker[azfake.PollerResponder[armazurearcdata.SQLServerInstancesClientDeleteResponse]] + beginGetTelemetry *tracker[azfake.PollerResponder[azfake.PagerResponder[armazurearcdata.SQLServerInstancesClientGetTelemetryResponse]]] newListPager *tracker[azfake.PagerResponder[armazurearcdata.SQLServerInstancesClientListResponse]] newListByResourceGroupPager *tracker[azfake.PagerResponder[armazurearcdata.SQLServerInstancesClientListByResourceGroupResponse]] + beginUpdate *tracker[azfake.PollerResponder[armazurearcdata.SQLServerInstancesClientUpdateResponse]] } // Do implements the policy.Transporter interface for SQLServerInstancesServerTransport. @@ -90,12 +115,22 @@ func (s *SQLServerInstancesServerTransport) Do(req *http.Request) (*http.Respons resp, err = s.dispatchBeginDelete(req) case "SQLServerInstancesClient.Get": resp, err = s.dispatchGet(req) + case "SQLServerInstancesClient.GetJobsStatus": + resp, err = s.dispatchGetJobsStatus(req) + case "SQLServerInstancesClient.BeginGetTelemetry": + resp, err = s.dispatchBeginGetTelemetry(req) case "SQLServerInstancesClient.NewListPager": resp, err = s.dispatchNewListPager(req) case "SQLServerInstancesClient.NewListByResourceGroupPager": resp, err = s.dispatchNewListByResourceGroupPager(req) - case "SQLServerInstancesClient.Update": - resp, err = s.dispatchUpdate(req) + case "SQLServerInstancesClient.PostUpgrade": + resp, err = s.dispatchPostUpgrade(req) + case "SQLServerInstancesClient.PreUpgrade": + resp, err = s.dispatchPreUpgrade(req) + case "SQLServerInstancesClient.RunMigrationAssessment": + resp, err = s.dispatchRunMigrationAssessment(req) + case "SQLServerInstancesClient.BeginUpdate": + resp, err = s.dispatchBeginUpdate(req) default: err = fmt.Errorf("unhandled API %s", method) } @@ -232,6 +267,97 @@ func (s *SQLServerInstancesServerTransport) dispatchGet(req *http.Request) (*htt return resp, nil } +func (s *SQLServerInstancesServerTransport) dispatchGetJobsStatus(req *http.Request) (*http.Response, error) { + if s.srv.GetJobsStatus == nil { + return nil, &nonRetriableError{errors.New("fake for method GetJobsStatus not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/getJobsStatus` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerInstanceJobsStatusRequest](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + var options *armazurearcdata.SQLServerInstancesClientGetJobsStatusOptions + if !reflect.ValueOf(body).IsZero() { + options = &armazurearcdata.SQLServerInstancesClientGetJobsStatusOptions{ + SQLServerInstanceJobsStatusRequest: &body, + } + } + respr, errRespr := s.srv.GetJobsStatus(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, options) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerInstanceJobsStatusResponse, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerInstancesServerTransport) dispatchBeginGetTelemetry(req *http.Request) (*http.Response, error) { + if s.srv.BeginGetTelemetry == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginGetTelemetry not implemented")} + } + beginGetTelemetry := s.beginGetTelemetry.get(req) + if beginGetTelemetry == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/getTelemetry` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerInstanceTelemetryRequest](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginGetTelemetry(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginGetTelemetry = &respr + s.beginGetTelemetry.add(req, beginGetTelemetry) + } + + resp, err := server.PollerResponderNext(beginGetTelemetry, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) { + s.beginGetTelemetry.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted", resp.StatusCode)} + } + if !server.PollerResponderMore(beginGetTelemetry) { + s.beginGetTelemetry.remove(req) + } + + return resp, nil +} + func (s *SQLServerInstancesServerTransport) dispatchNewListPager(req *http.Request) (*http.Response, error) { if s.srv.NewListPager == nil { return nil, &nonRetriableError{errors.New("fake for method NewListPager not implemented")} @@ -302,20 +428,49 @@ func (s *SQLServerInstancesServerTransport) dispatchNewListByResourceGroupPager( return resp, nil } -func (s *SQLServerInstancesServerTransport) dispatchUpdate(req *http.Request) (*http.Response, error) { - if s.srv.Update == nil { - return nil, &nonRetriableError{errors.New("fake for method Update not implemented")} +func (s *SQLServerInstancesServerTransport) dispatchPostUpgrade(req *http.Request) (*http.Response, error) { + if s.srv.PostUpgrade == nil { + return nil, &nonRetriableError{errors.New("fake for method PostUpgrade not implemented")} } - const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/postUpgrade` regex := regexp.MustCompile(regexStr) matches := regex.FindStringSubmatch(req.URL.EscapedPath()) if matches == nil || len(matches) < 3 { return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) } - body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerInstanceUpdate](req) + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.PostUpgrade(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerInstance, req) if err != nil { return nil, err } + return resp, nil +} + +func (s *SQLServerInstancesServerTransport) dispatchPreUpgrade(req *http.Request) (*http.Response, error) { + if s.srv.PreUpgrade == nil { + return nil, &nonRetriableError{errors.New("fake for method PreUpgrade not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/preUpgrade` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) if err != nil { return nil, err @@ -324,7 +479,7 @@ func (s *SQLServerInstancesServerTransport) dispatchUpdate(req *http.Request) (* if err != nil { return nil, err } - respr, errRespr := s.srv.Update(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, body, nil) + respr, errRespr := s.srv.PreUpgrade(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, nil) if respErr := server.GetError(errRespr, req); respErr != nil { return nil, respErr } @@ -338,3 +493,84 @@ func (s *SQLServerInstancesServerTransport) dispatchUpdate(req *http.Request) (* } return resp, nil } + +func (s *SQLServerInstancesServerTransport) dispatchRunMigrationAssessment(req *http.Request) (*http.Response, error) { + if s.srv.RunMigrationAssessment == nil { + return nil, &nonRetriableError{errors.New("fake for method RunMigrationAssessment not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/runMigrationAssessment` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.RunMigrationAssessment(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerInstanceRunMigrationAssessmentResponse, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerInstancesServerTransport) dispatchBeginUpdate(req *http.Request) (*http.Response, error) { + if s.srv.BeginUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginUpdate not implemented")} + } + beginUpdate := s.beginUpdate.get(req) + if beginUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerInstances/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerInstanceUpdate](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerInstanceNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerInstanceName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginUpdate(req.Context(), resourceGroupNameParam, sqlServerInstanceNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginUpdate = &respr + s.beginUpdate.add(req, beginUpdate) + } + + resp, err := server.PollerResponderNext(beginUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) { + s.beginUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted", resp.StatusCode)} + } + if !server.PollerResponderMore(beginUpdate) { + s.beginUpdate.remove(req) + } + + return resp, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserverlicenses_server.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserverlicenses_server.go new file mode 100644 index 000000000000..8051d34d12e1 --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/sqlserverlicenses_server.go @@ -0,0 +1,314 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package fake + +import ( + "context" + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" + "net/http" + "net/url" + "regexp" +) + +// SQLServerLicensesServer is a fake server for instances of the armazurearcdata.SQLServerLicensesClient type. +type SQLServerLicensesServer struct { + // Create is the fake for method SQLServerLicensesClient.Create + // HTTP status codes to indicate success: http.StatusOK, http.StatusCreated + Create func(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, sqlServerLicense armazurearcdata.SQLServerLicense, options *armazurearcdata.SQLServerLicensesClientCreateOptions) (resp azfake.Responder[armazurearcdata.SQLServerLicensesClientCreateResponse], errResp azfake.ErrorResponder) + + // Delete is the fake for method SQLServerLicensesClient.Delete + // HTTP status codes to indicate success: http.StatusOK, http.StatusNoContent + Delete func(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, options *armazurearcdata.SQLServerLicensesClientDeleteOptions) (resp azfake.Responder[armazurearcdata.SQLServerLicensesClientDeleteResponse], errResp azfake.ErrorResponder) + + // Get is the fake for method SQLServerLicensesClient.Get + // HTTP status codes to indicate success: http.StatusOK + Get func(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, options *armazurearcdata.SQLServerLicensesClientGetOptions) (resp azfake.Responder[armazurearcdata.SQLServerLicensesClientGetResponse], errResp azfake.ErrorResponder) + + // NewListPager is the fake for method SQLServerLicensesClient.NewListPager + // HTTP status codes to indicate success: http.StatusOK + NewListPager func(options *armazurearcdata.SQLServerLicensesClientListOptions) (resp azfake.PagerResponder[armazurearcdata.SQLServerLicensesClientListResponse]) + + // NewListByResourceGroupPager is the fake for method SQLServerLicensesClient.NewListByResourceGroupPager + // HTTP status codes to indicate success: http.StatusOK + NewListByResourceGroupPager func(resourceGroupName string, options *armazurearcdata.SQLServerLicensesClientListByResourceGroupOptions) (resp azfake.PagerResponder[armazurearcdata.SQLServerLicensesClientListByResourceGroupResponse]) + + // Update is the fake for method SQLServerLicensesClient.Update + // HTTP status codes to indicate success: http.StatusOK + Update func(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, parameters armazurearcdata.SQLServerLicenseUpdate, options *armazurearcdata.SQLServerLicensesClientUpdateOptions) (resp azfake.Responder[armazurearcdata.SQLServerLicensesClientUpdateResponse], errResp azfake.ErrorResponder) +} + +// NewSQLServerLicensesServerTransport creates a new instance of SQLServerLicensesServerTransport with the provided implementation. +// The returned SQLServerLicensesServerTransport instance is connected to an instance of armazurearcdata.SQLServerLicensesClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewSQLServerLicensesServerTransport(srv *SQLServerLicensesServer) *SQLServerLicensesServerTransport { + return &SQLServerLicensesServerTransport{ + srv: srv, + newListPager: newTracker[azfake.PagerResponder[armazurearcdata.SQLServerLicensesClientListResponse]](), + newListByResourceGroupPager: newTracker[azfake.PagerResponder[armazurearcdata.SQLServerLicensesClientListByResourceGroupResponse]](), + } +} + +// SQLServerLicensesServerTransport connects instances of armazurearcdata.SQLServerLicensesClient to instances of SQLServerLicensesServer. +// Don't use this type directly, use NewSQLServerLicensesServerTransport instead. +type SQLServerLicensesServerTransport struct { + srv *SQLServerLicensesServer + newListPager *tracker[azfake.PagerResponder[armazurearcdata.SQLServerLicensesClientListResponse]] + newListByResourceGroupPager *tracker[azfake.PagerResponder[armazurearcdata.SQLServerLicensesClientListByResourceGroupResponse]] +} + +// Do implements the policy.Transporter interface for SQLServerLicensesServerTransport. +func (s *SQLServerLicensesServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + var resp *http.Response + var err error + + switch method { + case "SQLServerLicensesClient.Create": + resp, err = s.dispatchCreate(req) + case "SQLServerLicensesClient.Delete": + resp, err = s.dispatchDelete(req) + case "SQLServerLicensesClient.Get": + resp, err = s.dispatchGet(req) + case "SQLServerLicensesClient.NewListPager": + resp, err = s.dispatchNewListPager(req) + case "SQLServerLicensesClient.NewListByResourceGroupPager": + resp, err = s.dispatchNewListByResourceGroupPager(req) + case "SQLServerLicensesClient.Update": + resp, err = s.dispatchUpdate(req) + default: + err = fmt.Errorf("unhandled API %s", method) + } + + if err != nil { + return nil, err + } + + return resp, nil +} + +func (s *SQLServerLicensesServerTransport) dispatchCreate(req *http.Request) (*http.Response, error) { + if s.srv.Create == nil { + return nil, &nonRetriableError{errors.New("fake for method Create not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerLicenses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerLicense](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerLicenseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerLicenseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Create(req.Context(), resourceGroupNameParam, sqlServerLicenseNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK, http.StatusCreated}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusCreated", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerLicense, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerLicensesServerTransport) dispatchDelete(req *http.Request) (*http.Response, error) { + if s.srv.Delete == nil { + return nil, &nonRetriableError{errors.New("fake for method Delete not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerLicenses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerLicenseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerLicenseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Delete(req.Context(), resourceGroupNameParam, sqlServerLicenseNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK, http.StatusNoContent}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusNoContent", respContent.HTTPStatus)} + } + resp, err := server.NewResponse(respContent, req, nil) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerLicensesServerTransport) dispatchGet(req *http.Request) (*http.Response, error) { + if s.srv.Get == nil { + return nil, &nonRetriableError{errors.New("fake for method Get not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerLicenses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerLicenseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerLicenseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Get(req.Context(), resourceGroupNameParam, sqlServerLicenseNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerLicense, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SQLServerLicensesServerTransport) dispatchNewListPager(req *http.Request) (*http.Response, error) { + if s.srv.NewListPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListPager not implemented")} + } + newListPager := s.newListPager.get(req) + if newListPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerLicenses` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 1 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resp := s.srv.NewListPager(nil) + newListPager = &resp + s.newListPager.add(req, newListPager) + server.PagerResponderInjectNextLinks(newListPager, req, func(page *armazurearcdata.SQLServerLicensesClientListResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + s.newListPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListPager) { + s.newListPager.remove(req) + } + return resp, nil +} + +func (s *SQLServerLicensesServerTransport) dispatchNewListByResourceGroupPager(req *http.Request) (*http.Response, error) { + if s.srv.NewListByResourceGroupPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListByResourceGroupPager not implemented")} + } + newListByResourceGroupPager := s.newListByResourceGroupPager.get(req) + if newListByResourceGroupPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerLicenses` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 2 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + resp := s.srv.NewListByResourceGroupPager(resourceGroupNameParam, nil) + newListByResourceGroupPager = &resp + s.newListByResourceGroupPager.add(req, newListByResourceGroupPager) + server.PagerResponderInjectNextLinks(newListByResourceGroupPager, req, func(page *armazurearcdata.SQLServerLicensesClientListByResourceGroupResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListByResourceGroupPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + s.newListByResourceGroupPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListByResourceGroupPager) { + s.newListByResourceGroupPager.remove(req) + } + return resp, nil +} + +func (s *SQLServerLicensesServerTransport) dispatchUpdate(req *http.Request) (*http.Response, error) { + if s.srv.Update == nil { + return nil, &nonRetriableError{errors.New("fake for method Update not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AzureArcData/sqlServerLicenses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if matches == nil || len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armazurearcdata.SQLServerLicenseUpdate](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + sqlServerLicenseNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("sqlServerLicenseName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Update(req.Context(), resourceGroupNameParam, sqlServerLicenseNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SQLServerLicense, req) + if err != nil { + return nil, err + } + return resp, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/time_rfc3339.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/time_rfc3339.go index b0535a7b63e6..81f308b0d343 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/time_rfc3339.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/fake/time_rfc3339.go @@ -19,12 +19,16 @@ import ( ) // Azure reports time in UTC but it doesn't include the 'Z' time zone suffix in some cases. -var tzOffsetRegex = regexp.MustCompile(`(Z|z|\+|-)(\d+:\d+)*"*$`) +var tzOffsetRegex = regexp.MustCompile(`(?:Z|z|\+|-)(?:\d+:\d+)*"*$`) const ( - utcDateTimeJSON = `"2006-01-02T15:04:05.999999999"` - utcDateTime = "2006-01-02T15:04:05.999999999" - dateTimeJSON = `"` + time.RFC3339Nano + `"` + utcDateTime = "2006-01-02T15:04:05.999999999" + utcDateTimeJSON = `"` + utcDateTime + `"` + utcDateTimeNoT = "2006-01-02 15:04:05.999999999" + utcDateTimeJSONNoT = `"` + utcDateTimeNoT + `"` + dateTimeNoT = `2006-01-02 15:04:05.999999999Z07:00` + dateTimeJSON = `"` + time.RFC3339Nano + `"` + dateTimeJSONNoT = `"` + dateTimeNoT + `"` ) type dateTimeRFC3339 time.Time @@ -40,17 +44,33 @@ func (t dateTimeRFC3339) MarshalText() ([]byte, error) { } func (t *dateTimeRFC3339) UnmarshalJSON(data []byte) error { - layout := utcDateTimeJSON - if tzOffsetRegex.Match(data) { + tzOffset := tzOffsetRegex.Match(data) + hasT := strings.Contains(string(data), "T") || strings.Contains(string(data), "t") + var layout string + if tzOffset && hasT { layout = dateTimeJSON + } else if tzOffset { + layout = dateTimeJSONNoT + } else if hasT { + layout = utcDateTimeJSON + } else { + layout = utcDateTimeJSONNoT } return t.Parse(layout, string(data)) } func (t *dateTimeRFC3339) UnmarshalText(data []byte) error { - layout := utcDateTime - if tzOffsetRegex.Match(data) { + tzOffset := tzOffsetRegex.Match(data) + hasT := strings.Contains(string(data), "T") || strings.Contains(string(data), "t") + var layout string + if tzOffset && hasT { layout = time.RFC3339Nano + } else if tzOffset { + layout = dateTimeNoT + } else if hasT { + layout = utcDateTime + } else { + layout = utcDateTimeNoT } return t.Parse(layout, string(data)) } @@ -61,6 +81,10 @@ func (t *dateTimeRFC3339) Parse(layout, value string) error { return err } +func (t dateTimeRFC3339) String() string { + return time.Time(t).Format(time.RFC3339Nano) +} + func populateDateTimeRFC3339(m map[string]any, k string, t *time.Time) { if t == nil { return @@ -74,7 +98,7 @@ func populateDateTimeRFC3339(m map[string]any, k string, t *time.Time) { } func unpopulateDateTimeRFC3339(data json.RawMessage, fn string, t **time.Time) error { - if data == nil || strings.EqualFold(string(data), "null") { + if data == nil || string(data) == "null" { return nil } var aux dateTimeRFC3339 diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/go.mod b/sdk/resourcemanager/azurearcdata/armazurearcdata/go.mod index 5cad1be8f880..592e28bb4d72 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/go.mod +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/go.mod @@ -2,20 +2,10 @@ module github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazu go 1.18 -require ( - github.com/Azure/azure-sdk-for-go/sdk/azcore v1.13.0 - github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0 -) +require github.com/Azure/azure-sdk-for-go/sdk/azcore v1.13.0 require ( github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 // indirect - github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 // indirect - github.com/golang-jwt/jwt/v5 v5.2.1 // indirect - github.com/google/uuid v1.6.0 // indirect - github.com/kylelemons/godebug v1.1.0 // indirect - github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect - golang.org/x/crypto v0.25.0 // indirect golang.org/x/net v0.27.0 // indirect - golang.org/x/sys v0.22.0 // indirect golang.org/x/text v0.16.0 // indirect ) diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/go.sum b/sdk/resourcemanager/azurearcdata/armazurearcdata/go.sum index 09d275cb9a37..917448a001b7 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/go.sum +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/go.sum @@ -1,29 +1,12 @@ github.com/Azure/azure-sdk-for-go/sdk/azcore v1.13.0 h1:GJHeeA2N7xrG3q30L2UXDyuWRzDM900/65j70wcM4Ww= github.com/Azure/azure-sdk-for-go/sdk/azcore v1.13.0/go.mod h1:l38EPgmsp71HHLq9j7De57JcKOWPyhrsW1Awm1JS6K0= -github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0 h1:tfLQ34V6F7tVSwoTf/4lH5sE0o6eCJuNDTmH09nDpbc= -github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0/go.mod h1:9kIvujWAA58nmPmWB1m23fyWic1kYZMxD9CxaWn4Qpg= github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 h1:ywEEhmNahHBihViHepv3xPBn1663uRv2t2q/ESv9seY= github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0/go.mod h1:iZDifYGJTIgIIkYRNWPENUnqx6bJ2xnSDFI2tjwZNuY= -github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 h1:XHOnouVk1mxXfQidrMEnLlPk9UMeRtyBTnEFtxkV0kU= -github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk= -github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= -github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= -github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= -github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30= -golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M= golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys= golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE= -golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI= -golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/models.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/models.go index 5a970efedc01..e127f21f4fbc 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/models.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/models.go @@ -27,12 +27,12 @@ type ActiveDirectoryConnectorDNSDetails struct { // ActiveDirectoryConnectorDomainDetails - Active Directory domain details type ActiveDirectoryConnectorDomainDetails struct { - // REQUIRED; null - DomainControllers *ActiveDirectoryDomainControllers - // REQUIRED; Name (uppercase) of the Active Directory domain that this AD connector will be associated with. Realm *string + // null + DomainControllers *ActiveDirectoryDomainControllers + // NETBIOS name of the Active Directory domain. NetbiosDomainName *string @@ -131,6 +131,305 @@ type ActiveDirectoryInformation struct { KeytabInformation *KeytabInformation } +// ArcSQLServerAvailabilityGroupListResult - A list of Arc Sql Server Availability Groups. +type ArcSQLServerAvailabilityGroupListResult struct { + // READ-ONLY; Link to retrieve next page of results. + NextLink *string + + // READ-ONLY; Array of Arc Sql Server Availability Groups. + Value []*SQLServerAvailabilityGroupResource +} + +// ArcSQLServerDatabaseListResult - A list of Arc Sql Server database. +type ArcSQLServerDatabaseListResult struct { + // READ-ONLY; Link to retrieve next page of results. + NextLink *string + + // READ-ONLY; Array of Arc Sql Server database. + Value []*SQLServerDatabaseResource +} + +// AvailabilityGroupConfigure - The specifications of the availability group replica configuration +type AvailabilityGroupConfigure struct { + // Property that determines whether a given availability replica can run in synchronous-commit mode + AvailabilityMode *ArcSQLServerAvailabilityMode + + // Represents the user-specified priority for performing backups on this replica relative to the other replicas in the same + // availability group. + BackupPriority *int32 + + // Name of certificate to use for authentication. Required if any CERTIFICATE authentication modes are specified. + CertificateName *string + + // Permitted authentication modes for the mirroring endpoint. + EndpointAuthenticationMode *ConnectionAuth + + // The login which will connect to the mirroring endpoint. + EndpointConnectLogin *string + + // Name of the mirroring endpoint URL + EndpointName *string + + // Mirroring endpoint URL of availability group replica + EndpointURL *string + + // Property to set the failover mode of the availability group replica + FailoverMode *ArcSQLServerFailoverMode + + // Whether the primary replica should allow all connections or only READ_WRITE connections (disallowing ReadOnly connections) + PrimaryAllowConnections *PrimaryAllowConnections + + // Connectivity endpoint (URL) of the read only availability replica. + ReadOnlyRoutingURL *string + + // Connectivity endpoint (URL) of the read write availability replica. + ReadWriteRoutingURL *string + + // Whether the secondary replica should allow all connections, no connections, or only ReadOnly connections. + SecondaryAllowConnections *SecondaryAllowConnections + + // Specifies how the secondary replica will be initially seeded. AUTOMATIC enables direct seeding. This method will seed the + // secondary replica over the network. This method does not require you to backup + // and restore a copy of the primary database on the replica. MANUAL specifies manual seeding (default). This method requires + // you to create a backup of the database on the primary replica and manually + // restore that backup on the secondary replica. + SeedingMode *SeedingMode + + // The time-out period of availability group session replica, in seconds. + SessionTimeout *int32 + + // READ-ONLY; The Availability Synchronization mode of the availability group replica. + AvailabilityModeDescription *string + + // READ-ONLY; The failover mode of the availability group replica. + FailoverModeDescription *string + + // READ-ONLY; Whether the availability allows all connections or only read-write connections. + PrimaryRoleAllowConnectionsDescription *string + + // READ-ONLY; Date that the replica was created. + ReplicaCreateDate *time.Time + + // READ-ONLY; Date that the replica was modified. + ReplicaModifyDate *time.Time + + // READ-ONLY; Whether an availability replica that is performing the secondary role (that is, a secondary replica) can accept + // connections from clients. + SecondaryRoleAllowConnectionsDescription *string + + // READ-ONLY; Describes seeding mode. + SeedingModeDescription *string +} + +// AvailabilityGroupCreateUpdateConfiguration - Options used in creating an availability group +type AvailabilityGroupCreateUpdateConfiguration struct { + // Preferred replica for running automated backups. + AutomatedBackupPreference *AutomatedBackupPreference + + // Name of the availability group. + AvailabilityGroupName *string + + // Set to WSFC when availability group is on a failover cluster instance on a Windows Server failover cluster. Set to NONE + // when availability group not using WSFC for cluster coordination. + ClusterType *ClusterType + + // List of databases to include in the availability group. + Databases []*string + + // Specifies whether the availability group supports failover for database health conditions. + DbFailover *DbFailover + + // Specifies whether DTC support has been enabled for this availability group. + DtcSupport *DtcSupport + + // User-defined failure condition level under which an automatic failover must be triggered. + FailureConditionLevel *FailureConditionLevel + + // Wait time (in milliseconds) for the spserverdiagnostics system stored procedure to return server-health information, before + // the server instance is assumed to be slow or not responding. + HealthCheckTimeout *int32 + + // The listener for the sql server availability group + Listener *SQLAvailabilityGroupStaticIPListenerProperties + + // List of availability group replicas. + Replicas []*AvailabilityGroupCreateUpdateReplicaConfiguration + + // The number of secondary replicas that must be in a synchronized state for a commit to complete. + RequiredSynchronizedSecondariesToCommit *int32 +} + +// AvailabilityGroupCreateUpdateReplicaConfiguration - The specifications of the availability group replica configuration +type AvailabilityGroupCreateUpdateReplicaConfiguration struct { + // Property that determines whether a given availability replica can run in synchronous-commit mode + AvailabilityMode *ArcSQLServerAvailabilityMode + + // Represents the user-specified priority for performing backups on this replica relative to the other replicas in the same + // availability group. + BackupPriority *int32 + + // Name of certificate to use for authentication. Required if any CERTIFICATE authentication modes are specified. + CertificateName *string + + // Permitted authentication modes for the mirroring endpoint. + EndpointAuthenticationMode *ConnectionAuth + + // The login which will connect to the mirroring endpoint + EndpointConnectLogin *string + + // Name of the database mirroring endpoint URL for the availability group replica + EndpointName *string + + // Database mirroring endpoint URL of availability group replica + EndpointURL *string + + // Property to set the failover mode of the availability group replica + FailoverMode *ArcSQLServerFailoverMode + + // Whether the primary replica should allow all connections or only READ_WRITE connections (disallowing ReadOnly connections) + PrimaryRoleAllowConnections *PrimaryAllowConnections + + // List of read only routing URLs. + PrimaryRoleReadOnlyRoutingList []*string + + // Whether the secondary replica should allow all connections, no connections, or only ReadOnly connections. + SecondaryRoleAllowConnections *SecondaryAllowConnections + + // Connectivity endpoint (URL) of the read only availability replica. + SecondaryRoleReadOnlyRoutingURL *string + + // Specifies how the secondary replica will be initially seeded. AUTOMATIC enables direct seeding. This method will seed the + // secondary replica over the network. This method does not require you to backup + // and restore a copy of the primary database on the replica. MANUAL specifies manual seeding (default). This method requires + // you to create a backup of the database on the primary replica and manually + // restore that backup on the secondary replica. + SeedingMode *SeedingMode + + // the server instance hosting the replica. + ServerInstance *string + + // The time-out period of availability group session replica, in seconds. + SessionTimeout *int32 +} + +// AvailabilityGroupInfo - The specifications of the availability group state +type AvailabilityGroupInfo struct { + // Specifies whether this is a basic availability group. + BasicFeatures *bool + + // Specifies whether the availability group supports failover for database health conditions. + DbFailover *bool + + // Specifies whether DTC support has been enabled for this availability group. + DtcSupport *bool + + // User-defined failure condition level under which an automatic failover must be triggered. + FailureConditionLevel *int32 + + // Wait time (in milliseconds) for the spserverdiagnostics system stored procedure to return server-health information, before + // the server instance is assumed to be slow or not responding. + HealthCheckTimeout *int32 + + // SQL Server availability group contained system databases. + IsContained *bool + + // Specifies whether this is a distributed availability group. + IsDistributed *bool + + // The listener for the sql server availability group + Listener *SQLAvailabilityGroupStaticIPListenerProperties + + // The number of secondary replicas that must be in a synchronized state for a commit to complete. + RequiredSynchronizedSecondariesToCommit *int32 + + // READ-ONLY; Preferred location for performing backups on the availability databases in this availability group. + AutomatedBackupPreferenceDescription *string + + // READ-ONLY; SQL Server availability group cluster type description + ClusterTypeDescription *string + + // READ-ONLY; Indicates the recovery health of the primary replica. + PrimaryRecoveryHealthDescription *string + + // READ-ONLY; Name of the server instance that is hosting the current primary replica. + PrimaryReplica *string + + // READ-ONLY + ReplicationPartnerType *ReplicationPartnerType + + // READ-ONLY; Indicates the recovery health of a secondary replica. + SecondaryRecoveryHealthDescription *string + + // READ-ONLY; Reflects a roll-up of the synchronization health of all availability replicas in the availability group. + SynchronizationHealthDescription *string + + // READ-ONLY; SQL Server availability group current version. + Version *int32 +} + +// AvailabilityGroupState - The specifications of the availability group state +type AvailabilityGroupState struct { + // READ-ONLY; Current Always On availability groups role of the availability group replica. + AvailabilityGroupReplicaRole *string + + // READ-ONLY; Whether a secondary replica is currently connected to the primary replica. + ConnectedStateDescription *string + + // READ-ONLY; Text description of the last connection error of the availability group replica. + LastConnectErrorDescription *string + + // READ-ONLY; Date and time timestamp indicating when the last connect error occurred. + LastConnectErrorTimestamp *time.Time + + // READ-ONLY; Current operational state of the availability group replica + OperationalStateDescription *string + + // READ-ONLY; Recovery health of the availability group replica. + RecoveryHealthDescription *string + + // READ-ONLY; Reflects a rollup of the database synchronization state (synchronization_state) of all joined availability databases + // (also known as replicas) and the availability mode of the replica + // (synchronous-commit or asynchronous-commit mode). The rollup will reflect the least healthy accumulated state the databases + // on the replica. + SynchronizationHealthDescription *string +} + +// BackgroundJob - The background job details. +type BackgroundJob struct { + // The end time of the background job. + EndTime *time.Time + + // The execution state of the background job. + ExecutionState *ExecutionState + + // The last execution status of the background job. + LastExecutionStatus *LastExecutionStatus + + // The last execution time of the background job. + LastExecutionTime *time.Time + + // The start time of the background job. + StartTime *time.Time + + // The state of the background job. + State *State +} + +// BackupPolicy - The backup profile for the SQL server. +type BackupPolicy struct { + // The differential backup interval in hours. + DifferentialBackupHours *DifferentialBackupHours + + // The value indicating days between full backups. + FullBackupDays *int32 + + // The retention period for all the databases in this managed instance. + RetentionPeriodDays *int32 + + // The value indicating minutes between transaction log backups. + TransactionLogBackupMinutes *int32 +} + // BasicLoginInformation - Username and password for basic login authentication. type BasicLoginInformation struct { // Login password. @@ -140,6 +439,12 @@ type BasicLoginInformation struct { Username *string } +// ClientConnection - Client connection related configuration. +type ClientConnection struct { + // Indicates if client connection is enabled for this SQL Server instance. + Enabled *bool +} + // CommonSKU - The resource model definition representing SKU for ARM resources type CommonSKU struct { // REQUIRED; The name of the SKU. It is typically a letter+number code @@ -159,6 +464,54 @@ type CommonSKU struct { Size *string } +// DBMEndpoint - Database mirroring endpoint related properties. +type DBMEndpoint struct { + // READ-ONLY; Name of the certificate. + CertificateName *string + + // READ-ONLY; The type of connection authentication required for connections to this endpoint + ConnectionAuth *ConnectionAuth + + // READ-ONLY; Encryption Algorithm + EncryptionAlgorithm *EncryptionAlgorithm + + // READ-ONLY; Name of the database mirroring endpoint. + EndpointName *string + + // READ-ONLY; Listener IP address. + IPAddress *string + + // READ-ONLY; Is the port number dynamically assigned. + IsDynamicPort *bool + + // READ-ONLY; Is Encryption enabled + IsEncryptionEnabled *bool + + // READ-ONLY; The port number that the endpoint is listening on. + Port *int32 + + // READ-ONLY; Mirroring Role + Role *Role +} + +// DataBaseMigration - Migration related configuration. +type DataBaseMigration struct { + // Migration assessments related configuration. + Assessment *DataBaseMigrationAssessment +} + +// DataBaseMigrationAssessment - The migration assessment related configuration. +type DataBaseMigrationAssessment struct { + // READ-ONLY; The time when Migration Assessment Report upload was last performed. + AssessmentUploadTime *time.Time + + // READ-ONLY; Issues and warnings impacting the migration of Database to particular Azure Migration Target. + DatabaseAssessments []*DatabaseAssessmentsItem + + // READ-ONLY; The target readiness for migration for this database. + TargetReadiness *TargetReadiness +} + // DataControllerProperties - The data controller properties. type DataControllerProperties struct { // Deprecated. Azure Arc Data Services data controller no longer expose any endpoint. All traffic are exposed through Kubernetes @@ -238,27 +591,94 @@ type DataControllerUpdate struct { Tags map[string]*string } -// ErrorResponse - An error response from the Azure Data on Azure Arc service. -type ErrorResponse struct { - // null - Error *ErrorResponseBody +type DatabaseAssessmentsItem struct { + AppliesToMigrationTargetPlatform *string + FeatureID *string + IssueCategory *string + MoreInformation *string +} + +// Databases - List of database names. +type Databases struct { + // List of database names. + Values []*string +} + +// DistributedAvailabilityGroupCreateUpdateAvailabilityGroupCertificateConfiguration - The availability group certificate +// configuration. +type DistributedAvailabilityGroupCreateUpdateAvailabilityGroupCertificateConfiguration struct { + // Name of the certificate. + CertificateName *string } -// ErrorResponseBody - An error response from the Batch service. -type ErrorResponseBody struct { - // An identifier for the error. Codes are invariant and are intended to be consumed programmatically. +// DistributedAvailabilityGroupCreateUpdateAvailabilityGroupConfiguration - The availability group configuration specification +// for a distributed availability group. +type DistributedAvailabilityGroupCreateUpdateAvailabilityGroupConfiguration struct { + // The azure resource identifier for the availability group. + AvailabilityGroup *string + + // The availability mode of the availability group. + AvailabilityMode *ArcSQLServerAvailabilityMode + + // The certificate configuration for the availability group. + CertificateConfiguration *DistributedAvailabilityGroupCreateUpdateAvailabilityGroupCertificateConfiguration + + // The failover mode of the availability group. + FailoverMode *ArcSQLServerFailoverMode + + // The listener URL of the availability group. + ListenerURL *string + + // The seeding mode of the availability group. + SeedingMode *SeedingMode +} + +// DistributedAvailabilityGroupCreateUpdateConfiguration - Options used in creating a distributed availability group. +type DistributedAvailabilityGroupCreateUpdateConfiguration struct { + // Name of the availability group. + AvailabilityGroupName *string + + // The initial primary availability group for the distributed availability group. + PrimaryAvailabilityGroup *DistributedAvailabilityGroupCreateUpdateAvailabilityGroupConfiguration + + // The initial secondary availability group for the distributed availability group. + SecondaryAvailabilityGroup *DistributedAvailabilityGroupCreateUpdateAvailabilityGroupConfiguration +} + +// ErrorAdditionalInfo - The resource management error additional info. +type ErrorAdditionalInfo struct { + // READ-ONLY; The additional info. + Info any + + // READ-ONLY; The additional info type. + Type *string +} + +// ErrorDetail - The error detail. +type ErrorDetail struct { + // READ-ONLY; The error additional info. + AdditionalInfo []*ErrorAdditionalInfo + + // READ-ONLY; The error code. Code *string - // A list of additional details about the error. - Details []*ErrorResponseBody + // READ-ONLY; The error details. + Details []*ErrorDetail - // A message describing the error, intended to be suitable for display in a user interface. + // READ-ONLY; The error message. Message *string - // The target of the particular error. For example, the name of the property in error. + // READ-ONLY; The error target. Target *string } +// ErrorResponse - Common error response for all Azure Resource Manager APIs to return error details for failed operations. +// (This also follows the OData error response format.). +type ErrorResponse struct { + // The error object. + Error *ErrorDetail +} + // ExtendedLocation - The complex type of the extended location. type ExtendedLocation struct { // The name of the extended location. @@ -268,6 +688,127 @@ type ExtendedLocation struct { Type *ExtendedLocationTypes } +// FailoverCluster - Failover Cluster Instance properties. +type FailoverCluster struct { + // READ-ONLY; The host names which are part of the SQL FCI resource group. + HostNames []*string + + // READ-ONLY; The GUID of the SQL Server's underlying Failover Cluster. + ID *string + + // READ-ONLY; The network name to connect to the SQL FCI. + NetworkName *string + + // READ-ONLY; The ARM IDs of the Arc SQL Server resources, belonging to the current server's Failover cluster. + SQLInstanceIDs []*string +} + +// FailoverGroupListResult - A list of failover groups. +type FailoverGroupListResult struct { + // READ-ONLY; Link to retrieve next page of results. + NextLink *string + + // READ-ONLY; Array of failover group results. + Value []*FailoverGroupResource +} + +// FailoverGroupProperties - The properties of a failover group resource. +type FailoverGroupProperties struct { + // REQUIRED; The resource ID of the partner SQL managed instance. + PartnerManagedInstanceID *string + + // REQUIRED; The specifications of the failover group resource. + Spec *FailoverGroupSpec + + // OPTIONAL; Contains additional key/value pairs not defined in the schema. + AdditionalProperties map[string]any + + // The status of the failover group custom resource. + Status any + + // READ-ONLY; The provisioning state of the failover group resource. + ProvisioningState *ProvisioningState +} + +// FailoverGroupResource - A failover group resource. +type FailoverGroupResource struct { + // REQUIRED; null + Properties *FailoverGroupProperties + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// FailoverGroupSpec - The specifications of the failover group resource. +type FailoverGroupSpec struct { + // REQUIRED; The role of the SQL managed instance in this failover group. + Role *InstanceFailoverGroupRole + + // OPTIONAL; Contains additional key/value pairs not defined in the schema. + AdditionalProperties map[string]any + + // The name of the partner SQL managed instance. + PartnerMI *string + + // The mirroring endpoint public certificate for the partner SQL managed instance. Only PEM format is supported. + PartnerMirroringCert *string + + // The mirroring endpoint URL of the partner SQL managed instance. + PartnerMirroringURL *string + + // The partner sync mode of the SQL managed instance. + PartnerSyncMode *FailoverGroupPartnerSyncMode + + // The shared name of the failover group for this SQL managed instance. Both SQL managed instance and its partner have to + // use the same shared name. + SharedName *string + + // The name of the SQL managed instance with this failover group role. + SourceMI *string +} + +// K8SActiveDirectory - The kubernetes active directory information. +type K8SActiveDirectory struct { + // Account name for AAD + AccountName *string + Connector *K8SActiveDirectoryConnector + + // An array of encryption types + EncryptionTypes []*string + + // Keytab secret used to authenticate with Active Directory. + KeytabSecret *string +} + +type K8SActiveDirectoryConnector struct { + // Name of the connector + Name *string + + // Name space of the connector + Namespace *string +} + +// K8SNetworkSettings - The kubernetes network settings information. +type K8SNetworkSettings struct { + // If 1, then SQL Server forces all connections to be encrypted. By default, this option is 0 + Forceencryption *int32 + + // Specifies which ciphers are allowed by SQL Server for TLS + Tlsciphers *string + + // A comma-separated list of which TLS protocols are allowed by SQL Server + Tlsprotocols *string +} + // K8SResourceRequirements - The kubernetes resource limits and requests used to restrict or reserve resource usage. type K8SResourceRequirements struct { // OPTIONAL; Contains additional key/value pairs not defined in the schema. @@ -304,6 +845,42 @@ type K8SSchedulingOptions struct { Resources *K8SResourceRequirements } +// K8SSecurity - The kubernetes security information. +type K8SSecurity struct { + // The kubernetes active directory information. + ActiveDirectory *K8SActiveDirectory + + // OPTIONAL; Contains additional key/value pairs not defined in the schema. + AdditionalProperties map[string]any + + // Admin login secret key + AdminLoginSecret *string + + // Service certificate secret used + ServiceCertificateSecret *string + + // Transparent data encryption information. + TransparentDataEncryption *K8StransparentDataEncryption +} + +// K8SSettings - The kubernetes settings information. +type K8SSettings struct { + // OPTIONAL; Contains additional key/value pairs not defined in the schema. + AdditionalProperties map[string]any + + // The kubernetes network settings information. + Network *K8SNetworkSettings +} + +// K8StransparentDataEncryption - Transparent data encryption information. +type K8StransparentDataEncryption struct { + // Transparent data encryption mode. Can be Service Managed, Customer managed or disabled + Mode *string + + // Protector secret for customer managed Transparent data encryption mode + ProtectorSecret *string +} + // KeytabInformation - Keytab used for authenticate with Active Directory. type KeytabInformation struct { // A base64-encoded keytab. @@ -319,6 +896,33 @@ type LogAnalyticsWorkspaceConfig struct { WorkspaceID *string } +// Migration related configuration. +type Migration struct { + // Migration assessments related configuration. + Assessment *MigrationAssessment +} + +// MigrationAssessment - The migration assessment related configuration. +type MigrationAssessment struct { + // Indicates if migration assessment is enabled for this SQL Server instance. + Enabled *bool + + // READ-ONLY; The time when Migration Assessment Report upload was last performed. + AssessmentUploadTime *time.Time + + // READ-ONLY; SKU Recommendation results for Azure migration targets for SQL Server. + SKURecommendationResults *SKURecommendationResults + + // READ-ONLY; Issues and warnings impacting the migration of SQL Server instance to particular Azure Migration Target. + ServerAssessments []*ServerAssessmentsItem +} + +// Monitoring - The monitoring configuration. +type Monitoring struct { + // Indicates if monitoring is enabled for this SQL Server instance. + Enabled *bool +} + // OnPremiseProperty - Properties from the Kubernetes data controller type OnPremiseProperty struct { // REQUIRED; A globally unique ID identifying the associated Kubernetes cluster @@ -504,24 +1108,9 @@ type Resource struct { Type *string } -// SQLManagedInstance - A SqlManagedInstance. -type SQLManagedInstance struct { - // REQUIRED; The geo-location where the resource lives - Location *string - - // REQUIRED; null - Properties *SQLManagedInstanceProperties - - // The extendedLocation of the resource. - ExtendedLocation *ExtendedLocation - - // Resource sku. - SKU *SQLManagedInstanceSKU - - // Resource tags. - Tags map[string]*string - - // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} +// ResourceAutoGenerated - Common fields that are returned in the response for all Azure Resource Manager resources +type ResourceAutoGenerated struct { + // READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}" ID *string // READ-ONLY; The name of the resource @@ -534,17 +1123,259 @@ type SQLManagedInstance struct { Type *string } -// SQLManagedInstanceK8SRaw - The raw kubernetes information. -type SQLManagedInstanceK8SRaw struct { - // OPTIONAL; Contains additional key/value pairs not defined in the schema. - AdditionalProperties map[string]any +// SKURecommendationResults - SKU Recommendation results for Azure migration targets for SQL Server. +type SKURecommendationResults struct { + // SKU Recommendation results for Azure SQL Database. + AzureSQLDatabase *SKURecommendationResultsAzureSQLDatabase - // The kubernetes spec information. - Spec *SQLManagedInstanceK8SSpec + // SKU Recommendation results for Azure SQL Managed Instance. + AzureSQLManagedInstance *SKURecommendationResultsAzureSQLManagedInstance + + // SKU Recommendation results for Azure SQL Virtual Machine. + AzureSQLVirtualMachine *SKURecommendationResultsAzureSQLVirtualMachine } -// SQLManagedInstanceK8SSpec - The kubernetes spec information. -type SQLManagedInstanceK8SSpec struct { +// SKURecommendationResultsAzureSQLDatabase - SKU Recommendation results for Azure SQL Database. +type SKURecommendationResultsAzureSQLDatabase struct { + // The Monthly cost of the particular SKU. + MonthlyCost *SKURecommendationResultsMonthlyCost + + // Number of blocker issues to fix before migrating to the target platform. + NumberOfServerBlockerIssues *int32 + + // The target recommendation Status for this database. + RecommendationStatus *RecommendationStatus + TargetSKU *SKURecommendationResultsAzureSQLDatabaseTargetSKU +} + +type SKURecommendationResultsAzureSQLDatabaseTargetSKU struct { + Category *SKURecommendationResultsAzureSQLDatabaseTargetSKUCategory +} + +type SKURecommendationResultsAzureSQLDatabaseTargetSKUCategory struct { + // The compute tier of the target SKU. + ComputeTier *string + + // The hardware type of the target SKU. + HardwareType *string + + // The SQL purchasing model of the target SKU. + SQLPurchasingModel *string + + // The SQL service tier of the target SKU. + SQLServiceTier *string + + // Indicates if zone redundancy is available for the target SKU. + ZoneRedundancyAvailable *bool +} + +// SKURecommendationResultsAzureSQLManagedInstance - SKU Recommendation results for Azure SQL Managed Instance. +type SKURecommendationResultsAzureSQLManagedInstance struct { + // The Monthly cost of the particular SKU. + MonthlyCost *SKURecommendationResultsMonthlyCost + + // Number of blocker issues to fix before migrating to the target platform. + NumberOfServerBlockerIssues *int32 + + // The target recommendation Status for this database. + RecommendationStatus *RecommendationStatus + TargetSKU *SKURecommendationResultsAzureSQLManagedInstanceTargetSKU +} + +type SKURecommendationResultsAzureSQLManagedInstanceTargetSKU struct { + Category *SKURecommendationResultsAzureSQLManagedInstanceTargetSKUCategory +} + +type SKURecommendationResultsAzureSQLManagedInstanceTargetSKUCategory struct { + // The compute tier of the target SKU. + ComputeTier *string + + // The hardware type of the target SKU. + HardwareType *string + + // The SQL purchasing model of the target SKU. + SQLPurchasingModel *string + + // The SQL service tier of the target SKU. + SQLServiceTier *string + + // Indicates if zone redundancy is available for the target SKU. + ZoneRedundancyAvailable *bool +} + +// SKURecommendationResultsAzureSQLVirtualMachine - SKU Recommendation results for Azure SQL Virtual Machine. +type SKURecommendationResultsAzureSQLVirtualMachine struct { + // The Monthly cost of the particular SKU. + MonthlyCost *SKURecommendationResultsMonthlyCost + + // Number of blocker issues to fix before migrating to the target platform. + NumberOfServerBlockerIssues *int32 + + // The target recommendation Status for this database. + RecommendationStatus *RecommendationStatus + TargetSKU *SKURecommendationResultsAzureSQLVirtualMachineTargetSKU +} + +type SKURecommendationResultsAzureSQLVirtualMachineTargetSKU struct { + Category *SKURecommendationResultsAzureSQLVirtualMachineTargetSKUCategory +} + +type SKURecommendationResultsAzureSQLVirtualMachineTargetSKUCategory struct { + // Available VM SKUs for the Azure SQL Virtual Machine. + AvailableVMSKUs []*string + + // The virtual machine family of the target SKU. + VirtualMachineFamily *string +} + +// SKURecommendationResultsMonthlyCost - The Monthly cost of the particular SKU. +type SKURecommendationResultsMonthlyCost struct { + // Represents the Cost of Compute. + ComputeCost *float32 + + // Represents the Cost of Storage. + StorageCost *float32 + + // Represents the Total Cost. + TotalCost *float32 +} + +// SKURecommendationSummary - The SKU recommendation summary. +type SKURecommendationSummary struct { + // Number of blocker issues to fix before migrating this database to the target platform. + NumOfBlockerIssues *int32 + + // The target recommendation Status for this database. + RecommendationStatus *RecommendationStatus +} + +// SQLAvailabilityGroupDatabaseReplicaResourceProperties - The properties of Arc Sql availability group database replica resource +type SQLAvailabilityGroupDatabaseReplicaResourceProperties struct { + // the database name. + DatabaseName *string + + // READ-ONLY; Description of the database state of the availability replica. + DatabaseStateDescription *string + + // READ-ONLY; Whether this replica is transaction committer. + IsCommitParticipant *bool + + // READ-ONLY; Whether the availability database is local. + IsLocal *bool + + // READ-ONLY; Returns 1 if the replica is primary, or 0 if it is a secondary replica. + IsPrimaryReplica *bool + + // READ-ONLY; Whether this data movement is suspended. + IsSuspended *bool + + // READ-ONLY; the database replica name. + ReplicaName *string + + // READ-ONLY; Description of the database suspended state reason. + SuspendReasonDescription *string + + // READ-ONLY; Description of the health of database. + SynchronizationHealthDescription *string + + // READ-ONLY; Description of the data-movement state. + SynchronizationStateDescription *string +} + +// SQLAvailabilityGroupDhcpListenerProperties - The properties of a DHCP Arc Sql availability group listener +type SQLAvailabilityGroupDhcpListenerProperties struct { + // the DNS name for the listener. + DNSName *string + + // The netmask for the listener. + Mask *string + + // Network port for the listener. Default is 1433. + Port *int32 + + // The IPV4 subnet for the listener. + Subnet *string +} + +type SQLAvailabilityGroupIPV4AddressesAndMasksPropertiesItem struct { + // IPV4 address + IPAddress *string + + // IPV4 netmask + Mask *string +} + +// SQLAvailabilityGroupReplicaResourceProperties - The properties of Arc Sql availability group replica resource +type SQLAvailabilityGroupReplicaResourceProperties struct { + // null + Configure *AvailabilityGroupConfigure + + // the replica name. + ReplicaName *string + + // null + State *AvailabilityGroupState + + // READ-ONLY; ID GUID of the availability group. + ReplicaID *string +} + +// SQLAvailabilityGroupStaticIPListenerProperties - The properties of a static IP Arc Sql availability group listener +type SQLAvailabilityGroupStaticIPListenerProperties struct { + // the DNS name for the listener. + DNSName *string + + // IP V4 Addresses and masks for the listener. + IPV4AddressesAndMasks []*SQLAvailabilityGroupIPV4AddressesAndMasksPropertiesItem + + // IP V6 Addresses for the listener + IPV6Addresses []*string + + // Network port for the listener. Default is 1433. + Port *int32 +} + +// SQLManagedInstance - A SqlManagedInstance. +type SQLManagedInstance struct { + // REQUIRED; The geo-location where the resource lives + Location *string + + // REQUIRED; null + Properties *SQLManagedInstanceProperties + + // The extendedLocation of the resource. + ExtendedLocation *ExtendedLocation + + // Resource sku. + SKU *SQLManagedInstanceSKU + + // Resource tags. + Tags map[string]*string + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// SQLManagedInstanceK8SRaw - The raw kubernetes information. +type SQLManagedInstanceK8SRaw struct { + // OPTIONAL; Contains additional key/value pairs not defined in the schema. + AdditionalProperties map[string]any + + // The kubernetes spec information. + Spec *SQLManagedInstanceK8SSpec +} + +// SQLManagedInstanceK8SSpec - The kubernetes spec information. +type SQLManagedInstanceK8SSpec struct { // OPTIONAL; Contains additional key/value pairs not defined in the schema. AdditionalProperties map[string]any @@ -555,6 +1386,12 @@ type SQLManagedInstanceK8SSpec struct { // The kubernetes scheduling information. Scheduling *K8SScheduling + + // The kubernetes security information. + Security *K8SSecurity + + // The kubernetes settings information. + Settings *K8SSettings } // SQLManagedInstanceListResult - A list of SqlManagedInstance. @@ -633,6 +1470,297 @@ type SQLManagedInstanceUpdate struct { Tags map[string]*string } +// SQLServerAvailabilityGroupResource - Arc Sql Server Availability Group +type SQLServerAvailabilityGroupResource struct { + // REQUIRED; The geo-location where the resource lives + Location *string + + // REQUIRED; Properties of Arc Sql Server availability group + Properties *SQLServerAvailabilityGroupResourceProperties + + // Resource tags. + Tags map[string]*string + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// SQLServerAvailabilityGroupResourceProperties - The properties of Arc Sql Server availability group resource +type SQLServerAvailabilityGroupResourceProperties struct { + // A list of Availability Group Database Replicas. + Databases *SQLServerAvailabilityGroupResourcePropertiesDatabases + + // Availability Group Info + Info *AvailabilityGroupInfo + + // A list of Availability Group Replicas. + Replicas *SQLServerAvailabilityGroupResourcePropertiesReplicas + + // READ-ONLY; ID GUID of the availability group. + AvailabilityGroupID *string + + // READ-ONLY; Timestamp for when the data was collected from the client machine. + CollectionTimestamp *time.Time + + // READ-ONLY; the SQL Server Instance name. + InstanceName *string + + // READ-ONLY; The provisioning state of the Arc-enabled SQL Server availability group resource. + ProvisioningState *string + + // READ-ONLY; the SQL server name. + ServerName *string +} + +// SQLServerAvailabilityGroupResourcePropertiesDatabases - A list of Availability Group Database Replicas. +type SQLServerAvailabilityGroupResourcePropertiesDatabases struct { + // Array of Availability Group Database Replicas. + Value []*SQLAvailabilityGroupDatabaseReplicaResourceProperties + + // READ-ONLY; Link to retrieve next page of results. + NextLink *string +} + +// SQLServerAvailabilityGroupResourcePropertiesReplicas - A list of Availability Group Replicas. +type SQLServerAvailabilityGroupResourcePropertiesReplicas struct { + // Array of Availability Group Replicas. + Value []*SQLAvailabilityGroupReplicaResourceProperties + + // READ-ONLY; Link to retrieve next page of results. + NextLink *string +} + +// SQLServerAvailabilityGroupUpdate - An update to availability group resource. +type SQLServerAvailabilityGroupUpdate struct { + // The Server Availability Group's properties + Properties *SQLServerAvailabilityGroupResourceProperties + + // Resource tags. + Tags map[string]*string +} + +// SQLServerDatabaseResource - Arc Sql Server database +type SQLServerDatabaseResource struct { + // REQUIRED; The geo-location where the resource lives + Location *string + + // REQUIRED; Properties of Arc Sql Server database + Properties *SQLServerDatabaseResourceProperties + + // Resource tags. + Tags map[string]*string + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// SQLServerDatabaseResourceProperties - The properties of Arc Sql Server database resource +type SQLServerDatabaseResourceProperties struct { + BackupInformation *SQLServerDatabaseResourcePropertiesBackupInformation + + // The backup profile for the SQL server. + BackupPolicy *BackupPolicy + + // Collation of the database. + CollationName *string + + // Compatibility level of the database + CompatibilityLevel *int32 + + // Database create mode. PointInTimeRestore: Create a database by restoring a point in time backup of an existing database. + // sourceDatabaseId and restorePointInTime must be specified. + CreateMode *DatabaseCreateMode + + // Creation date of the database. + DatabaseCreationDate *time.Time + + // List of features that are enabled for the database + DatabaseOptions *SQLServerDatabaseResourcePropertiesDatabaseOptions + + // Whether the database is read only or not. + IsReadOnly *bool + + // Migration related configuration. + Migration *DataBaseMigration + + // Status of the database. + RecoveryMode *RecoveryMode + + // Conditional. If createMode is PointInTimeRestore, this value is required. Specifies the point in time (ISO8601 format) + // of the source database that will be restored to create the new database. + RestorePointInTime *time.Time + + // Size of the database. + SizeMB *float32 + + // The name of the source database associated with create operation of this database. + SourceDatabaseID *string + + // Space left of the database. + SpaceAvailableMB *float32 + + // State of the database. + State *DatabaseState + + // READ-ONLY; This records the earliest start date and time that restore is available for this database (ISO8601 format). + EarliestRestoreDate *time.Time + + // READ-ONLY; The time when last successful database upload was performed. + LastDatabaseUploadTime *time.Time + + // READ-ONLY; The provisioning state of the Arc-enabled SQL Server database resource. + ProvisioningState *string +} + +type SQLServerDatabaseResourcePropertiesBackupInformation struct { + // Date time of last full backup. + LastFullBackup *time.Time + + // Date time of last log backup. + LastLogBackup *time.Time +} + +// SQLServerDatabaseResourcePropertiesDatabaseOptions - List of features that are enabled for the database +type SQLServerDatabaseResourcePropertiesDatabaseOptions struct { + IsAutoCloseOn *bool + IsAutoCreateStatsOn *bool + IsAutoShrinkOn *bool + IsAutoUpdateStatsOn *bool + IsEncrypted *bool + IsMemoryOptimizationEnabled *bool + IsRemoteDataArchiveEnabled *bool + IsTrustworthyOn *bool +} + +// SQLServerDatabaseUpdate - An update to database resource. +type SQLServerDatabaseUpdate struct { + // The data controller's properties + Properties *SQLServerDatabaseResourceProperties + + // Resource tags. + Tags map[string]*string +} + +// SQLServerEsuLicense - Describe SQL Server ESU license resource. +type SQLServerEsuLicense struct { + // REQUIRED; The geo-location where the resource lives + Location *string + + // REQUIRED; SQL Server ESU license properties + Properties *SQLServerEsuLicenseProperties + + // Resource tags. + Tags map[string]*string + + // READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}" + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// SQLServerEsuLicenseListResult - A list of SQL Server ESU licenses. +type SQLServerEsuLicenseListResult struct { + // READ-ONLY; Link to retrieve next page of results. + NextLink *string + + // READ-ONLY; Array of results. + Value []*SQLServerEsuLicense +} + +// SQLServerEsuLicenseProperties - Properties of SQL Server ESU license. +type SQLServerEsuLicenseProperties struct { + // REQUIRED; The activation state of the license. + ActivationState *State + + // REQUIRED; SQL Server ESU license type. + BillingPlan *BillingPlan + + // REQUIRED; The number of total cores of the license covers. + PhysicalCores *int32 + + // REQUIRED; The Azure scope to which the license will apply. + ScopeType *ScopeType + + // REQUIRED; The SQL Server version the license covers. + Version *Version + + // READ-ONLY; The timestamp of the activation of the SqlServerEsuLicense in ISO 8601 date-time format. + ActivatedAt *time.Time + + // READ-ONLY; The tenantId the SQL Server ESU license resource subscription resides in. + TenantID *string + + // READ-ONLY; The timestamp of the termination of the SqlServerEsuLicense in ISO 8601 date-time format. + TerminatedAt *time.Time + + // READ-ONLY; The unique ID of this license. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000). + UniqueID *string +} + +// SQLServerEsuLicenseUpdate - An update to a SQL Server ESU license resource. +type SQLServerEsuLicenseUpdate struct { + // null + Properties *SQLServerEsuLicenseUpdateProperties + + // Resource tags. + Tags map[string]*string +} + +// SQLServerEsuLicenseUpdateProperties - Properties of update SqlServerEsuLicense. +type SQLServerEsuLicenseUpdateProperties struct { + // The activation state of the license. + ActivationState *State + + // SQL Server ESU license type. + BillingPlan *BillingPlan + + // The number of total cores of the license covers. + PhysicalCores *int32 + + // The Azure scope to which the license will apply. + ScopeType *ScopeType + + // The SQL Server version the license covers. + Version *Version + + // READ-ONLY; The timestamp of the activation of the SqlServerEsuLicense in ISO 8601 date-time format. + ActivatedAt *time.Time + + // READ-ONLY; The tenantId the SQL Server ESU license resource subscription resides in. + TenantID *string + + // READ-ONLY; The timestamp of the termination of the SqlServerEsuLicense in ISO 8601 date-time format. + TerminatedAt *time.Time + + // READ-ONLY; The unique ID of this license. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000). + UniqueID *string +} + // SQLServerInstance - A SqlServerInstance. type SQLServerInstance struct { // REQUIRED; The geo-location where the resource lives @@ -657,6 +1785,42 @@ type SQLServerInstance struct { Type *string } +// SQLServerInstanceJobStatus - The status of the job running on the SQL Server instance. +type SQLServerInstanceJobStatus struct { + // The background job details. + BackgroundJob *BackgroundJob + + // The unique identifier of the job. + ID *string + + // The name of the SQL Server instance. + InstanceName *string + + // The exception message if the job failed. + JobException *string + + // The status of the job. + JobStatus *JobStatus + + // The list of sequencer actions. + SequencerActions []*SequencerAction +} + +// SQLServerInstanceJobsStatusRequest - The request for the status of the jobs running on the SQL Server instance. +type SQLServerInstanceJobsStatusRequest struct { + // The name of the feature to retrieve the job status for. + FeatureName *string + + // The type of the job to retrieve the status for. + JobType *string +} + +// SQLServerInstanceJobsStatusResponse - The response for the status of the jobs running on the SQL Server instance. +type SQLServerInstanceJobsStatusResponse struct { + // The list of jobs status running on the SQL Server instance. + JobsStatus []*SQLServerInstanceJobStatus +} + // SQLServerInstanceListResult - A list of SqlServerInstance. type SQLServerInstanceListResult struct { // READ-ONLY; Link to retrieve next page of results. @@ -668,67 +1832,403 @@ type SQLServerInstanceListResult struct { // SQLServerInstanceProperties - Properties of SqlServerInstance. type SQLServerInstanceProperties struct { - // REQUIRED; ARM Resource id of the container resource (Azure Arc for Servers). - ContainerResourceID *string + // The backup profile for the SQL server. + BackupPolicy *BackupPolicy - // REQUIRED; The cloud connectivity status. - Status *ConnectionStatus - - // Status of Azure Defender. - AzureDefenderStatus *DefenderStatus + // Client connection related configuration. + ClientConnection *ClientConnection - // Timestamp of last Azure Defender status update. - AzureDefenderStatusLastUpdated *time.Time + // The number of total cores of the Operating System Environment (OSE) hosting the SQL Server instance. + Cores *string - // SQL Server collation. - Collation *string - - // SQL Server current version. - CurrentVersion *string + // Database mirroring endpoint related properties. + DatabaseMirroringEndpoint *DBMEndpoint // SQL Server edition. Edition *EditionType + // Failover Cluster Instance properties. + FailoverCluster *FailoverCluster + // Type of host for Azure Arc SQL Server HostType *HostType // SQL Server instance name. InstanceName *string - // SQL Server license type. + // Migration related configuration. + Migration *Migration + + // The monitoring configuration. + Monitoring *Monitoring + + // Indicates if the resource represents a SQL Server engine or a SQL Server component service installed on the host. + ServiceType *ServiceType + + // Upgrade Action for this resource is locked until it expires. The Expiration time indicated by this value. It is not locked + // when it is empty. + UpgradeLockedUntil *time.Time + + // SQL Server version. + Version *SQLVersion + + // READ-ONLY; The role of the SQL Server, based on availability. + AlwaysOnRole *AlwaysOnRole + + // READ-ONLY; Status of Azure Defender. + AzureDefenderStatus *DefenderStatus + + // READ-ONLY; Timestamp of last Azure Defender status update. + AzureDefenderStatusLastUpdated *time.Time + + // READ-ONLY; SQL Server collation. + Collation *string + + // READ-ONLY; ARM Resource id of the container resource (Azure Arc for Servers). + ContainerResourceID *string + + // READ-ONLY; The time when the resource was created. + CreateTime *string + + // READ-ONLY; SQL Server current version. + CurrentVersion *string + + // READ-ONLY; Indicates whether database master key exists in SQL Server. + DbMasterKeyExists *bool + + // READ-ONLY; Indicates whether always On availability groups is enabled in SQL Server. + IsHadrEnabled *bool + + // READ-ONLY; The time when last successful inventory upload was performed. + LastInventoryUploadTime *time.Time + + // READ-ONLY; The time when last successful usage upload was performed. + LastUsageUploadTime *time.Time + + // READ-ONLY; SQL Server license type. LicenseType *ArcSQLServerLicenseType - // SQL Server update level. + // READ-ONLY; SQL Server update level. PatchLevel *string - // SQL Server product ID. + // READ-ONLY; SQL Server product ID. ProductID *string - // Dynamic TCP ports used by SQL Server. + // READ-ONLY; The provisioning state of the Arc-enabled SQL Server resource. + ProvisioningState *string + + // READ-ONLY; The cloud connectivity status. + Status *ConnectionStatus + + // READ-ONLY; Dynamic TCP ports used by SQL Server. TCPDynamicPorts *string - // Static TCP ports used by SQL Server. + // READ-ONLY; Static TCP ports used by SQL Server. TCPStaticPorts *string - // The number of logical processors used by the SQL Server instance. + // READ-ONLY; An array of integers, where each value represents the enabled trace flags in SQL Server. + TraceFlags []*int32 + + // READ-ONLY; The number of logical processors used by the SQL Server instance. VCore *string +} + +// SQLServerInstanceRunMigrationAssessmentResponse - The response for running migration assessment on the SQL Server instance. +type SQLServerInstanceRunMigrationAssessmentResponse struct { + // The background job details. + BackgroundJob *BackgroundJob + + // The unique identifier of the job. + ID *string + + // The name of the SQL Server instance. + InstanceName *string + + // The exception message if the job failed. + JobException *string + + // The status of the job. + JobStatus *JobStatus + + // The list of sequencer actions. + SequencerActions []*SequencerAction +} + +// SQLServerInstanceTelemetryColumn - The telemetry column for the SQL Server instance. +type SQLServerInstanceTelemetryColumn struct { + // The name of the telemetry column. + Name *string + + // The type of the telemetry column. + Type *SQLServerInstanceTelemetryColumnType +} + +// SQLServerInstanceTelemetryRequest - The Arc SQL Server instance telemetry retrieval request. +type SQLServerInstanceTelemetryRequest struct { + // REQUIRED; The name of the telemetry dataset to retrieve. + DatasetName *string + + // The aggregation type to use for the numerical columns in the dataset. + AggregationType *AggregationType + + // The list of database names to return telemetry for. If not specified, telemetry for all databases will be aggregated and + // returned. + DatabaseNames []*string + + // The end time for the time range to fetch telemetry for. If not specified, the current time is used. + EndTime *time.Time + + // The time granularity to fetch telemetry for. This is an ISO8601 duration. Examples: PT15M, PT1H, P1D + Interval *string + + // The start time for the time range to fetch telemetry for. If not specified, the current time minus 1 hour is used. + StartTime *time.Time +} + +// SQLServerInstanceTelemetryResponse - A section of the telemetry response for the SQL Server instance. +type SQLServerInstanceTelemetryResponse struct { + // REQUIRED; The columns of the result telemetry table for the SQL Server instance. + Columns []*SQLServerInstanceTelemetryColumn + + // REQUIRED; A list of rows from the result telemetry table for the SQL Server instance. + Rows [][]*string + + // READ-ONLY; The link to the next section of rows of the telemetry response for the SQL Server instance. Null if no more + // sections are available. + NextLink *string +} + +// SQLServerInstanceUpdate - An update to a SQL Server Instance. +type SQLServerInstanceUpdate struct { + // null + Properties *SQLServerInstanceUpdateProperties + + // Resource tags. + Tags map[string]*string +} + +// SQLServerInstanceUpdateProperties - Properties of update SqlServerInstance. +type SQLServerInstanceUpdateProperties struct { + // The backup profile for the SQL server. + BackupPolicy *BackupPolicy + + // Client connection related configuration. + ClientConnection *ClientConnection + + // The number of total cores of the Operating System Environment (OSE) hosting the SQL Server instance. + Cores *string + + // SQL Server edition. + Edition *EditionType + + // Failover Cluster Instance properties. + FailoverCluster *FailoverCluster + + // Type of host for Azure Arc SQL Server + HostType *HostType + + // SQL Server instance name. + InstanceName *string + + // Migration related configuration. + Migration *Migration + + // The monitoring configuration. + Monitoring *Monitoring + + // Indicates if the resource represents a SQL Server engine or a SQL Server component service installed on the host. + ServiceType *ServiceType + + // Upgrade Action for this resource is locked until it expires. The Expiration time indicated by this value. It is not locked + // when it is empty. + UpgradeLockedUntil *time.Time // SQL Server version. Version *SQLVersion + // READ-ONLY; The role of the SQL Server, based on availability. + AlwaysOnRole *AlwaysOnRole + + // READ-ONLY; Status of Azure Defender. + AzureDefenderStatus *DefenderStatus + + // READ-ONLY; Timestamp of last Azure Defender status update. + AzureDefenderStatusLastUpdated *time.Time + + // READ-ONLY; SQL Server collation. + Collation *string + + // READ-ONLY; ARM Resource id of the container resource (Azure Arc for Servers). + ContainerResourceID *string + // READ-ONLY; The time when the resource was created. CreateTime *string + // READ-ONLY; SQL Server current version. + CurrentVersion *string + + // READ-ONLY; Indicates whether database master key exists in SQL Server. + DbMasterKeyExists *bool + + // READ-ONLY; Indicates whether always On availability groups is enabled in SQL Server. + IsHadrEnabled *bool + + // READ-ONLY; The time when last successful inventory upload was performed. + LastInventoryUploadTime *time.Time + + // READ-ONLY; The time when last successful usage upload was performed. + LastUsageUploadTime *time.Time + + // READ-ONLY; SQL Server license type. + LicenseType *ArcSQLServerLicenseType + + // READ-ONLY; SQL Server update level. + PatchLevel *string + + // READ-ONLY; SQL Server product ID. + ProductID *string + // READ-ONLY; The provisioning state of the Arc-enabled SQL Server resource. ProvisioningState *string + + // READ-ONLY; The cloud connectivity status. + Status *ConnectionStatus + + // READ-ONLY; Dynamic TCP ports used by SQL Server. + TCPDynamicPorts *string + + // READ-ONLY; Static TCP ports used by SQL Server. + TCPStaticPorts *string + + // READ-ONLY; An array of integers, where each value represents the enabled trace flags in SQL Server. + TraceFlags []*int32 + + // READ-ONLY; The number of logical processors used by the SQL Server instance. + VCore *string } -// SQLServerInstanceUpdate - An update to a SQL Server Instance. -type SQLServerInstanceUpdate struct { +// SQLServerLicense - Describe SQL Server license resource. +type SQLServerLicense struct { + // REQUIRED; The geo-location where the resource lives + Location *string + + // REQUIRED; SQL Server license properties + Properties *SQLServerLicenseProperties + + // Resource tags. + Tags map[string]*string + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// SQLServerLicenseListResult - A list of SQL Server licenses. +type SQLServerLicenseListResult struct { + // READ-ONLY; Link to retrieve next page of results. + NextLink *string + + // READ-ONLY; Array of results. + Value []*SQLServerLicense +} + +// SQLServerLicenseProperties - Properties of SQL Server License. +type SQLServerLicenseProperties struct { + // REQUIRED; The activation state of the license. + ActivationState *ActivationState + + // REQUIRED; SQL Server license type. + BillingPlan *BillingPlan + + // REQUIRED; This property represents the choice between SQL Server Core and ESU licenses. + LicenseCategory *LicenseCategory + + // REQUIRED; The number of total cores of the license covers. + PhysicalCores *int32 + + // REQUIRED; The Azure scope to which the license will apply. + ScopeType *ScopeType + + // READ-ONLY; The timestamp of the most recent activation of the SqlServerLicense. + LastActivatedAt *time.Time + + // READ-ONLY; The timestamp of the most recent deactivation of the SqlServerLicense. + LastDeactivatedAt *time.Time + + // READ-ONLY; The tenantId the SQL Server license resource subscription resides in. + TenantID *string +} + +// SQLServerLicenseUpdate - An update to a SQL Server license resource. +type SQLServerLicenseUpdate struct { + // null + Properties *SQLServerLicenseUpdateProperties + // Resource tags. Tags map[string]*string } +// SQLServerLicenseUpdateProperties - Properties of update SqlServerLicense. +type SQLServerLicenseUpdateProperties struct { + // The activation state of the license. + ActivationState *ActivationState + + // SQL Server license type. + BillingPlan *BillingPlan + + // This property represents the choice between SQL Server Core and ESU licenses. + LicenseCategory *LicenseCategory + + // The number of total cores of the license covers. + PhysicalCores *int32 + + // The Azure scope to which the license will apply. + ScopeType *ScopeType + + // READ-ONLY; The timestamp of the most recent activation of the SqlServerLicense. + LastActivatedAt *time.Time + + // READ-ONLY; The timestamp of the most recent deactivation of the SqlServerLicense. + LastDeactivatedAt *time.Time + + // READ-ONLY; The tenantId the SQL Server license resource subscription resides in. + TenantID *string +} + +// SequencerAction - The sequencer action details. +type SequencerAction struct { + // The unique identifier of the sequencer action. + ActionID *string + + // The result of the sequencer action. + Result *Result + + // The state of the sequencer action. + State *SequencerState +} + +type ServerAssessmentsItem struct { + AppliesToMigrationTargetPlatform *string + FeatureID *string + ImpactedObjects []*ServerAssessmentsPropertiesItemsItem + IssueCategory *string + MoreInformation *string +} + +type ServerAssessmentsPropertiesItemsItem struct { + ImpactDetail *string + Name *string + ObjectType *string +} + // SystemData - Metadata pertaining to creation and last modification of the resource. type SystemData struct { // The timestamp of resource creation (UTC). @@ -750,6 +2250,18 @@ type SystemData struct { LastModifiedByType *CreatedByType } +// TargetReadiness - The target readiness for migration for this database. +type TargetReadiness struct { + // The SKU recommendation summary. + AzureSQLDatabase *SKURecommendationSummary + + // The SKU recommendation summary. + AzureSQLManagedInstance *SKURecommendationSummary + + // The SKU recommendation summary. + AzureSQLVirtualMachine *SKURecommendationSummary +} + // TrackedResource - The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' // and a 'location' type TrackedResource struct { @@ -772,6 +2284,28 @@ type TrackedResource struct { Type *string } +// TrackedResourceAutoGenerated - The resource model definition for an Azure Resource Manager tracked top level resource which +// has 'tags' and a 'location' +type TrackedResourceAutoGenerated struct { + // REQUIRED; The geo-location where the resource lives + Location *string + + // Resource tags. + Tags map[string]*string + + // READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}" + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + // UploadServicePrincipal - Service principal for uploading billing, metrics and logs. type UploadServicePrincipal struct { // Authority for the service principal. Example: https://login.microsoftonline.com/ diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/models_serde.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/models_serde.go index 25269a4a9aed..caad6de2ac77 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/models_serde.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/models_serde.go @@ -376,1238 +376,4908 @@ func (a *ActiveDirectoryInformation) UnmarshalJSON(data []byte) error { return nil } -// MarshalJSON implements the json.Marshaller interface for type BasicLoginInformation. -func (b BasicLoginInformation) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type ArcSQLServerAvailabilityGroupListResult. +func (a ArcSQLServerAvailabilityGroupListResult) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "password", b.Password) - populate(objectMap, "username", b.Username) + populate(objectMap, "nextLink", a.NextLink) + populate(objectMap, "value", a.Value) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type BasicLoginInformation. -func (b *BasicLoginInformation) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type ArcSQLServerAvailabilityGroupListResult. +func (a *ArcSQLServerAvailabilityGroupListResult) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", b, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } for key, val := range rawMsg { var err error switch key { - case "password": - err = unpopulate(val, "Password", &b.Password) + case "nextLink": + err = unpopulate(val, "NextLink", &a.NextLink) delete(rawMsg, key) - case "username": - err = unpopulate(val, "Username", &b.Username) + case "value": + err = unpopulate(val, "Value", &a.Value) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", b, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type CommonSKU. -func (c CommonSKU) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type ArcSQLServerDatabaseListResult. +func (a ArcSQLServerDatabaseListResult) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "capacity", c.Capacity) - populate(objectMap, "dev", c.Dev) - populate(objectMap, "family", c.Family) - populate(objectMap, "name", c.Name) - populate(objectMap, "size", c.Size) + populate(objectMap, "nextLink", a.NextLink) + populate(objectMap, "value", a.Value) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type CommonSKU. -func (c *CommonSKU) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type ArcSQLServerDatabaseListResult. +func (a *ArcSQLServerDatabaseListResult) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", c, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } for key, val := range rawMsg { var err error switch key { - case "capacity": - err = unpopulate(val, "Capacity", &c.Capacity) - delete(rawMsg, key) - case "dev": - err = unpopulate(val, "Dev", &c.Dev) - delete(rawMsg, key) - case "family": - err = unpopulate(val, "Family", &c.Family) - delete(rawMsg, key) - case "name": - err = unpopulate(val, "Name", &c.Name) + case "nextLink": + err = unpopulate(val, "NextLink", &a.NextLink) delete(rawMsg, key) - case "size": - err = unpopulate(val, "Size", &c.Size) + case "value": + err = unpopulate(val, "Value", &a.Value) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", c, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type DataControllerProperties. -func (d DataControllerProperties) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type AvailabilityGroupConfigure. +func (a AvailabilityGroupConfigure) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "basicLoginInformation", d.BasicLoginInformation) - populate(objectMap, "clusterId", d.ClusterID) - populate(objectMap, "extensionId", d.ExtensionID) - populate(objectMap, "infrastructure", d.Infrastructure) - populateAny(objectMap, "k8sRaw", d.K8SRaw) - populateDateTimeRFC3339(objectMap, "lastUploadedDate", d.LastUploadedDate) - populate(objectMap, "logAnalyticsWorkspaceConfig", d.LogAnalyticsWorkspaceConfig) - populate(objectMap, "logsDashboardCredential", d.LogsDashboardCredential) - populate(objectMap, "metricsDashboardCredential", d.MetricsDashboardCredential) - populate(objectMap, "onPremiseProperty", d.OnPremiseProperty) - populate(objectMap, "provisioningState", d.ProvisioningState) - populate(objectMap, "uploadServicePrincipal", d.UploadServicePrincipal) - populate(objectMap, "uploadWatermark", d.UploadWatermark) + populate(objectMap, "availabilityMode", a.AvailabilityMode) + populate(objectMap, "availabilityModeDescription", a.AvailabilityModeDescription) + populate(objectMap, "backupPriority", a.BackupPriority) + populate(objectMap, "certificateName", a.CertificateName) + populate(objectMap, "endpointAuthenticationMode", a.EndpointAuthenticationMode) + populate(objectMap, "endpointConnectLogin", a.EndpointConnectLogin) + populate(objectMap, "endpointName", a.EndpointName) + populate(objectMap, "endpointUrl", a.EndpointURL) + populate(objectMap, "failoverMode", a.FailoverMode) + populate(objectMap, "failoverModeDescription", a.FailoverModeDescription) + populate(objectMap, "primaryAllowConnections", a.PrimaryAllowConnections) + populate(objectMap, "primaryRoleAllowConnectionsDescription", a.PrimaryRoleAllowConnectionsDescription) + populate(objectMap, "readOnlyRoutingUrl", a.ReadOnlyRoutingURL) + populate(objectMap, "readWriteRoutingUrl", a.ReadWriteRoutingURL) + populateDateTimeRFC3339(objectMap, "replicaCreateDate", a.ReplicaCreateDate) + populateDateTimeRFC3339(objectMap, "replicaModifyDate", a.ReplicaModifyDate) + populate(objectMap, "secondaryAllowConnections", a.SecondaryAllowConnections) + populate(objectMap, "secondaryRoleAllowConnectionsDescription", a.SecondaryRoleAllowConnectionsDescription) + populate(objectMap, "seedingMode", a.SeedingMode) + populate(objectMap, "seedingModeDescription", a.SeedingModeDescription) + populate(objectMap, "sessionTimeout", a.SessionTimeout) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type DataControllerProperties. -func (d *DataControllerProperties) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailabilityGroupConfigure. +func (a *AvailabilityGroupConfigure) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", d, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } for key, val := range rawMsg { var err error switch key { - case "basicLoginInformation": - err = unpopulate(val, "BasicLoginInformation", &d.BasicLoginInformation) + case "availabilityMode": + err = unpopulate(val, "AvailabilityMode", &a.AvailabilityMode) delete(rawMsg, key) - case "clusterId": - err = unpopulate(val, "ClusterID", &d.ClusterID) + case "availabilityModeDescription": + err = unpopulate(val, "AvailabilityModeDescription", &a.AvailabilityModeDescription) delete(rawMsg, key) - case "extensionId": - err = unpopulate(val, "ExtensionID", &d.ExtensionID) + case "backupPriority": + err = unpopulate(val, "BackupPriority", &a.BackupPriority) delete(rawMsg, key) - case "infrastructure": - err = unpopulate(val, "Infrastructure", &d.Infrastructure) + case "certificateName": + err = unpopulate(val, "CertificateName", &a.CertificateName) delete(rawMsg, key) - case "k8sRaw": - err = unpopulate(val, "K8SRaw", &d.K8SRaw) + case "endpointAuthenticationMode": + err = unpopulate(val, "EndpointAuthenticationMode", &a.EndpointAuthenticationMode) delete(rawMsg, key) - case "lastUploadedDate": - err = unpopulateDateTimeRFC3339(val, "LastUploadedDate", &d.LastUploadedDate) + case "endpointConnectLogin": + err = unpopulate(val, "EndpointConnectLogin", &a.EndpointConnectLogin) delete(rawMsg, key) - case "logAnalyticsWorkspaceConfig": - err = unpopulate(val, "LogAnalyticsWorkspaceConfig", &d.LogAnalyticsWorkspaceConfig) + case "endpointName": + err = unpopulate(val, "EndpointName", &a.EndpointName) delete(rawMsg, key) - case "logsDashboardCredential": - err = unpopulate(val, "LogsDashboardCredential", &d.LogsDashboardCredential) + case "endpointUrl": + err = unpopulate(val, "EndpointURL", &a.EndpointURL) delete(rawMsg, key) - case "metricsDashboardCredential": - err = unpopulate(val, "MetricsDashboardCredential", &d.MetricsDashboardCredential) + case "failoverMode": + err = unpopulate(val, "FailoverMode", &a.FailoverMode) delete(rawMsg, key) - case "onPremiseProperty": - err = unpopulate(val, "OnPremiseProperty", &d.OnPremiseProperty) + case "failoverModeDescription": + err = unpopulate(val, "FailoverModeDescription", &a.FailoverModeDescription) delete(rawMsg, key) - case "provisioningState": - err = unpopulate(val, "ProvisioningState", &d.ProvisioningState) + case "primaryAllowConnections": + err = unpopulate(val, "PrimaryAllowConnections", &a.PrimaryAllowConnections) delete(rawMsg, key) - case "uploadServicePrincipal": - err = unpopulate(val, "UploadServicePrincipal", &d.UploadServicePrincipal) + case "primaryRoleAllowConnectionsDescription": + err = unpopulate(val, "PrimaryRoleAllowConnectionsDescription", &a.PrimaryRoleAllowConnectionsDescription) delete(rawMsg, key) - case "uploadWatermark": - err = unpopulate(val, "UploadWatermark", &d.UploadWatermark) + case "readOnlyRoutingUrl": + err = unpopulate(val, "ReadOnlyRoutingURL", &a.ReadOnlyRoutingURL) + delete(rawMsg, key) + case "readWriteRoutingUrl": + err = unpopulate(val, "ReadWriteRoutingURL", &a.ReadWriteRoutingURL) + delete(rawMsg, key) + case "replicaCreateDate": + err = unpopulateDateTimeRFC3339(val, "ReplicaCreateDate", &a.ReplicaCreateDate) + delete(rawMsg, key) + case "replicaModifyDate": + err = unpopulateDateTimeRFC3339(val, "ReplicaModifyDate", &a.ReplicaModifyDate) + delete(rawMsg, key) + case "secondaryAllowConnections": + err = unpopulate(val, "SecondaryAllowConnections", &a.SecondaryAllowConnections) + delete(rawMsg, key) + case "secondaryRoleAllowConnectionsDescription": + err = unpopulate(val, "SecondaryRoleAllowConnectionsDescription", &a.SecondaryRoleAllowConnectionsDescription) + delete(rawMsg, key) + case "seedingMode": + err = unpopulate(val, "SeedingMode", &a.SeedingMode) + delete(rawMsg, key) + case "seedingModeDescription": + err = unpopulate(val, "SeedingModeDescription", &a.SeedingModeDescription) + delete(rawMsg, key) + case "sessionTimeout": + err = unpopulate(val, "SessionTimeout", &a.SessionTimeout) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", d, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type DataControllerResource. -func (d DataControllerResource) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type AvailabilityGroupCreateUpdateConfiguration. +func (a AvailabilityGroupCreateUpdateConfiguration) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "extendedLocation", d.ExtendedLocation) - populate(objectMap, "id", d.ID) - populate(objectMap, "location", d.Location) - populate(objectMap, "name", d.Name) - populate(objectMap, "properties", d.Properties) - populate(objectMap, "systemData", d.SystemData) - populate(objectMap, "tags", d.Tags) - populate(objectMap, "type", d.Type) + populate(objectMap, "automatedBackupPreference", a.AutomatedBackupPreference) + populate(objectMap, "availabilityGroupName", a.AvailabilityGroupName) + populate(objectMap, "clusterType", a.ClusterType) + populate(objectMap, "databases", a.Databases) + populate(objectMap, "dbFailover", a.DbFailover) + populate(objectMap, "dtcSupport", a.DtcSupport) + populate(objectMap, "failureConditionLevel", a.FailureConditionLevel) + populate(objectMap, "healthCheckTimeout", a.HealthCheckTimeout) + populate(objectMap, "listener", a.Listener) + populate(objectMap, "replicas", a.Replicas) + populate(objectMap, "requiredSynchronizedSecondariesToCommit", a.RequiredSynchronizedSecondariesToCommit) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type DataControllerResource. -func (d *DataControllerResource) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailabilityGroupCreateUpdateConfiguration. +func (a *AvailabilityGroupCreateUpdateConfiguration) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", d, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } for key, val := range rawMsg { var err error switch key { - case "extendedLocation": - err = unpopulate(val, "ExtendedLocation", &d.ExtendedLocation) + case "automatedBackupPreference": + err = unpopulate(val, "AutomatedBackupPreference", &a.AutomatedBackupPreference) delete(rawMsg, key) - case "id": - err = unpopulate(val, "ID", &d.ID) + case "availabilityGroupName": + err = unpopulate(val, "AvailabilityGroupName", &a.AvailabilityGroupName) delete(rawMsg, key) - case "location": - err = unpopulate(val, "Location", &d.Location) + case "clusterType": + err = unpopulate(val, "ClusterType", &a.ClusterType) delete(rawMsg, key) - case "name": - err = unpopulate(val, "Name", &d.Name) + case "databases": + err = unpopulate(val, "Databases", &a.Databases) delete(rawMsg, key) - case "properties": - err = unpopulate(val, "Properties", &d.Properties) + case "dbFailover": + err = unpopulate(val, "DbFailover", &a.DbFailover) delete(rawMsg, key) - case "systemData": - err = unpopulate(val, "SystemData", &d.SystemData) + case "dtcSupport": + err = unpopulate(val, "DtcSupport", &a.DtcSupport) delete(rawMsg, key) - case "tags": - err = unpopulate(val, "Tags", &d.Tags) + case "failureConditionLevel": + err = unpopulate(val, "FailureConditionLevel", &a.FailureConditionLevel) delete(rawMsg, key) - case "type": - err = unpopulate(val, "Type", &d.Type) + case "healthCheckTimeout": + err = unpopulate(val, "HealthCheckTimeout", &a.HealthCheckTimeout) + delete(rawMsg, key) + case "listener": + err = unpopulate(val, "Listener", &a.Listener) + delete(rawMsg, key) + case "replicas": + err = unpopulate(val, "Replicas", &a.Replicas) + delete(rawMsg, key) + case "requiredSynchronizedSecondariesToCommit": + err = unpopulate(val, "RequiredSynchronizedSecondariesToCommit", &a.RequiredSynchronizedSecondariesToCommit) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", d, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type DataControllerUpdate. -func (d DataControllerUpdate) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type AvailabilityGroupCreateUpdateReplicaConfiguration. +func (a AvailabilityGroupCreateUpdateReplicaConfiguration) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "properties", d.Properties) - populate(objectMap, "tags", d.Tags) + populate(objectMap, "availabilityMode", a.AvailabilityMode) + populate(objectMap, "backupPriority", a.BackupPriority) + populate(objectMap, "certificateName", a.CertificateName) + populate(objectMap, "endpointAuthenticationMode", a.EndpointAuthenticationMode) + populate(objectMap, "endpointConnectLogin", a.EndpointConnectLogin) + populate(objectMap, "endpointName", a.EndpointName) + populate(objectMap, "endpointUrl", a.EndpointURL) + populate(objectMap, "failoverMode", a.FailoverMode) + populate(objectMap, "primaryRoleAllowConnections", a.PrimaryRoleAllowConnections) + populate(objectMap, "primaryRoleReadOnlyRoutingList", a.PrimaryRoleReadOnlyRoutingList) + populate(objectMap, "secondaryRoleAllowConnections", a.SecondaryRoleAllowConnections) + populate(objectMap, "secondaryRoleReadOnlyRoutingUrl", a.SecondaryRoleReadOnlyRoutingURL) + populate(objectMap, "seedingMode", a.SeedingMode) + populate(objectMap, "serverInstance", a.ServerInstance) + populate(objectMap, "sessionTimeout", a.SessionTimeout) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type DataControllerUpdate. -func (d *DataControllerUpdate) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailabilityGroupCreateUpdateReplicaConfiguration. +func (a *AvailabilityGroupCreateUpdateReplicaConfiguration) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", d, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } for key, val := range rawMsg { var err error switch key { - case "properties": - err = unpopulate(val, "Properties", &d.Properties) + case "availabilityMode": + err = unpopulate(val, "AvailabilityMode", &a.AvailabilityMode) delete(rawMsg, key) - case "tags": - err = unpopulate(val, "Tags", &d.Tags) + case "backupPriority": + err = unpopulate(val, "BackupPriority", &a.BackupPriority) + delete(rawMsg, key) + case "certificateName": + err = unpopulate(val, "CertificateName", &a.CertificateName) + delete(rawMsg, key) + case "endpointAuthenticationMode": + err = unpopulate(val, "EndpointAuthenticationMode", &a.EndpointAuthenticationMode) + delete(rawMsg, key) + case "endpointConnectLogin": + err = unpopulate(val, "EndpointConnectLogin", &a.EndpointConnectLogin) + delete(rawMsg, key) + case "endpointName": + err = unpopulate(val, "EndpointName", &a.EndpointName) + delete(rawMsg, key) + case "endpointUrl": + err = unpopulate(val, "EndpointURL", &a.EndpointURL) + delete(rawMsg, key) + case "failoverMode": + err = unpopulate(val, "FailoverMode", &a.FailoverMode) + delete(rawMsg, key) + case "primaryRoleAllowConnections": + err = unpopulate(val, "PrimaryRoleAllowConnections", &a.PrimaryRoleAllowConnections) + delete(rawMsg, key) + case "primaryRoleReadOnlyRoutingList": + err = unpopulate(val, "PrimaryRoleReadOnlyRoutingList", &a.PrimaryRoleReadOnlyRoutingList) + delete(rawMsg, key) + case "secondaryRoleAllowConnections": + err = unpopulate(val, "SecondaryRoleAllowConnections", &a.SecondaryRoleAllowConnections) + delete(rawMsg, key) + case "secondaryRoleReadOnlyRoutingUrl": + err = unpopulate(val, "SecondaryRoleReadOnlyRoutingURL", &a.SecondaryRoleReadOnlyRoutingURL) + delete(rawMsg, key) + case "seedingMode": + err = unpopulate(val, "SeedingMode", &a.SeedingMode) + delete(rawMsg, key) + case "serverInstance": + err = unpopulate(val, "ServerInstance", &a.ServerInstance) + delete(rawMsg, key) + case "sessionTimeout": + err = unpopulate(val, "SessionTimeout", &a.SessionTimeout) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", d, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type ErrorResponse. -func (e ErrorResponse) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type AvailabilityGroupInfo. +func (a AvailabilityGroupInfo) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "error", e.Error) + populate(objectMap, "automatedBackupPreferenceDescription", a.AutomatedBackupPreferenceDescription) + populate(objectMap, "basicFeatures", a.BasicFeatures) + populate(objectMap, "clusterTypeDescription", a.ClusterTypeDescription) + populate(objectMap, "dbFailover", a.DbFailover) + populate(objectMap, "dtcSupport", a.DtcSupport) + populate(objectMap, "failureConditionLevel", a.FailureConditionLevel) + populate(objectMap, "healthCheckTimeout", a.HealthCheckTimeout) + populate(objectMap, "isContained", a.IsContained) + populate(objectMap, "isDistributed", a.IsDistributed) + populate(objectMap, "listener", a.Listener) + populate(objectMap, "primaryRecoveryHealthDescription", a.PrimaryRecoveryHealthDescription) + populate(objectMap, "primaryReplica", a.PrimaryReplica) + populate(objectMap, "replicationPartnerType", a.ReplicationPartnerType) + populate(objectMap, "requiredSynchronizedSecondariesToCommit", a.RequiredSynchronizedSecondariesToCommit) + populate(objectMap, "secondaryRecoveryHealthDescription", a.SecondaryRecoveryHealthDescription) + populate(objectMap, "synchronizationHealthDescription", a.SynchronizationHealthDescription) + populate(objectMap, "version", a.Version) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponse. -func (e *ErrorResponse) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailabilityGroupInfo. +func (a *AvailabilityGroupInfo) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", e, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } for key, val := range rawMsg { var err error switch key { - case "error": - err = unpopulate(val, "Error", &e.Error) + case "automatedBackupPreferenceDescription": + err = unpopulate(val, "AutomatedBackupPreferenceDescription", &a.AutomatedBackupPreferenceDescription) + delete(rawMsg, key) + case "basicFeatures": + err = unpopulate(val, "BasicFeatures", &a.BasicFeatures) + delete(rawMsg, key) + case "clusterTypeDescription": + err = unpopulate(val, "ClusterTypeDescription", &a.ClusterTypeDescription) + delete(rawMsg, key) + case "dbFailover": + err = unpopulate(val, "DbFailover", &a.DbFailover) + delete(rawMsg, key) + case "dtcSupport": + err = unpopulate(val, "DtcSupport", &a.DtcSupport) + delete(rawMsg, key) + case "failureConditionLevel": + err = unpopulate(val, "FailureConditionLevel", &a.FailureConditionLevel) + delete(rawMsg, key) + case "healthCheckTimeout": + err = unpopulate(val, "HealthCheckTimeout", &a.HealthCheckTimeout) + delete(rawMsg, key) + case "isContained": + err = unpopulate(val, "IsContained", &a.IsContained) + delete(rawMsg, key) + case "isDistributed": + err = unpopulate(val, "IsDistributed", &a.IsDistributed) + delete(rawMsg, key) + case "listener": + err = unpopulate(val, "Listener", &a.Listener) + delete(rawMsg, key) + case "primaryRecoveryHealthDescription": + err = unpopulate(val, "PrimaryRecoveryHealthDescription", &a.PrimaryRecoveryHealthDescription) + delete(rawMsg, key) + case "primaryReplica": + err = unpopulate(val, "PrimaryReplica", &a.PrimaryReplica) + delete(rawMsg, key) + case "replicationPartnerType": + err = unpopulate(val, "ReplicationPartnerType", &a.ReplicationPartnerType) + delete(rawMsg, key) + case "requiredSynchronizedSecondariesToCommit": + err = unpopulate(val, "RequiredSynchronizedSecondariesToCommit", &a.RequiredSynchronizedSecondariesToCommit) + delete(rawMsg, key) + case "secondaryRecoveryHealthDescription": + err = unpopulate(val, "SecondaryRecoveryHealthDescription", &a.SecondaryRecoveryHealthDescription) + delete(rawMsg, key) + case "synchronizationHealthDescription": + err = unpopulate(val, "SynchronizationHealthDescription", &a.SynchronizationHealthDescription) + delete(rawMsg, key) + case "version": + err = unpopulate(val, "Version", &a.Version) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", e, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type ErrorResponseBody. -func (e ErrorResponseBody) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type AvailabilityGroupState. +func (a AvailabilityGroupState) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "code", e.Code) - populate(objectMap, "details", e.Details) - populate(objectMap, "message", e.Message) - populate(objectMap, "target", e.Target) + populate(objectMap, "availabilityGroupReplicaRole", a.AvailabilityGroupReplicaRole) + populate(objectMap, "connectedStateDescription", a.ConnectedStateDescription) + populate(objectMap, "lastConnectErrorDescription", a.LastConnectErrorDescription) + populateDateTimeRFC3339(objectMap, "lastConnectErrorTimestamp", a.LastConnectErrorTimestamp) + populate(objectMap, "operationalStateDescription", a.OperationalStateDescription) + populate(objectMap, "recoveryHealthDescription", a.RecoveryHealthDescription) + populate(objectMap, "synchronizationHealthDescription", a.SynchronizationHealthDescription) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponseBody. -func (e *ErrorResponseBody) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailabilityGroupState. +func (a *AvailabilityGroupState) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", e, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } for key, val := range rawMsg { var err error switch key { - case "code": - err = unpopulate(val, "Code", &e.Code) + case "availabilityGroupReplicaRole": + err = unpopulate(val, "AvailabilityGroupReplicaRole", &a.AvailabilityGroupReplicaRole) delete(rawMsg, key) - case "details": - err = unpopulate(val, "Details", &e.Details) + case "connectedStateDescription": + err = unpopulate(val, "ConnectedStateDescription", &a.ConnectedStateDescription) delete(rawMsg, key) - case "message": - err = unpopulate(val, "Message", &e.Message) + case "lastConnectErrorDescription": + err = unpopulate(val, "LastConnectErrorDescription", &a.LastConnectErrorDescription) delete(rawMsg, key) - case "target": - err = unpopulate(val, "Target", &e.Target) + case "lastConnectErrorTimestamp": + err = unpopulateDateTimeRFC3339(val, "LastConnectErrorTimestamp", &a.LastConnectErrorTimestamp) + delete(rawMsg, key) + case "operationalStateDescription": + err = unpopulate(val, "OperationalStateDescription", &a.OperationalStateDescription) + delete(rawMsg, key) + case "recoveryHealthDescription": + err = unpopulate(val, "RecoveryHealthDescription", &a.RecoveryHealthDescription) + delete(rawMsg, key) + case "synchronizationHealthDescription": + err = unpopulate(val, "SynchronizationHealthDescription", &a.SynchronizationHealthDescription) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", e, err) + return fmt.Errorf("unmarshalling type %T: %v", a, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type ExtendedLocation. -func (e ExtendedLocation) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type BackgroundJob. +func (b BackgroundJob) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "name", e.Name) - populate(objectMap, "type", e.Type) + populateDateTimeRFC3339(objectMap, "endTime", b.EndTime) + populate(objectMap, "executionState", b.ExecutionState) + populate(objectMap, "lastExecutionStatus", b.LastExecutionStatus) + populateDateTimeRFC3339(objectMap, "lastExecutionTime", b.LastExecutionTime) + populateDateTimeRFC3339(objectMap, "startTime", b.StartTime) + populate(objectMap, "state", b.State) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type ExtendedLocation. -func (e *ExtendedLocation) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type BackgroundJob. +func (b *BackgroundJob) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", e, err) + return fmt.Errorf("unmarshalling type %T: %v", b, err) } for key, val := range rawMsg { var err error switch key { - case "name": - err = unpopulate(val, "Name", &e.Name) + case "endTime": + err = unpopulateDateTimeRFC3339(val, "EndTime", &b.EndTime) delete(rawMsg, key) - case "type": - err = unpopulate(val, "Type", &e.Type) + case "executionState": + err = unpopulate(val, "ExecutionState", &b.ExecutionState) + delete(rawMsg, key) + case "lastExecutionStatus": + err = unpopulate(val, "LastExecutionStatus", &b.LastExecutionStatus) + delete(rawMsg, key) + case "lastExecutionTime": + err = unpopulateDateTimeRFC3339(val, "LastExecutionTime", &b.LastExecutionTime) + delete(rawMsg, key) + case "startTime": + err = unpopulateDateTimeRFC3339(val, "StartTime", &b.StartTime) + delete(rawMsg, key) + case "state": + err = unpopulate(val, "State", &b.State) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", e, err) + return fmt.Errorf("unmarshalling type %T: %v", b, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type K8SResourceRequirements. -func (k K8SResourceRequirements) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type BackupPolicy. +func (b BackupPolicy) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "limits", k.Limits) - populate(objectMap, "requests", k.Requests) - if k.AdditionalProperties != nil { - for key, val := range k.AdditionalProperties { - objectMap[key] = val - } - } + populate(objectMap, "differentialBackupHours", b.DifferentialBackupHours) + populate(objectMap, "fullBackupDays", b.FullBackupDays) + populate(objectMap, "retentionPeriodDays", b.RetentionPeriodDays) + populate(objectMap, "transactionLogBackupMinutes", b.TransactionLogBackupMinutes) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type K8SResourceRequirements. -func (k *K8SResourceRequirements) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type BackupPolicy. +func (b *BackupPolicy) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", k, err) + return fmt.Errorf("unmarshalling type %T: %v", b, err) } for key, val := range rawMsg { var err error switch key { - case "limits": - err = unpopulate(val, "Limits", &k.Limits) + case "differentialBackupHours": + err = unpopulate(val, "DifferentialBackupHours", &b.DifferentialBackupHours) delete(rawMsg, key) - case "requests": - err = unpopulate(val, "Requests", &k.Requests) + case "fullBackupDays": + err = unpopulate(val, "FullBackupDays", &b.FullBackupDays) delete(rawMsg, key) - default: - if k.AdditionalProperties == nil { - k.AdditionalProperties = map[string]any{} - } - if val != nil { - var aux any - err = json.Unmarshal(val, &aux) - k.AdditionalProperties[key] = aux - } + case "retentionPeriodDays": + err = unpopulate(val, "RetentionPeriodDays", &b.RetentionPeriodDays) + delete(rawMsg, key) + case "transactionLogBackupMinutes": + err = unpopulate(val, "TransactionLogBackupMinutes", &b.TransactionLogBackupMinutes) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", k, err) + return fmt.Errorf("unmarshalling type %T: %v", b, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type K8SScheduling. -func (k K8SScheduling) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type BasicLoginInformation. +func (b BasicLoginInformation) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "default", k.Default) - if k.AdditionalProperties != nil { - for key, val := range k.AdditionalProperties { - objectMap[key] = val - } - } + populate(objectMap, "password", b.Password) + populate(objectMap, "username", b.Username) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type K8SScheduling. -func (k *K8SScheduling) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type BasicLoginInformation. +func (b *BasicLoginInformation) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", k, err) + return fmt.Errorf("unmarshalling type %T: %v", b, err) } for key, val := range rawMsg { var err error switch key { - case "default": - err = unpopulate(val, "Default", &k.Default) + case "password": + err = unpopulate(val, "Password", &b.Password) delete(rawMsg, key) - default: - if k.AdditionalProperties == nil { - k.AdditionalProperties = map[string]any{} - } - if val != nil { - var aux any - err = json.Unmarshal(val, &aux) - k.AdditionalProperties[key] = aux - } + case "username": + err = unpopulate(val, "Username", &b.Username) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", k, err) + return fmt.Errorf("unmarshalling type %T: %v", b, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type K8SSchedulingOptions. -func (k K8SSchedulingOptions) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type ClientConnection. +func (c ClientConnection) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "resources", k.Resources) - if k.AdditionalProperties != nil { - for key, val := range k.AdditionalProperties { - objectMap[key] = val - } - } + populate(objectMap, "enabled", c.Enabled) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type K8SSchedulingOptions. -func (k *K8SSchedulingOptions) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type ClientConnection. +func (c *ClientConnection) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", k, err) + return fmt.Errorf("unmarshalling type %T: %v", c, err) } for key, val := range rawMsg { var err error switch key { - case "resources": - err = unpopulate(val, "Resources", &k.Resources) - delete(rawMsg, key) - default: - if k.AdditionalProperties == nil { - k.AdditionalProperties = map[string]any{} - } - if val != nil { - var aux any - err = json.Unmarshal(val, &aux) - k.AdditionalProperties[key] = aux - } + case "enabled": + err = unpopulate(val, "Enabled", &c.Enabled) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", k, err) + return fmt.Errorf("unmarshalling type %T: %v", c, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type KeytabInformation. -func (k KeytabInformation) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type CommonSKU. +func (c CommonSKU) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "keytab", k.Keytab) + populate(objectMap, "capacity", c.Capacity) + populate(objectMap, "dev", c.Dev) + populate(objectMap, "family", c.Family) + populate(objectMap, "name", c.Name) + populate(objectMap, "size", c.Size) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type KeytabInformation. -func (k *KeytabInformation) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type CommonSKU. +func (c *CommonSKU) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", k, err) + return fmt.Errorf("unmarshalling type %T: %v", c, err) } for key, val := range rawMsg { var err error switch key { - case "keytab": - err = unpopulate(val, "Keytab", &k.Keytab) + case "capacity": + err = unpopulate(val, "Capacity", &c.Capacity) + delete(rawMsg, key) + case "dev": + err = unpopulate(val, "Dev", &c.Dev) + delete(rawMsg, key) + case "family": + err = unpopulate(val, "Family", &c.Family) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &c.Name) + delete(rawMsg, key) + case "size": + err = unpopulate(val, "Size", &c.Size) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", k, err) + return fmt.Errorf("unmarshalling type %T: %v", c, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type LogAnalyticsWorkspaceConfig. -func (l LogAnalyticsWorkspaceConfig) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type DBMEndpoint. +func (d DBMEndpoint) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "primaryKey", l.PrimaryKey) - populate(objectMap, "workspaceId", l.WorkspaceID) + populate(objectMap, "certificateName", d.CertificateName) + populate(objectMap, "connectionAuth", d.ConnectionAuth) + populate(objectMap, "encryptionAlgorithm", d.EncryptionAlgorithm) + populate(objectMap, "endpointName", d.EndpointName) + populate(objectMap, "ipAddress", d.IPAddress) + populate(objectMap, "isDynamicPort", d.IsDynamicPort) + populate(objectMap, "isEncryptionEnabled", d.IsEncryptionEnabled) + populate(objectMap, "port", d.Port) + populate(objectMap, "role", d.Role) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type LogAnalyticsWorkspaceConfig. -func (l *LogAnalyticsWorkspaceConfig) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type DBMEndpoint. +func (d *DBMEndpoint) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", l, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "primaryKey": - err = unpopulate(val, "PrimaryKey", &l.PrimaryKey) + case "certificateName": + err = unpopulate(val, "CertificateName", &d.CertificateName) delete(rawMsg, key) - case "workspaceId": - err = unpopulate(val, "WorkspaceID", &l.WorkspaceID) + case "connectionAuth": + err = unpopulate(val, "ConnectionAuth", &d.ConnectionAuth) + delete(rawMsg, key) + case "encryptionAlgorithm": + err = unpopulate(val, "EncryptionAlgorithm", &d.EncryptionAlgorithm) + delete(rawMsg, key) + case "endpointName": + err = unpopulate(val, "EndpointName", &d.EndpointName) + delete(rawMsg, key) + case "ipAddress": + err = unpopulate(val, "IPAddress", &d.IPAddress) + delete(rawMsg, key) + case "isDynamicPort": + err = unpopulate(val, "IsDynamicPort", &d.IsDynamicPort) + delete(rawMsg, key) + case "isEncryptionEnabled": + err = unpopulate(val, "IsEncryptionEnabled", &d.IsEncryptionEnabled) + delete(rawMsg, key) + case "port": + err = unpopulate(val, "Port", &d.Port) + delete(rawMsg, key) + case "role": + err = unpopulate(val, "Role", &d.Role) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", l, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type OnPremiseProperty. -func (o OnPremiseProperty) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type DataBaseMigration. +func (d DataBaseMigration) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "id", o.ID) - populate(objectMap, "publicSigningKey", o.PublicSigningKey) - populate(objectMap, "signingCertificateThumbprint", o.SigningCertificateThumbprint) + populate(objectMap, "assessment", d.Assessment) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type OnPremiseProperty. -func (o *OnPremiseProperty) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type DataBaseMigration. +func (d *DataBaseMigration) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", o, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "id": - err = unpopulate(val, "ID", &o.ID) - delete(rawMsg, key) - case "publicSigningKey": - err = unpopulate(val, "PublicSigningKey", &o.PublicSigningKey) - delete(rawMsg, key) - case "signingCertificateThumbprint": - err = unpopulate(val, "SigningCertificateThumbprint", &o.SigningCertificateThumbprint) + case "assessment": + err = unpopulate(val, "Assessment", &d.Assessment) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", o, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type Operation. -func (o Operation) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type DataBaseMigrationAssessment. +func (d DataBaseMigrationAssessment) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "display", o.Display) - populate(objectMap, "isDataAction", o.IsDataAction) - populate(objectMap, "name", o.Name) - populate(objectMap, "origin", o.Origin) - populate(objectMap, "properties", o.Properties) + populateDateTimeRFC3339(objectMap, "assessmentUploadTime", d.AssessmentUploadTime) + populate(objectMap, "databaseAssessments", d.DatabaseAssessments) + populate(objectMap, "targetReadiness", d.TargetReadiness) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type Operation. -func (o *Operation) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type DataBaseMigrationAssessment. +func (d *DataBaseMigrationAssessment) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", o, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "display": - err = unpopulate(val, "Display", &o.Display) - delete(rawMsg, key) - case "isDataAction": - err = unpopulate(val, "IsDataAction", &o.IsDataAction) + case "assessmentUploadTime": + err = unpopulateDateTimeRFC3339(val, "AssessmentUploadTime", &d.AssessmentUploadTime) delete(rawMsg, key) - case "name": - err = unpopulate(val, "Name", &o.Name) - delete(rawMsg, key) - case "origin": - err = unpopulate(val, "Origin", &o.Origin) + case "databaseAssessments": + err = unpopulate(val, "DatabaseAssessments", &d.DatabaseAssessments) delete(rawMsg, key) - case "properties": - err = unpopulate(val, "Properties", &o.Properties) + case "targetReadiness": + err = unpopulate(val, "TargetReadiness", &d.TargetReadiness) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", o, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type OperationDisplay. -func (o OperationDisplay) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type DataControllerProperties. +func (d DataControllerProperties) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "description", o.Description) - populate(objectMap, "operation", o.Operation) - populate(objectMap, "provider", o.Provider) - populate(objectMap, "resource", o.Resource) + populate(objectMap, "basicLoginInformation", d.BasicLoginInformation) + populate(objectMap, "clusterId", d.ClusterID) + populate(objectMap, "extensionId", d.ExtensionID) + populate(objectMap, "infrastructure", d.Infrastructure) + populateAny(objectMap, "k8sRaw", d.K8SRaw) + populateDateTimeRFC3339(objectMap, "lastUploadedDate", d.LastUploadedDate) + populate(objectMap, "logAnalyticsWorkspaceConfig", d.LogAnalyticsWorkspaceConfig) + populate(objectMap, "logsDashboardCredential", d.LogsDashboardCredential) + populate(objectMap, "metricsDashboardCredential", d.MetricsDashboardCredential) + populate(objectMap, "onPremiseProperty", d.OnPremiseProperty) + populate(objectMap, "provisioningState", d.ProvisioningState) + populate(objectMap, "uploadServicePrincipal", d.UploadServicePrincipal) + populate(objectMap, "uploadWatermark", d.UploadWatermark) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay. -func (o *OperationDisplay) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type DataControllerProperties. +func (d *DataControllerProperties) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", o, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "description": - err = unpopulate(val, "Description", &o.Description) + case "basicLoginInformation": + err = unpopulate(val, "BasicLoginInformation", &d.BasicLoginInformation) delete(rawMsg, key) - case "operation": - err = unpopulate(val, "Operation", &o.Operation) + case "clusterId": + err = unpopulate(val, "ClusterID", &d.ClusterID) delete(rawMsg, key) - case "provider": - err = unpopulate(val, "Provider", &o.Provider) + case "extensionId": + err = unpopulate(val, "ExtensionID", &d.ExtensionID) delete(rawMsg, key) - case "resource": - err = unpopulate(val, "Resource", &o.Resource) + case "infrastructure": + err = unpopulate(val, "Infrastructure", &d.Infrastructure) + delete(rawMsg, key) + case "k8sRaw": + err = unpopulate(val, "K8SRaw", &d.K8SRaw) + delete(rawMsg, key) + case "lastUploadedDate": + err = unpopulateDateTimeRFC3339(val, "LastUploadedDate", &d.LastUploadedDate) + delete(rawMsg, key) + case "logAnalyticsWorkspaceConfig": + err = unpopulate(val, "LogAnalyticsWorkspaceConfig", &d.LogAnalyticsWorkspaceConfig) + delete(rawMsg, key) + case "logsDashboardCredential": + err = unpopulate(val, "LogsDashboardCredential", &d.LogsDashboardCredential) + delete(rawMsg, key) + case "metricsDashboardCredential": + err = unpopulate(val, "MetricsDashboardCredential", &d.MetricsDashboardCredential) + delete(rawMsg, key) + case "onPremiseProperty": + err = unpopulate(val, "OnPremiseProperty", &d.OnPremiseProperty) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &d.ProvisioningState) + delete(rawMsg, key) + case "uploadServicePrincipal": + err = unpopulate(val, "UploadServicePrincipal", &d.UploadServicePrincipal) + delete(rawMsg, key) + case "uploadWatermark": + err = unpopulate(val, "UploadWatermark", &d.UploadWatermark) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", o, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type OperationListResult. -func (o OperationListResult) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type DataControllerResource. +func (d DataControllerResource) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "nextLink", o.NextLink) - populate(objectMap, "value", o.Value) - return json.Marshal(objectMap) -} - -// UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult. -func (o *OperationListResult) UnmarshalJSON(data []byte) error { + populate(objectMap, "extendedLocation", d.ExtendedLocation) + populate(objectMap, "id", d.ID) + populate(objectMap, "location", d.Location) + populate(objectMap, "name", d.Name) + populate(objectMap, "properties", d.Properties) + populate(objectMap, "systemData", d.SystemData) + populate(objectMap, "tags", d.Tags) + populate(objectMap, "type", d.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type DataControllerResource. +func (d *DataControllerResource) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", o, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "nextLink": - err = unpopulate(val, "NextLink", &o.NextLink) + case "extendedLocation": + err = unpopulate(val, "ExtendedLocation", &d.ExtendedLocation) delete(rawMsg, key) - case "value": - err = unpopulate(val, "Value", &o.Value) + case "id": + err = unpopulate(val, "ID", &d.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &d.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &d.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &d.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &d.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &d.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &d.Type) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", o, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type PageOfDataControllerResource. -func (p PageOfDataControllerResource) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type DataControllerUpdate. +func (d DataControllerUpdate) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "nextLink", p.NextLink) - populate(objectMap, "value", p.Value) + populate(objectMap, "properties", d.Properties) + populate(objectMap, "tags", d.Tags) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type PageOfDataControllerResource. -func (p *PageOfDataControllerResource) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type DataControllerUpdate. +func (d *DataControllerUpdate) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "nextLink": - err = unpopulate(val, "NextLink", &p.NextLink) + case "properties": + err = unpopulate(val, "Properties", &d.Properties) delete(rawMsg, key) - case "value": - err = unpopulate(val, "Value", &p.Value) + case "tags": + err = unpopulate(val, "Tags", &d.Tags) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type PostgresInstance. -func (p PostgresInstance) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type DatabaseAssessmentsItem. +func (d DatabaseAssessmentsItem) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "extendedLocation", p.ExtendedLocation) - populate(objectMap, "id", p.ID) - populate(objectMap, "location", p.Location) - populate(objectMap, "name", p.Name) - populate(objectMap, "properties", p.Properties) - populate(objectMap, "sku", p.SKU) - populate(objectMap, "systemData", p.SystemData) - populate(objectMap, "tags", p.Tags) - populate(objectMap, "type", p.Type) + populate(objectMap, "appliesToMigrationTargetPlatform", d.AppliesToMigrationTargetPlatform) + populate(objectMap, "featureId", d.FeatureID) + populate(objectMap, "issueCategory", d.IssueCategory) + populate(objectMap, "moreInformation", d.MoreInformation) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type PostgresInstance. -func (p *PostgresInstance) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type DatabaseAssessmentsItem. +func (d *DatabaseAssessmentsItem) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "extendedLocation": - err = unpopulate(val, "ExtendedLocation", &p.ExtendedLocation) - delete(rawMsg, key) - case "id": - err = unpopulate(val, "ID", &p.ID) - delete(rawMsg, key) - case "location": - err = unpopulate(val, "Location", &p.Location) - delete(rawMsg, key) - case "name": - err = unpopulate(val, "Name", &p.Name) - delete(rawMsg, key) - case "properties": - err = unpopulate(val, "Properties", &p.Properties) + case "appliesToMigrationTargetPlatform": + err = unpopulate(val, "AppliesToMigrationTargetPlatform", &d.AppliesToMigrationTargetPlatform) delete(rawMsg, key) - case "sku": - err = unpopulate(val, "SKU", &p.SKU) - delete(rawMsg, key) - case "systemData": - err = unpopulate(val, "SystemData", &p.SystemData) + case "featureId": + err = unpopulate(val, "FeatureID", &d.FeatureID) delete(rawMsg, key) - case "tags": - err = unpopulate(val, "Tags", &p.Tags) + case "issueCategory": + err = unpopulate(val, "IssueCategory", &d.IssueCategory) delete(rawMsg, key) - case "type": - err = unpopulate(val, "Type", &p.Type) + case "moreInformation": + err = unpopulate(val, "MoreInformation", &d.MoreInformation) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type PostgresInstanceListResult. -func (p PostgresInstanceListResult) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type Databases. +func (d Databases) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "nextLink", p.NextLink) - populate(objectMap, "value", p.Value) + populate(objectMap, "values", d.Values) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type PostgresInstanceListResult. -func (p *PostgresInstanceListResult) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type Databases. +func (d *Databases) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "nextLink": - err = unpopulate(val, "NextLink", &p.NextLink) - delete(rawMsg, key) - case "value": - err = unpopulate(val, "Value", &p.Value) + case "values": + err = unpopulate(val, "Values", &d.Values) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type PostgresInstanceProperties. -func (p PostgresInstanceProperties) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type DistributedAvailabilityGroupCreateUpdateAvailabilityGroupCertificateConfiguration. +func (d DistributedAvailabilityGroupCreateUpdateAvailabilityGroupCertificateConfiguration) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "admin", p.Admin) - populate(objectMap, "basicLoginInformation", p.BasicLoginInformation) - populate(objectMap, "dataControllerId", p.DataControllerID) - populateAny(objectMap, "k8sRaw", p.K8SRaw) - populateDateTimeRFC3339(objectMap, "lastUploadedDate", p.LastUploadedDate) - populate(objectMap, "provisioningState", p.ProvisioningState) + populate(objectMap, "certificateName", d.CertificateName) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type PostgresInstanceProperties. -func (p *PostgresInstanceProperties) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type DistributedAvailabilityGroupCreateUpdateAvailabilityGroupCertificateConfiguration. +func (d *DistributedAvailabilityGroupCreateUpdateAvailabilityGroupCertificateConfiguration) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "admin": - err = unpopulate(val, "Admin", &p.Admin) - delete(rawMsg, key) - case "basicLoginInformation": - err = unpopulate(val, "BasicLoginInformation", &p.BasicLoginInformation) - delete(rawMsg, key) - case "dataControllerId": - err = unpopulate(val, "DataControllerID", &p.DataControllerID) - delete(rawMsg, key) - case "k8sRaw": - err = unpopulate(val, "K8SRaw", &p.K8SRaw) - delete(rawMsg, key) - case "lastUploadedDate": - err = unpopulateDateTimeRFC3339(val, "LastUploadedDate", &p.LastUploadedDate) - delete(rawMsg, key) - case "provisioningState": - err = unpopulate(val, "ProvisioningState", &p.ProvisioningState) + case "certificateName": + err = unpopulate(val, "CertificateName", &d.CertificateName) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type PostgresInstanceSKU. -func (p PostgresInstanceSKU) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type DistributedAvailabilityGroupCreateUpdateAvailabilityGroupConfiguration. +func (d DistributedAvailabilityGroupCreateUpdateAvailabilityGroupConfiguration) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "capacity", p.Capacity) - populate(objectMap, "dev", p.Dev) - populate(objectMap, "family", p.Family) - populate(objectMap, "name", p.Name) - populate(objectMap, "size", p.Size) - objectMap["tier"] = "Hyperscale" + populate(objectMap, "availabilityGroup", d.AvailabilityGroup) + populate(objectMap, "availabilityMode", d.AvailabilityMode) + populate(objectMap, "certificateConfiguration", d.CertificateConfiguration) + populate(objectMap, "failoverMode", d.FailoverMode) + populate(objectMap, "listenerUrl", d.ListenerURL) + populate(objectMap, "seedingMode", d.SeedingMode) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type PostgresInstanceSKU. -func (p *PostgresInstanceSKU) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type DistributedAvailabilityGroupCreateUpdateAvailabilityGroupConfiguration. +func (d *DistributedAvailabilityGroupCreateUpdateAvailabilityGroupConfiguration) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "capacity": - err = unpopulate(val, "Capacity", &p.Capacity) + case "availabilityGroup": + err = unpopulate(val, "AvailabilityGroup", &d.AvailabilityGroup) delete(rawMsg, key) - case "dev": - err = unpopulate(val, "Dev", &p.Dev) + case "availabilityMode": + err = unpopulate(val, "AvailabilityMode", &d.AvailabilityMode) delete(rawMsg, key) - case "family": - err = unpopulate(val, "Family", &p.Family) + case "certificateConfiguration": + err = unpopulate(val, "CertificateConfiguration", &d.CertificateConfiguration) delete(rawMsg, key) - case "name": - err = unpopulate(val, "Name", &p.Name) + case "failoverMode": + err = unpopulate(val, "FailoverMode", &d.FailoverMode) delete(rawMsg, key) - case "size": - err = unpopulate(val, "Size", &p.Size) + case "listenerUrl": + err = unpopulate(val, "ListenerURL", &d.ListenerURL) delete(rawMsg, key) - case "tier": - err = unpopulate(val, "Tier", &p.Tier) + case "seedingMode": + err = unpopulate(val, "SeedingMode", &d.SeedingMode) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type PostgresInstanceUpdate. -func (p PostgresInstanceUpdate) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type DistributedAvailabilityGroupCreateUpdateConfiguration. +func (d DistributedAvailabilityGroupCreateUpdateConfiguration) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "properties", p.Properties) - populate(objectMap, "tags", p.Tags) + populate(objectMap, "availabilityGroupName", d.AvailabilityGroupName) + populate(objectMap, "primaryAvailabilityGroup", d.PrimaryAvailabilityGroup) + populate(objectMap, "secondaryAvailabilityGroup", d.SecondaryAvailabilityGroup) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type PostgresInstanceUpdate. -func (p *PostgresInstanceUpdate) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type DistributedAvailabilityGroupCreateUpdateConfiguration. +func (d *DistributedAvailabilityGroupCreateUpdateConfiguration) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } for key, val := range rawMsg { var err error switch key { - case "properties": - err = unpopulate(val, "Properties", &p.Properties) + case "availabilityGroupName": + err = unpopulate(val, "AvailabilityGroupName", &d.AvailabilityGroupName) delete(rawMsg, key) - case "tags": - err = unpopulate(val, "Tags", &p.Tags) + case "primaryAvailabilityGroup": + err = unpopulate(val, "PrimaryAvailabilityGroup", &d.PrimaryAvailabilityGroup) + delete(rawMsg, key) + case "secondaryAvailabilityGroup": + err = unpopulate(val, "SecondaryAvailabilityGroup", &d.SecondaryAvailabilityGroup) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", d, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type ProxyResource. -func (p ProxyResource) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type ErrorAdditionalInfo. +func (e ErrorAdditionalInfo) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "id", p.ID) - populate(objectMap, "name", p.Name) - populate(objectMap, "systemData", p.SystemData) - populate(objectMap, "type", p.Type) + populateAny(objectMap, "info", e.Info) + populate(objectMap, "type", e.Type) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type ProxyResource. -func (p *ProxyResource) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type ErrorAdditionalInfo. +func (e *ErrorAdditionalInfo) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", e, err) } for key, val := range rawMsg { var err error switch key { - case "id": - err = unpopulate(val, "ID", &p.ID) - delete(rawMsg, key) - case "name": - err = unpopulate(val, "Name", &p.Name) - delete(rawMsg, key) - case "systemData": - err = unpopulate(val, "SystemData", &p.SystemData) + case "info": + err = unpopulate(val, "Info", &e.Info) delete(rawMsg, key) case "type": - err = unpopulate(val, "Type", &p.Type) + err = unpopulate(val, "Type", &e.Type) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) + return fmt.Errorf("unmarshalling type %T: %v", e, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type Resource. -func (r Resource) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type ErrorDetail. +func (e ErrorDetail) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "id", r.ID) - populate(objectMap, "name", r.Name) - populate(objectMap, "systemData", r.SystemData) - populate(objectMap, "type", r.Type) + populate(objectMap, "additionalInfo", e.AdditionalInfo) + populate(objectMap, "code", e.Code) + populate(objectMap, "details", e.Details) + populate(objectMap, "message", e.Message) + populate(objectMap, "target", e.Target) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type Resource. -func (r *Resource) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetail. +func (e *ErrorDetail) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", r, err) + return fmt.Errorf("unmarshalling type %T: %v", e, err) } for key, val := range rawMsg { var err error switch key { - case "id": - err = unpopulate(val, "ID", &r.ID) + case "additionalInfo": + err = unpopulate(val, "AdditionalInfo", &e.AdditionalInfo) delete(rawMsg, key) - case "name": - err = unpopulate(val, "Name", &r.Name) + case "code": + err = unpopulate(val, "Code", &e.Code) delete(rawMsg, key) - case "systemData": - err = unpopulate(val, "SystemData", &r.SystemData) + case "details": + err = unpopulate(val, "Details", &e.Details) delete(rawMsg, key) - case "type": - err = unpopulate(val, "Type", &r.Type) + case "message": + err = unpopulate(val, "Message", &e.Message) + delete(rawMsg, key) + case "target": + err = unpopulate(val, "Target", &e.Target) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", r, err) + return fmt.Errorf("unmarshalling type %T: %v", e, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstance. -func (s SQLManagedInstance) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type ErrorResponse. +func (e ErrorResponse) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "extendedLocation", s.ExtendedLocation) - populate(objectMap, "id", s.ID) - populate(objectMap, "location", s.Location) - populate(objectMap, "name", s.Name) - populate(objectMap, "properties", s.Properties) - populate(objectMap, "sku", s.SKU) - populate(objectMap, "systemData", s.SystemData) - populate(objectMap, "tags", s.Tags) - populate(objectMap, "type", s.Type) + populate(objectMap, "error", e.Error) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstance. -func (s *SQLManagedInstance) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponse. +func (e *ErrorResponse) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) + return fmt.Errorf("unmarshalling type %T: %v", e, err) } for key, val := range rawMsg { var err error switch key { - case "extendedLocation": - err = unpopulate(val, "ExtendedLocation", &s.ExtendedLocation) + case "error": + err = unpopulate(val, "Error", &e.Error) delete(rawMsg, key) - case "id": - err = unpopulate(val, "ID", &s.ID) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExtendedLocation. +func (e ExtendedLocation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "name", e.Name) + populate(objectMap, "type", e.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExtendedLocation. +func (e *ExtendedLocation) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "name": + err = unpopulate(val, "Name", &e.Name) delete(rawMsg, key) - case "location": - err = unpopulate(val, "Location", &s.Location) + case "type": + err = unpopulate(val, "Type", &e.Type) delete(rawMsg, key) - case "name": - err = unpopulate(val, "Name", &s.Name) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type FailoverCluster. +func (f FailoverCluster) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "hostNames", f.HostNames) + populate(objectMap, "id", f.ID) + populate(objectMap, "networkName", f.NetworkName) + populate(objectMap, "sqlInstanceIds", f.SQLInstanceIDs) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type FailoverCluster. +func (f *FailoverCluster) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", f, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "hostNames": + err = unpopulate(val, "HostNames", &f.HostNames) delete(rawMsg, key) - case "properties": - err = unpopulate(val, "Properties", &s.Properties) + case "id": + err = unpopulate(val, "ID", &f.ID) delete(rawMsg, key) - case "sku": - err = unpopulate(val, "SKU", &s.SKU) + case "networkName": + err = unpopulate(val, "NetworkName", &f.NetworkName) delete(rawMsg, key) - case "systemData": - err = unpopulate(val, "SystemData", &s.SystemData) + case "sqlInstanceIds": + err = unpopulate(val, "SQLInstanceIDs", &f.SQLInstanceIDs) delete(rawMsg, key) - case "tags": - err = unpopulate(val, "Tags", &s.Tags) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", f, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type FailoverGroupListResult. +func (f FailoverGroupListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", f.NextLink) + populate(objectMap, "value", f.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type FailoverGroupListResult. +func (f *FailoverGroupListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", f, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &f.NextLink) delete(rawMsg, key) - case "type": - err = unpopulate(val, "Type", &s.Type) + case "value": + err = unpopulate(val, "Value", &f.Value) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) + return fmt.Errorf("unmarshalling type %T: %v", f, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceK8SRaw. -func (s SQLManagedInstanceK8SRaw) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type FailoverGroupProperties. +func (f FailoverGroupProperties) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "spec", s.Spec) - if s.AdditionalProperties != nil { - for key, val := range s.AdditionalProperties { + populate(objectMap, "partnerManagedInstanceId", f.PartnerManagedInstanceID) + populate(objectMap, "provisioningState", f.ProvisioningState) + populate(objectMap, "spec", f.Spec) + populateAny(objectMap, "status", f.Status) + if f.AdditionalProperties != nil { + for key, val := range f.AdditionalProperties { objectMap[key] = val } } return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceK8SRaw. -func (s *SQLManagedInstanceK8SRaw) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type FailoverGroupProperties. +func (f *FailoverGroupProperties) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) + return fmt.Errorf("unmarshalling type %T: %v", f, err) } for key, val := range rawMsg { var err error switch key { + case "partnerManagedInstanceId": + err = unpopulate(val, "PartnerManagedInstanceID", &f.PartnerManagedInstanceID) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &f.ProvisioningState) + delete(rawMsg, key) case "spec": - err = unpopulate(val, "Spec", &s.Spec) + err = unpopulate(val, "Spec", &f.Spec) + delete(rawMsg, key) + case "status": + err = unpopulate(val, "Status", &f.Status) delete(rawMsg, key) default: - if s.AdditionalProperties == nil { - s.AdditionalProperties = map[string]any{} + if f.AdditionalProperties == nil { + f.AdditionalProperties = map[string]any{} } if val != nil { var aux any err = json.Unmarshal(val, &aux) - s.AdditionalProperties[key] = aux + f.AdditionalProperties[key] = aux } delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) + return fmt.Errorf("unmarshalling type %T: %v", f, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceK8SSpec. -func (s SQLManagedInstanceK8SSpec) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type FailoverGroupResource. +func (f FailoverGroupResource) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "replicas", s.Replicas) - populate(objectMap, "scheduling", s.Scheduling) - if s.AdditionalProperties != nil { - for key, val := range s.AdditionalProperties { + populate(objectMap, "id", f.ID) + populate(objectMap, "name", f.Name) + populate(objectMap, "properties", f.Properties) + populate(objectMap, "systemData", f.SystemData) + populate(objectMap, "type", f.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type FailoverGroupResource. +func (f *FailoverGroupResource) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", f, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &f.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &f.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &f.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &f.SystemData) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &f.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", f, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type FailoverGroupSpec. +func (f FailoverGroupSpec) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "partnerMI", f.PartnerMI) + populate(objectMap, "partnerMirroringCert", f.PartnerMirroringCert) + populate(objectMap, "partnerMirroringURL", f.PartnerMirroringURL) + populate(objectMap, "partnerSyncMode", f.PartnerSyncMode) + populate(objectMap, "role", f.Role) + populate(objectMap, "sharedName", f.SharedName) + populate(objectMap, "sourceMI", f.SourceMI) + if f.AdditionalProperties != nil { + for key, val := range f.AdditionalProperties { objectMap[key] = val } } return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceK8SSpec. -func (s *SQLManagedInstanceK8SSpec) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type FailoverGroupSpec. +func (f *FailoverGroupSpec) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) + return fmt.Errorf("unmarshalling type %T: %v", f, err) } for key, val := range rawMsg { var err error switch key { - case "replicas": - err = unpopulate(val, "Replicas", &s.Replicas) + case "partnerMI": + err = unpopulate(val, "PartnerMI", &f.PartnerMI) delete(rawMsg, key) - case "scheduling": - err = unpopulate(val, "Scheduling", &s.Scheduling) + case "partnerMirroringCert": + err = unpopulate(val, "PartnerMirroringCert", &f.PartnerMirroringCert) + delete(rawMsg, key) + case "partnerMirroringURL": + err = unpopulate(val, "PartnerMirroringURL", &f.PartnerMirroringURL) + delete(rawMsg, key) + case "partnerSyncMode": + err = unpopulate(val, "PartnerSyncMode", &f.PartnerSyncMode) + delete(rawMsg, key) + case "role": + err = unpopulate(val, "Role", &f.Role) + delete(rawMsg, key) + case "sharedName": + err = unpopulate(val, "SharedName", &f.SharedName) + delete(rawMsg, key) + case "sourceMI": + err = unpopulate(val, "SourceMI", &f.SourceMI) delete(rawMsg, key) default: - if s.AdditionalProperties == nil { - s.AdditionalProperties = map[string]any{} + if f.AdditionalProperties == nil { + f.AdditionalProperties = map[string]any{} } if val != nil { var aux any err = json.Unmarshal(val, &aux) - s.AdditionalProperties[key] = aux + f.AdditionalProperties[key] = aux } delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) + return fmt.Errorf("unmarshalling type %T: %v", f, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceListResult. -func (s SQLManagedInstanceListResult) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type K8SActiveDirectory. +func (k K8SActiveDirectory) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "nextLink", s.NextLink) - populate(objectMap, "value", s.Value) + populate(objectMap, "accountName", k.AccountName) + populate(objectMap, "connector", k.Connector) + populate(objectMap, "encryptionTypes", k.EncryptionTypes) + populate(objectMap, "keytabSecret", k.KeytabSecret) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceListResult. -func (s *SQLManagedInstanceListResult) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type K8SActiveDirectory. +func (k *K8SActiveDirectory) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) + return fmt.Errorf("unmarshalling type %T: %v", k, err) } for key, val := range rawMsg { var err error switch key { - case "nextLink": - err = unpopulate(val, "NextLink", &s.NextLink) + case "accountName": + err = unpopulate(val, "AccountName", &k.AccountName) delete(rawMsg, key) - case "value": - err = unpopulate(val, "Value", &s.Value) + case "connector": + err = unpopulate(val, "Connector", &k.Connector) + delete(rawMsg, key) + case "encryptionTypes": + err = unpopulate(val, "EncryptionTypes", &k.EncryptionTypes) + delete(rawMsg, key) + case "keytabSecret": + err = unpopulate(val, "KeytabSecret", &k.KeytabSecret) delete(rawMsg, key) } if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) + return fmt.Errorf("unmarshalling type %T: %v", k, err) } } return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceProperties. -func (s SQLManagedInstanceProperties) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type K8SActiveDirectoryConnector. +func (k K8SActiveDirectoryConnector) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "activeDirectoryInformation", s.ActiveDirectoryInformation) - populate(objectMap, "admin", s.Admin) - populate(objectMap, "basicLoginInformation", s.BasicLoginInformation) - populate(objectMap, "clusterId", s.ClusterID) - populate(objectMap, "dataControllerId", s.DataControllerID) - populate(objectMap, "endTime", s.EndTime) - populate(objectMap, "extensionId", s.ExtensionID) - populate(objectMap, "k8sRaw", s.K8SRaw) - populateDateTimeRFC3339(objectMap, "lastUploadedDate", s.LastUploadedDate) - populate(objectMap, "licenseType", s.LicenseType) - populate(objectMap, "provisioningState", s.ProvisioningState) - populate(objectMap, "startTime", s.StartTime) + populate(objectMap, "name", k.Name) + populate(objectMap, "namespace", k.Namespace) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceProperties. -func (s *SQLManagedInstanceProperties) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type K8SActiveDirectoryConnector. +func (k *K8SActiveDirectoryConnector) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) + return fmt.Errorf("unmarshalling type %T: %v", k, err) } for key, val := range rawMsg { var err error switch key { - case "activeDirectoryInformation": - err = unpopulate(val, "ActiveDirectoryInformation", &s.ActiveDirectoryInformation) - delete(rawMsg, key) - case "admin": - err = unpopulate(val, "Admin", &s.Admin) - delete(rawMsg, key) - case "basicLoginInformation": - err = unpopulate(val, "BasicLoginInformation", &s.BasicLoginInformation) - delete(rawMsg, key) - case "clusterId": - err = unpopulate(val, "ClusterID", &s.ClusterID) + case "name": + err = unpopulate(val, "Name", &k.Name) delete(rawMsg, key) - case "dataControllerId": - err = unpopulate(val, "DataControllerID", &s.DataControllerID) + case "namespace": + err = unpopulate(val, "Namespace", &k.Namespace) delete(rawMsg, key) - case "endTime": - err = unpopulate(val, "EndTime", &s.EndTime) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type K8SNetworkSettings. +func (k K8SNetworkSettings) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "forceencryption", k.Forceencryption) + populate(objectMap, "tlsciphers", k.Tlsciphers) + populate(objectMap, "tlsprotocols", k.Tlsprotocols) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type K8SNetworkSettings. +func (k *K8SNetworkSettings) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "forceencryption": + err = unpopulate(val, "Forceencryption", &k.Forceencryption) delete(rawMsg, key) - case "extensionId": - err = unpopulate(val, "ExtensionID", &s.ExtensionID) + case "tlsciphers": + err = unpopulate(val, "Tlsciphers", &k.Tlsciphers) delete(rawMsg, key) - case "k8sRaw": - err = unpopulate(val, "K8SRaw", &s.K8SRaw) + case "tlsprotocols": + err = unpopulate(val, "Tlsprotocols", &k.Tlsprotocols) delete(rawMsg, key) - case "lastUploadedDate": - err = unpopulateDateTimeRFC3339(val, "LastUploadedDate", &s.LastUploadedDate) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type K8SResourceRequirements. +func (k K8SResourceRequirements) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "limits", k.Limits) + populate(objectMap, "requests", k.Requests) + if k.AdditionalProperties != nil { + for key, val := range k.AdditionalProperties { + objectMap[key] = val + } + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type K8SResourceRequirements. +func (k *K8SResourceRequirements) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "limits": + err = unpopulate(val, "Limits", &k.Limits) + delete(rawMsg, key) + case "requests": + err = unpopulate(val, "Requests", &k.Requests) + delete(rawMsg, key) + default: + if k.AdditionalProperties == nil { + k.AdditionalProperties = map[string]any{} + } + if val != nil { + var aux any + err = json.Unmarshal(val, &aux) + k.AdditionalProperties[key] = aux + } + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type K8SScheduling. +func (k K8SScheduling) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "default", k.Default) + if k.AdditionalProperties != nil { + for key, val := range k.AdditionalProperties { + objectMap[key] = val + } + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type K8SScheduling. +func (k *K8SScheduling) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "default": + err = unpopulate(val, "Default", &k.Default) + delete(rawMsg, key) + default: + if k.AdditionalProperties == nil { + k.AdditionalProperties = map[string]any{} + } + if val != nil { + var aux any + err = json.Unmarshal(val, &aux) + k.AdditionalProperties[key] = aux + } + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type K8SSchedulingOptions. +func (k K8SSchedulingOptions) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "resources", k.Resources) + if k.AdditionalProperties != nil { + for key, val := range k.AdditionalProperties { + objectMap[key] = val + } + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type K8SSchedulingOptions. +func (k *K8SSchedulingOptions) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "resources": + err = unpopulate(val, "Resources", &k.Resources) + delete(rawMsg, key) + default: + if k.AdditionalProperties == nil { + k.AdditionalProperties = map[string]any{} + } + if val != nil { + var aux any + err = json.Unmarshal(val, &aux) + k.AdditionalProperties[key] = aux + } + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type K8SSecurity. +func (k K8SSecurity) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "activeDirectory", k.ActiveDirectory) + populate(objectMap, "adminLoginSecret", k.AdminLoginSecret) + populate(objectMap, "serviceCertificateSecret", k.ServiceCertificateSecret) + populate(objectMap, "transparentDataEncryption", k.TransparentDataEncryption) + if k.AdditionalProperties != nil { + for key, val := range k.AdditionalProperties { + objectMap[key] = val + } + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type K8SSecurity. +func (k *K8SSecurity) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "activeDirectory": + err = unpopulate(val, "ActiveDirectory", &k.ActiveDirectory) + delete(rawMsg, key) + case "adminLoginSecret": + err = unpopulate(val, "AdminLoginSecret", &k.AdminLoginSecret) + delete(rawMsg, key) + case "serviceCertificateSecret": + err = unpopulate(val, "ServiceCertificateSecret", &k.ServiceCertificateSecret) + delete(rawMsg, key) + case "transparentDataEncryption": + err = unpopulate(val, "TransparentDataEncryption", &k.TransparentDataEncryption) + delete(rawMsg, key) + default: + if k.AdditionalProperties == nil { + k.AdditionalProperties = map[string]any{} + } + if val != nil { + var aux any + err = json.Unmarshal(val, &aux) + k.AdditionalProperties[key] = aux + } + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type K8SSettings. +func (k K8SSettings) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "network", k.Network) + if k.AdditionalProperties != nil { + for key, val := range k.AdditionalProperties { + objectMap[key] = val + } + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type K8SSettings. +func (k *K8SSettings) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "network": + err = unpopulate(val, "Network", &k.Network) + delete(rawMsg, key) + default: + if k.AdditionalProperties == nil { + k.AdditionalProperties = map[string]any{} + } + if val != nil { + var aux any + err = json.Unmarshal(val, &aux) + k.AdditionalProperties[key] = aux + } + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type K8StransparentDataEncryption. +func (k K8StransparentDataEncryption) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "mode", k.Mode) + populate(objectMap, "protectorSecret", k.ProtectorSecret) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type K8StransparentDataEncryption. +func (k *K8StransparentDataEncryption) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "mode": + err = unpopulate(val, "Mode", &k.Mode) + delete(rawMsg, key) + case "protectorSecret": + err = unpopulate(val, "ProtectorSecret", &k.ProtectorSecret) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type KeytabInformation. +func (k KeytabInformation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "keytab", k.Keytab) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type KeytabInformation. +func (k *KeytabInformation) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "keytab": + err = unpopulate(val, "Keytab", &k.Keytab) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type LogAnalyticsWorkspaceConfig. +func (l LogAnalyticsWorkspaceConfig) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "primaryKey", l.PrimaryKey) + populate(objectMap, "workspaceId", l.WorkspaceID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type LogAnalyticsWorkspaceConfig. +func (l *LogAnalyticsWorkspaceConfig) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", l, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "primaryKey": + err = unpopulate(val, "PrimaryKey", &l.PrimaryKey) + delete(rawMsg, key) + case "workspaceId": + err = unpopulate(val, "WorkspaceID", &l.WorkspaceID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", l, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type Migration. +func (m Migration) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "assessment", m.Assessment) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Migration. +func (m *Migration) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "assessment": + err = unpopulate(val, "Assessment", &m.Assessment) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type MigrationAssessment. +func (m MigrationAssessment) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populateDateTimeRFC3339(objectMap, "assessmentUploadTime", m.AssessmentUploadTime) + populate(objectMap, "enabled", m.Enabled) + populate(objectMap, "skuRecommendationResults", m.SKURecommendationResults) + populate(objectMap, "serverAssessments", m.ServerAssessments) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type MigrationAssessment. +func (m *MigrationAssessment) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "assessmentUploadTime": + err = unpopulateDateTimeRFC3339(val, "AssessmentUploadTime", &m.AssessmentUploadTime) + delete(rawMsg, key) + case "enabled": + err = unpopulate(val, "Enabled", &m.Enabled) + delete(rawMsg, key) + case "skuRecommendationResults": + err = unpopulate(val, "SKURecommendationResults", &m.SKURecommendationResults) + delete(rawMsg, key) + case "serverAssessments": + err = unpopulate(val, "ServerAssessments", &m.ServerAssessments) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type Monitoring. +func (m Monitoring) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "enabled", m.Enabled) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Monitoring. +func (m *Monitoring) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "enabled": + err = unpopulate(val, "Enabled", &m.Enabled) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OnPremiseProperty. +func (o OnPremiseProperty) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", o.ID) + populate(objectMap, "publicSigningKey", o.PublicSigningKey) + populate(objectMap, "signingCertificateThumbprint", o.SigningCertificateThumbprint) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OnPremiseProperty. +func (o *OnPremiseProperty) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &o.ID) + delete(rawMsg, key) + case "publicSigningKey": + err = unpopulate(val, "PublicSigningKey", &o.PublicSigningKey) + delete(rawMsg, key) + case "signingCertificateThumbprint": + err = unpopulate(val, "SigningCertificateThumbprint", &o.SigningCertificateThumbprint) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type Operation. +func (o Operation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "display", o.Display) + populate(objectMap, "isDataAction", o.IsDataAction) + populate(objectMap, "name", o.Name) + populate(objectMap, "origin", o.Origin) + populate(objectMap, "properties", o.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Operation. +func (o *Operation) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "display": + err = unpopulate(val, "Display", &o.Display) + delete(rawMsg, key) + case "isDataAction": + err = unpopulate(val, "IsDataAction", &o.IsDataAction) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &o.Name) + delete(rawMsg, key) + case "origin": + err = unpopulate(val, "Origin", &o.Origin) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &o.Properties) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OperationDisplay. +func (o OperationDisplay) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "description", o.Description) + populate(objectMap, "operation", o.Operation) + populate(objectMap, "provider", o.Provider) + populate(objectMap, "resource", o.Resource) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay. +func (o *OperationDisplay) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "description": + err = unpopulate(val, "Description", &o.Description) + delete(rawMsg, key) + case "operation": + err = unpopulate(val, "Operation", &o.Operation) + delete(rawMsg, key) + case "provider": + err = unpopulate(val, "Provider", &o.Provider) + delete(rawMsg, key) + case "resource": + err = unpopulate(val, "Resource", &o.Resource) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OperationListResult. +func (o OperationListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", o.NextLink) + populate(objectMap, "value", o.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult. +func (o *OperationListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &o.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &o.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type PageOfDataControllerResource. +func (p PageOfDataControllerResource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", p.NextLink) + populate(objectMap, "value", p.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PageOfDataControllerResource. +func (p *PageOfDataControllerResource) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &p.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &p.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type PostgresInstance. +func (p PostgresInstance) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "extendedLocation", p.ExtendedLocation) + populate(objectMap, "id", p.ID) + populate(objectMap, "location", p.Location) + populate(objectMap, "name", p.Name) + populate(objectMap, "properties", p.Properties) + populate(objectMap, "sku", p.SKU) + populate(objectMap, "systemData", p.SystemData) + populate(objectMap, "tags", p.Tags) + populate(objectMap, "type", p.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PostgresInstance. +func (p *PostgresInstance) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "extendedLocation": + err = unpopulate(val, "ExtendedLocation", &p.ExtendedLocation) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &p.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &p.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &p.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &p.Properties) + delete(rawMsg, key) + case "sku": + err = unpopulate(val, "SKU", &p.SKU) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &p.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &p.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &p.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type PostgresInstanceListResult. +func (p PostgresInstanceListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", p.NextLink) + populate(objectMap, "value", p.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PostgresInstanceListResult. +func (p *PostgresInstanceListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &p.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &p.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type PostgresInstanceProperties. +func (p PostgresInstanceProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "admin", p.Admin) + populate(objectMap, "basicLoginInformation", p.BasicLoginInformation) + populate(objectMap, "dataControllerId", p.DataControllerID) + populateAny(objectMap, "k8sRaw", p.K8SRaw) + populateDateTimeRFC3339(objectMap, "lastUploadedDate", p.LastUploadedDate) + populate(objectMap, "provisioningState", p.ProvisioningState) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PostgresInstanceProperties. +func (p *PostgresInstanceProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "admin": + err = unpopulate(val, "Admin", &p.Admin) + delete(rawMsg, key) + case "basicLoginInformation": + err = unpopulate(val, "BasicLoginInformation", &p.BasicLoginInformation) + delete(rawMsg, key) + case "dataControllerId": + err = unpopulate(val, "DataControllerID", &p.DataControllerID) + delete(rawMsg, key) + case "k8sRaw": + err = unpopulate(val, "K8SRaw", &p.K8SRaw) + delete(rawMsg, key) + case "lastUploadedDate": + err = unpopulateDateTimeRFC3339(val, "LastUploadedDate", &p.LastUploadedDate) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &p.ProvisioningState) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type PostgresInstanceSKU. +func (p PostgresInstanceSKU) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "capacity", p.Capacity) + populate(objectMap, "dev", p.Dev) + populate(objectMap, "family", p.Family) + populate(objectMap, "name", p.Name) + populate(objectMap, "size", p.Size) + objectMap["tier"] = "Hyperscale" + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PostgresInstanceSKU. +func (p *PostgresInstanceSKU) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "capacity": + err = unpopulate(val, "Capacity", &p.Capacity) + delete(rawMsg, key) + case "dev": + err = unpopulate(val, "Dev", &p.Dev) + delete(rawMsg, key) + case "family": + err = unpopulate(val, "Family", &p.Family) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &p.Name) + delete(rawMsg, key) + case "size": + err = unpopulate(val, "Size", &p.Size) + delete(rawMsg, key) + case "tier": + err = unpopulate(val, "Tier", &p.Tier) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type PostgresInstanceUpdate. +func (p PostgresInstanceUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "properties", p.Properties) + populate(objectMap, "tags", p.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PostgresInstanceUpdate. +func (p *PostgresInstanceUpdate) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &p.Properties) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &p.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ProxyResource. +func (p ProxyResource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", p.ID) + populate(objectMap, "name", p.Name) + populate(objectMap, "systemData", p.SystemData) + populate(objectMap, "type", p.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ProxyResource. +func (p *ProxyResource) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &p.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &p.Name) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &p.SystemData) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &p.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type Resource. +func (r Resource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", r.ID) + populate(objectMap, "name", r.Name) + populate(objectMap, "systemData", r.SystemData) + populate(objectMap, "type", r.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Resource. +func (r *Resource) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &r.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &r.Name) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &r.SystemData) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &r.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ResourceAutoGenerated. +func (r ResourceAutoGenerated) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", r.ID) + populate(objectMap, "name", r.Name) + populate(objectMap, "systemData", r.SystemData) + populate(objectMap, "type", r.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ResourceAutoGenerated. +func (r *ResourceAutoGenerated) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &r.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &r.Name) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &r.SystemData) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &r.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResults. +func (s SKURecommendationResults) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "azureSqlDatabase", s.AzureSQLDatabase) + populate(objectMap, "azureSqlManagedInstance", s.AzureSQLManagedInstance) + populate(objectMap, "azureSqlVirtualMachine", s.AzureSQLVirtualMachine) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResults. +func (s *SKURecommendationResults) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "azureSqlDatabase": + err = unpopulate(val, "AzureSQLDatabase", &s.AzureSQLDatabase) + delete(rawMsg, key) + case "azureSqlManagedInstance": + err = unpopulate(val, "AzureSQLManagedInstance", &s.AzureSQLManagedInstance) + delete(rawMsg, key) + case "azureSqlVirtualMachine": + err = unpopulate(val, "AzureSQLVirtualMachine", &s.AzureSQLVirtualMachine) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResultsAzureSQLDatabase. +func (s SKURecommendationResultsAzureSQLDatabase) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "monthlyCost", s.MonthlyCost) + populate(objectMap, "numberOfServerBlockerIssues", s.NumberOfServerBlockerIssues) + populate(objectMap, "recommendationStatus", s.RecommendationStatus) + populate(objectMap, "targetSku", s.TargetSKU) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResultsAzureSQLDatabase. +func (s *SKURecommendationResultsAzureSQLDatabase) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "monthlyCost": + err = unpopulate(val, "MonthlyCost", &s.MonthlyCost) + delete(rawMsg, key) + case "numberOfServerBlockerIssues": + err = unpopulate(val, "NumberOfServerBlockerIssues", &s.NumberOfServerBlockerIssues) + delete(rawMsg, key) + case "recommendationStatus": + err = unpopulate(val, "RecommendationStatus", &s.RecommendationStatus) + delete(rawMsg, key) + case "targetSku": + err = unpopulate(val, "TargetSKU", &s.TargetSKU) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResultsAzureSQLDatabaseTargetSKU. +func (s SKURecommendationResultsAzureSQLDatabaseTargetSKU) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "category", s.Category) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResultsAzureSQLDatabaseTargetSKU. +func (s *SKURecommendationResultsAzureSQLDatabaseTargetSKU) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "category": + err = unpopulate(val, "Category", &s.Category) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResultsAzureSQLDatabaseTargetSKUCategory. +func (s SKURecommendationResultsAzureSQLDatabaseTargetSKUCategory) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "computeTier", s.ComputeTier) + populate(objectMap, "hardwareType", s.HardwareType) + populate(objectMap, "sqlPurchasingModel", s.SQLPurchasingModel) + populate(objectMap, "sqlServiceTier", s.SQLServiceTier) + populate(objectMap, "zoneRedundancyAvailable", s.ZoneRedundancyAvailable) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResultsAzureSQLDatabaseTargetSKUCategory. +func (s *SKURecommendationResultsAzureSQLDatabaseTargetSKUCategory) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "computeTier": + err = unpopulate(val, "ComputeTier", &s.ComputeTier) + delete(rawMsg, key) + case "hardwareType": + err = unpopulate(val, "HardwareType", &s.HardwareType) + delete(rawMsg, key) + case "sqlPurchasingModel": + err = unpopulate(val, "SQLPurchasingModel", &s.SQLPurchasingModel) + delete(rawMsg, key) + case "sqlServiceTier": + err = unpopulate(val, "SQLServiceTier", &s.SQLServiceTier) + delete(rawMsg, key) + case "zoneRedundancyAvailable": + err = unpopulate(val, "ZoneRedundancyAvailable", &s.ZoneRedundancyAvailable) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResultsAzureSQLManagedInstance. +func (s SKURecommendationResultsAzureSQLManagedInstance) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "monthlyCost", s.MonthlyCost) + populate(objectMap, "numberOfServerBlockerIssues", s.NumberOfServerBlockerIssues) + populate(objectMap, "recommendationStatus", s.RecommendationStatus) + populate(objectMap, "targetSku", s.TargetSKU) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResultsAzureSQLManagedInstance. +func (s *SKURecommendationResultsAzureSQLManagedInstance) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "monthlyCost": + err = unpopulate(val, "MonthlyCost", &s.MonthlyCost) + delete(rawMsg, key) + case "numberOfServerBlockerIssues": + err = unpopulate(val, "NumberOfServerBlockerIssues", &s.NumberOfServerBlockerIssues) + delete(rawMsg, key) + case "recommendationStatus": + err = unpopulate(val, "RecommendationStatus", &s.RecommendationStatus) + delete(rawMsg, key) + case "targetSku": + err = unpopulate(val, "TargetSKU", &s.TargetSKU) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResultsAzureSQLManagedInstanceTargetSKU. +func (s SKURecommendationResultsAzureSQLManagedInstanceTargetSKU) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "category", s.Category) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResultsAzureSQLManagedInstanceTargetSKU. +func (s *SKURecommendationResultsAzureSQLManagedInstanceTargetSKU) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "category": + err = unpopulate(val, "Category", &s.Category) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResultsAzureSQLManagedInstanceTargetSKUCategory. +func (s SKURecommendationResultsAzureSQLManagedInstanceTargetSKUCategory) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "computeTier", s.ComputeTier) + populate(objectMap, "hardwareType", s.HardwareType) + populate(objectMap, "sqlPurchasingModel", s.SQLPurchasingModel) + populate(objectMap, "sqlServiceTier", s.SQLServiceTier) + populate(objectMap, "zoneRedundancyAvailable", s.ZoneRedundancyAvailable) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResultsAzureSQLManagedInstanceTargetSKUCategory. +func (s *SKURecommendationResultsAzureSQLManagedInstanceTargetSKUCategory) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "computeTier": + err = unpopulate(val, "ComputeTier", &s.ComputeTier) + delete(rawMsg, key) + case "hardwareType": + err = unpopulate(val, "HardwareType", &s.HardwareType) + delete(rawMsg, key) + case "sqlPurchasingModel": + err = unpopulate(val, "SQLPurchasingModel", &s.SQLPurchasingModel) + delete(rawMsg, key) + case "sqlServiceTier": + err = unpopulate(val, "SQLServiceTier", &s.SQLServiceTier) + delete(rawMsg, key) + case "zoneRedundancyAvailable": + err = unpopulate(val, "ZoneRedundancyAvailable", &s.ZoneRedundancyAvailable) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResultsAzureSQLVirtualMachine. +func (s SKURecommendationResultsAzureSQLVirtualMachine) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "monthlyCost", s.MonthlyCost) + populate(objectMap, "numberOfServerBlockerIssues", s.NumberOfServerBlockerIssues) + populate(objectMap, "recommendationStatus", s.RecommendationStatus) + populate(objectMap, "targetSku", s.TargetSKU) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResultsAzureSQLVirtualMachine. +func (s *SKURecommendationResultsAzureSQLVirtualMachine) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "monthlyCost": + err = unpopulate(val, "MonthlyCost", &s.MonthlyCost) + delete(rawMsg, key) + case "numberOfServerBlockerIssues": + err = unpopulate(val, "NumberOfServerBlockerIssues", &s.NumberOfServerBlockerIssues) + delete(rawMsg, key) + case "recommendationStatus": + err = unpopulate(val, "RecommendationStatus", &s.RecommendationStatus) + delete(rawMsg, key) + case "targetSku": + err = unpopulate(val, "TargetSKU", &s.TargetSKU) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResultsAzureSQLVirtualMachineTargetSKU. +func (s SKURecommendationResultsAzureSQLVirtualMachineTargetSKU) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "category", s.Category) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResultsAzureSQLVirtualMachineTargetSKU. +func (s *SKURecommendationResultsAzureSQLVirtualMachineTargetSKU) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "category": + err = unpopulate(val, "Category", &s.Category) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResultsAzureSQLVirtualMachineTargetSKUCategory. +func (s SKURecommendationResultsAzureSQLVirtualMachineTargetSKUCategory) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "availableVmSkus", s.AvailableVMSKUs) + populate(objectMap, "virtualMachineFamily", s.VirtualMachineFamily) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResultsAzureSQLVirtualMachineTargetSKUCategory. +func (s *SKURecommendationResultsAzureSQLVirtualMachineTargetSKUCategory) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "availableVmSkus": + err = unpopulate(val, "AvailableVMSKUs", &s.AvailableVMSKUs) + delete(rawMsg, key) + case "virtualMachineFamily": + err = unpopulate(val, "VirtualMachineFamily", &s.VirtualMachineFamily) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationResultsMonthlyCost. +func (s SKURecommendationResultsMonthlyCost) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "computeCost", s.ComputeCost) + populate(objectMap, "storageCost", s.StorageCost) + populate(objectMap, "totalCost", s.TotalCost) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationResultsMonthlyCost. +func (s *SKURecommendationResultsMonthlyCost) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "computeCost": + err = unpopulate(val, "ComputeCost", &s.ComputeCost) + delete(rawMsg, key) + case "storageCost": + err = unpopulate(val, "StorageCost", &s.StorageCost) + delete(rawMsg, key) + case "totalCost": + err = unpopulate(val, "TotalCost", &s.TotalCost) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURecommendationSummary. +func (s SKURecommendationSummary) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "numOfBlockerIssues", s.NumOfBlockerIssues) + populate(objectMap, "recommendationStatus", s.RecommendationStatus) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURecommendationSummary. +func (s *SKURecommendationSummary) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "numOfBlockerIssues": + err = unpopulate(val, "NumOfBlockerIssues", &s.NumOfBlockerIssues) + delete(rawMsg, key) + case "recommendationStatus": + err = unpopulate(val, "RecommendationStatus", &s.RecommendationStatus) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLAvailabilityGroupDatabaseReplicaResourceProperties. +func (s SQLAvailabilityGroupDatabaseReplicaResourceProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "databaseName", s.DatabaseName) + populate(objectMap, "databaseStateDescription", s.DatabaseStateDescription) + populate(objectMap, "isCommitParticipant", s.IsCommitParticipant) + populate(objectMap, "isLocal", s.IsLocal) + populate(objectMap, "isPrimaryReplica", s.IsPrimaryReplica) + populate(objectMap, "isSuspended", s.IsSuspended) + populate(objectMap, "replicaName", s.ReplicaName) + populate(objectMap, "suspendReasonDescription", s.SuspendReasonDescription) + populate(objectMap, "synchronizationHealthDescription", s.SynchronizationHealthDescription) + populate(objectMap, "synchronizationStateDescription", s.SynchronizationStateDescription) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLAvailabilityGroupDatabaseReplicaResourceProperties. +func (s *SQLAvailabilityGroupDatabaseReplicaResourceProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "databaseName": + err = unpopulate(val, "DatabaseName", &s.DatabaseName) + delete(rawMsg, key) + case "databaseStateDescription": + err = unpopulate(val, "DatabaseStateDescription", &s.DatabaseStateDescription) + delete(rawMsg, key) + case "isCommitParticipant": + err = unpopulate(val, "IsCommitParticipant", &s.IsCommitParticipant) + delete(rawMsg, key) + case "isLocal": + err = unpopulate(val, "IsLocal", &s.IsLocal) + delete(rawMsg, key) + case "isPrimaryReplica": + err = unpopulate(val, "IsPrimaryReplica", &s.IsPrimaryReplica) + delete(rawMsg, key) + case "isSuspended": + err = unpopulate(val, "IsSuspended", &s.IsSuspended) + delete(rawMsg, key) + case "replicaName": + err = unpopulate(val, "ReplicaName", &s.ReplicaName) + delete(rawMsg, key) + case "suspendReasonDescription": + err = unpopulate(val, "SuspendReasonDescription", &s.SuspendReasonDescription) + delete(rawMsg, key) + case "synchronizationHealthDescription": + err = unpopulate(val, "SynchronizationHealthDescription", &s.SynchronizationHealthDescription) + delete(rawMsg, key) + case "synchronizationStateDescription": + err = unpopulate(val, "SynchronizationStateDescription", &s.SynchronizationStateDescription) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLAvailabilityGroupDhcpListenerProperties. +func (s SQLAvailabilityGroupDhcpListenerProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "dnsName", s.DNSName) + populate(objectMap, "mask", s.Mask) + populate(objectMap, "port", s.Port) + populate(objectMap, "subnet", s.Subnet) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLAvailabilityGroupDhcpListenerProperties. +func (s *SQLAvailabilityGroupDhcpListenerProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "dnsName": + err = unpopulate(val, "DNSName", &s.DNSName) + delete(rawMsg, key) + case "mask": + err = unpopulate(val, "Mask", &s.Mask) + delete(rawMsg, key) + case "port": + err = unpopulate(val, "Port", &s.Port) + delete(rawMsg, key) + case "subnet": + err = unpopulate(val, "Subnet", &s.Subnet) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLAvailabilityGroupIPV4AddressesAndMasksPropertiesItem. +func (s SQLAvailabilityGroupIPV4AddressesAndMasksPropertiesItem) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "ipAddress", s.IPAddress) + populate(objectMap, "mask", s.Mask) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLAvailabilityGroupIPV4AddressesAndMasksPropertiesItem. +func (s *SQLAvailabilityGroupIPV4AddressesAndMasksPropertiesItem) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "ipAddress": + err = unpopulate(val, "IPAddress", &s.IPAddress) + delete(rawMsg, key) + case "mask": + err = unpopulate(val, "Mask", &s.Mask) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLAvailabilityGroupReplicaResourceProperties. +func (s SQLAvailabilityGroupReplicaResourceProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "configure", s.Configure) + populate(objectMap, "replicaId", s.ReplicaID) + populate(objectMap, "replicaName", s.ReplicaName) + populate(objectMap, "state", s.State) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLAvailabilityGroupReplicaResourceProperties. +func (s *SQLAvailabilityGroupReplicaResourceProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "configure": + err = unpopulate(val, "Configure", &s.Configure) + delete(rawMsg, key) + case "replicaId": + err = unpopulate(val, "ReplicaID", &s.ReplicaID) + delete(rawMsg, key) + case "replicaName": + err = unpopulate(val, "ReplicaName", &s.ReplicaName) + delete(rawMsg, key) + case "state": + err = unpopulate(val, "State", &s.State) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLAvailabilityGroupStaticIPListenerProperties. +func (s SQLAvailabilityGroupStaticIPListenerProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "dnsName", s.DNSName) + populate(objectMap, "ipV4AddressesAndMasks", s.IPV4AddressesAndMasks) + populate(objectMap, "ipV6Addresses", s.IPV6Addresses) + populate(objectMap, "port", s.Port) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLAvailabilityGroupStaticIPListenerProperties. +func (s *SQLAvailabilityGroupStaticIPListenerProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "dnsName": + err = unpopulate(val, "DNSName", &s.DNSName) + delete(rawMsg, key) + case "ipV4AddressesAndMasks": + err = unpopulate(val, "IPV4AddressesAndMasks", &s.IPV4AddressesAndMasks) + delete(rawMsg, key) + case "ipV6Addresses": + err = unpopulate(val, "IPV6Addresses", &s.IPV6Addresses) + delete(rawMsg, key) + case "port": + err = unpopulate(val, "Port", &s.Port) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstance. +func (s SQLManagedInstance) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "extendedLocation", s.ExtendedLocation) + populate(objectMap, "id", s.ID) + populate(objectMap, "location", s.Location) + populate(objectMap, "name", s.Name) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "sku", s.SKU) + populate(objectMap, "systemData", s.SystemData) + populate(objectMap, "tags", s.Tags) + populate(objectMap, "type", s.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstance. +func (s *SQLManagedInstance) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "extendedLocation": + err = unpopulate(val, "ExtendedLocation", &s.ExtendedLocation) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &s.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &s.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "sku": + err = unpopulate(val, "SKU", &s.SKU) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &s.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &s.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceK8SRaw. +func (s SQLManagedInstanceK8SRaw) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "spec", s.Spec) + if s.AdditionalProperties != nil { + for key, val := range s.AdditionalProperties { + objectMap[key] = val + } + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceK8SRaw. +func (s *SQLManagedInstanceK8SRaw) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "spec": + err = unpopulate(val, "Spec", &s.Spec) + delete(rawMsg, key) + default: + if s.AdditionalProperties == nil { + s.AdditionalProperties = map[string]any{} + } + if val != nil { + var aux any + err = json.Unmarshal(val, &aux) + s.AdditionalProperties[key] = aux + } + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceK8SSpec. +func (s SQLManagedInstanceK8SSpec) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "replicas", s.Replicas) + populate(objectMap, "scheduling", s.Scheduling) + populate(objectMap, "security", s.Security) + populate(objectMap, "settings", s.Settings) + if s.AdditionalProperties != nil { + for key, val := range s.AdditionalProperties { + objectMap[key] = val + } + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceK8SSpec. +func (s *SQLManagedInstanceK8SSpec) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "replicas": + err = unpopulate(val, "Replicas", &s.Replicas) + delete(rawMsg, key) + case "scheduling": + err = unpopulate(val, "Scheduling", &s.Scheduling) + delete(rawMsg, key) + case "security": + err = unpopulate(val, "Security", &s.Security) + delete(rawMsg, key) + case "settings": + err = unpopulate(val, "Settings", &s.Settings) + delete(rawMsg, key) + default: + if s.AdditionalProperties == nil { + s.AdditionalProperties = map[string]any{} + } + if val != nil { + var aux any + err = json.Unmarshal(val, &aux) + s.AdditionalProperties[key] = aux + } + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceListResult. +func (s SQLManagedInstanceListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", s.NextLink) + populate(objectMap, "value", s.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceListResult. +func (s *SQLManagedInstanceListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &s.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &s.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceProperties. +func (s SQLManagedInstanceProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "activeDirectoryInformation", s.ActiveDirectoryInformation) + populate(objectMap, "admin", s.Admin) + populate(objectMap, "basicLoginInformation", s.BasicLoginInformation) + populate(objectMap, "clusterId", s.ClusterID) + populate(objectMap, "dataControllerId", s.DataControllerID) + populate(objectMap, "endTime", s.EndTime) + populate(objectMap, "extensionId", s.ExtensionID) + populate(objectMap, "k8sRaw", s.K8SRaw) + populateDateTimeRFC3339(objectMap, "lastUploadedDate", s.LastUploadedDate) + populate(objectMap, "licenseType", s.LicenseType) + populate(objectMap, "provisioningState", s.ProvisioningState) + populate(objectMap, "startTime", s.StartTime) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceProperties. +func (s *SQLManagedInstanceProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "activeDirectoryInformation": + err = unpopulate(val, "ActiveDirectoryInformation", &s.ActiveDirectoryInformation) + delete(rawMsg, key) + case "admin": + err = unpopulate(val, "Admin", &s.Admin) + delete(rawMsg, key) + case "basicLoginInformation": + err = unpopulate(val, "BasicLoginInformation", &s.BasicLoginInformation) + delete(rawMsg, key) + case "clusterId": + err = unpopulate(val, "ClusterID", &s.ClusterID) + delete(rawMsg, key) + case "dataControllerId": + err = unpopulate(val, "DataControllerID", &s.DataControllerID) + delete(rawMsg, key) + case "endTime": + err = unpopulate(val, "EndTime", &s.EndTime) + delete(rawMsg, key) + case "extensionId": + err = unpopulate(val, "ExtensionID", &s.ExtensionID) + delete(rawMsg, key) + case "k8sRaw": + err = unpopulate(val, "K8SRaw", &s.K8SRaw) + delete(rawMsg, key) + case "lastUploadedDate": + err = unpopulateDateTimeRFC3339(val, "LastUploadedDate", &s.LastUploadedDate) + delete(rawMsg, key) + case "licenseType": + err = unpopulate(val, "LicenseType", &s.LicenseType) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &s.ProvisioningState) + delete(rawMsg, key) + case "startTime": + err = unpopulate(val, "StartTime", &s.StartTime) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceSKU. +func (s SQLManagedInstanceSKU) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "capacity", s.Capacity) + populate(objectMap, "dev", s.Dev) + populate(objectMap, "family", s.Family) + objectMap["name"] = "vCore" + populate(objectMap, "size", s.Size) + populate(objectMap, "tier", s.Tier) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceSKU. +func (s *SQLManagedInstanceSKU) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "capacity": + err = unpopulate(val, "Capacity", &s.Capacity) + delete(rawMsg, key) + case "dev": + err = unpopulate(val, "Dev", &s.Dev) + delete(rawMsg, key) + case "family": + err = unpopulate(val, "Family", &s.Family) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "size": + err = unpopulate(val, "Size", &s.Size) + delete(rawMsg, key) + case "tier": + err = unpopulate(val, "Tier", &s.Tier) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceUpdate. +func (s SQLManagedInstanceUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "tags", s.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceUpdate. +func (s *SQLManagedInstanceUpdate) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerAvailabilityGroupResource. +func (s SQLServerAvailabilityGroupResource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", s.ID) + populate(objectMap, "location", s.Location) + populate(objectMap, "name", s.Name) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "systemData", s.SystemData) + populate(objectMap, "tags", s.Tags) + populate(objectMap, "type", s.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerAvailabilityGroupResource. +func (s *SQLServerAvailabilityGroupResource) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &s.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &s.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &s.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &s.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerAvailabilityGroupResourceProperties. +func (s SQLServerAvailabilityGroupResourceProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "availabilityGroupId", s.AvailabilityGroupID) + populateDateTimeRFC3339(objectMap, "collectionTimestamp", s.CollectionTimestamp) + populate(objectMap, "databases", s.Databases) + populate(objectMap, "info", s.Info) + populate(objectMap, "instanceName", s.InstanceName) + populate(objectMap, "provisioningState", s.ProvisioningState) + populate(objectMap, "replicas", s.Replicas) + populate(objectMap, "serverName", s.ServerName) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerAvailabilityGroupResourceProperties. +func (s *SQLServerAvailabilityGroupResourceProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "availabilityGroupId": + err = unpopulate(val, "AvailabilityGroupID", &s.AvailabilityGroupID) + delete(rawMsg, key) + case "collectionTimestamp": + err = unpopulateDateTimeRFC3339(val, "CollectionTimestamp", &s.CollectionTimestamp) + delete(rawMsg, key) + case "databases": + err = unpopulate(val, "Databases", &s.Databases) + delete(rawMsg, key) + case "info": + err = unpopulate(val, "Info", &s.Info) + delete(rawMsg, key) + case "instanceName": + err = unpopulate(val, "InstanceName", &s.InstanceName) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &s.ProvisioningState) + delete(rawMsg, key) + case "replicas": + err = unpopulate(val, "Replicas", &s.Replicas) + delete(rawMsg, key) + case "serverName": + err = unpopulate(val, "ServerName", &s.ServerName) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerAvailabilityGroupResourcePropertiesDatabases. +func (s SQLServerAvailabilityGroupResourcePropertiesDatabases) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", s.NextLink) + populate(objectMap, "value", s.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerAvailabilityGroupResourcePropertiesDatabases. +func (s *SQLServerAvailabilityGroupResourcePropertiesDatabases) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &s.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &s.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerAvailabilityGroupResourcePropertiesReplicas. +func (s SQLServerAvailabilityGroupResourcePropertiesReplicas) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", s.NextLink) + populate(objectMap, "value", s.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerAvailabilityGroupResourcePropertiesReplicas. +func (s *SQLServerAvailabilityGroupResourcePropertiesReplicas) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &s.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &s.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerAvailabilityGroupUpdate. +func (s SQLServerAvailabilityGroupUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "tags", s.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerAvailabilityGroupUpdate. +func (s *SQLServerAvailabilityGroupUpdate) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerDatabaseResource. +func (s SQLServerDatabaseResource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", s.ID) + populate(objectMap, "location", s.Location) + populate(objectMap, "name", s.Name) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "systemData", s.SystemData) + populate(objectMap, "tags", s.Tags) + populate(objectMap, "type", s.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerDatabaseResource. +func (s *SQLServerDatabaseResource) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &s.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &s.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &s.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &s.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerDatabaseResourceProperties. +func (s SQLServerDatabaseResourceProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "backupInformation", s.BackupInformation) + populate(objectMap, "backupPolicy", s.BackupPolicy) + populate(objectMap, "collationName", s.CollationName) + populate(objectMap, "compatibilityLevel", s.CompatibilityLevel) + populate(objectMap, "createMode", s.CreateMode) + populateDateTimeRFC3339(objectMap, "databaseCreationDate", s.DatabaseCreationDate) + populate(objectMap, "databaseOptions", s.DatabaseOptions) + populateDateTimeRFC3339(objectMap, "earliestRestoreDate", s.EarliestRestoreDate) + populate(objectMap, "isReadOnly", s.IsReadOnly) + populateDateTimeRFC3339(objectMap, "lastDatabaseUploadTime", s.LastDatabaseUploadTime) + populate(objectMap, "migration", s.Migration) + populate(objectMap, "provisioningState", s.ProvisioningState) + populate(objectMap, "recoveryMode", s.RecoveryMode) + populateDateTimeRFC3339(objectMap, "restorePointInTime", s.RestorePointInTime) + populate(objectMap, "sizeMB", s.SizeMB) + populate(objectMap, "sourceDatabaseId", s.SourceDatabaseID) + populate(objectMap, "spaceAvailableMB", s.SpaceAvailableMB) + populate(objectMap, "state", s.State) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerDatabaseResourceProperties. +func (s *SQLServerDatabaseResourceProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "backupInformation": + err = unpopulate(val, "BackupInformation", &s.BackupInformation) + delete(rawMsg, key) + case "backupPolicy": + err = unpopulate(val, "BackupPolicy", &s.BackupPolicy) + delete(rawMsg, key) + case "collationName": + err = unpopulate(val, "CollationName", &s.CollationName) + delete(rawMsg, key) + case "compatibilityLevel": + err = unpopulate(val, "CompatibilityLevel", &s.CompatibilityLevel) + delete(rawMsg, key) + case "createMode": + err = unpopulate(val, "CreateMode", &s.CreateMode) + delete(rawMsg, key) + case "databaseCreationDate": + err = unpopulateDateTimeRFC3339(val, "DatabaseCreationDate", &s.DatabaseCreationDate) + delete(rawMsg, key) + case "databaseOptions": + err = unpopulate(val, "DatabaseOptions", &s.DatabaseOptions) + delete(rawMsg, key) + case "earliestRestoreDate": + err = unpopulateDateTimeRFC3339(val, "EarliestRestoreDate", &s.EarliestRestoreDate) + delete(rawMsg, key) + case "isReadOnly": + err = unpopulate(val, "IsReadOnly", &s.IsReadOnly) + delete(rawMsg, key) + case "lastDatabaseUploadTime": + err = unpopulateDateTimeRFC3339(val, "LastDatabaseUploadTime", &s.LastDatabaseUploadTime) + delete(rawMsg, key) + case "migration": + err = unpopulate(val, "Migration", &s.Migration) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &s.ProvisioningState) + delete(rawMsg, key) + case "recoveryMode": + err = unpopulate(val, "RecoveryMode", &s.RecoveryMode) + delete(rawMsg, key) + case "restorePointInTime": + err = unpopulateDateTimeRFC3339(val, "RestorePointInTime", &s.RestorePointInTime) + delete(rawMsg, key) + case "sizeMB": + err = unpopulate(val, "SizeMB", &s.SizeMB) + delete(rawMsg, key) + case "sourceDatabaseId": + err = unpopulate(val, "SourceDatabaseID", &s.SourceDatabaseID) + delete(rawMsg, key) + case "spaceAvailableMB": + err = unpopulate(val, "SpaceAvailableMB", &s.SpaceAvailableMB) + delete(rawMsg, key) + case "state": + err = unpopulate(val, "State", &s.State) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerDatabaseResourcePropertiesBackupInformation. +func (s SQLServerDatabaseResourcePropertiesBackupInformation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populateDateTimeRFC3339(objectMap, "lastFullBackup", s.LastFullBackup) + populateDateTimeRFC3339(objectMap, "lastLogBackup", s.LastLogBackup) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerDatabaseResourcePropertiesBackupInformation. +func (s *SQLServerDatabaseResourcePropertiesBackupInformation) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "lastFullBackup": + err = unpopulateDateTimeRFC3339(val, "LastFullBackup", &s.LastFullBackup) + delete(rawMsg, key) + case "lastLogBackup": + err = unpopulateDateTimeRFC3339(val, "LastLogBackup", &s.LastLogBackup) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerDatabaseResourcePropertiesDatabaseOptions. +func (s SQLServerDatabaseResourcePropertiesDatabaseOptions) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "isAutoCloseOn", s.IsAutoCloseOn) + populate(objectMap, "isAutoCreateStatsOn", s.IsAutoCreateStatsOn) + populate(objectMap, "isAutoShrinkOn", s.IsAutoShrinkOn) + populate(objectMap, "isAutoUpdateStatsOn", s.IsAutoUpdateStatsOn) + populate(objectMap, "isEncrypted", s.IsEncrypted) + populate(objectMap, "isMemoryOptimizationEnabled", s.IsMemoryOptimizationEnabled) + populate(objectMap, "isRemoteDataArchiveEnabled", s.IsRemoteDataArchiveEnabled) + populate(objectMap, "isTrustworthyOn", s.IsTrustworthyOn) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerDatabaseResourcePropertiesDatabaseOptions. +func (s *SQLServerDatabaseResourcePropertiesDatabaseOptions) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "isAutoCloseOn": + err = unpopulate(val, "IsAutoCloseOn", &s.IsAutoCloseOn) + delete(rawMsg, key) + case "isAutoCreateStatsOn": + err = unpopulate(val, "IsAutoCreateStatsOn", &s.IsAutoCreateStatsOn) + delete(rawMsg, key) + case "isAutoShrinkOn": + err = unpopulate(val, "IsAutoShrinkOn", &s.IsAutoShrinkOn) + delete(rawMsg, key) + case "isAutoUpdateStatsOn": + err = unpopulate(val, "IsAutoUpdateStatsOn", &s.IsAutoUpdateStatsOn) + delete(rawMsg, key) + case "isEncrypted": + err = unpopulate(val, "IsEncrypted", &s.IsEncrypted) + delete(rawMsg, key) + case "isMemoryOptimizationEnabled": + err = unpopulate(val, "IsMemoryOptimizationEnabled", &s.IsMemoryOptimizationEnabled) + delete(rawMsg, key) + case "isRemoteDataArchiveEnabled": + err = unpopulate(val, "IsRemoteDataArchiveEnabled", &s.IsRemoteDataArchiveEnabled) + delete(rawMsg, key) + case "isTrustworthyOn": + err = unpopulate(val, "IsTrustworthyOn", &s.IsTrustworthyOn) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerDatabaseUpdate. +func (s SQLServerDatabaseUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "tags", s.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerDatabaseUpdate. +func (s *SQLServerDatabaseUpdate) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerEsuLicense. +func (s SQLServerEsuLicense) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", s.ID) + populate(objectMap, "location", s.Location) + populate(objectMap, "name", s.Name) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "systemData", s.SystemData) + populate(objectMap, "tags", s.Tags) + populate(objectMap, "type", s.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerEsuLicense. +func (s *SQLServerEsuLicense) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &s.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &s.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &s.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &s.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerEsuLicenseListResult. +func (s SQLServerEsuLicenseListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", s.NextLink) + populate(objectMap, "value", s.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerEsuLicenseListResult. +func (s *SQLServerEsuLicenseListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &s.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &s.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerEsuLicenseProperties. +func (s SQLServerEsuLicenseProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populateDateTimeRFC3339(objectMap, "activatedAt", s.ActivatedAt) + populate(objectMap, "activationState", s.ActivationState) + populate(objectMap, "billingPlan", s.BillingPlan) + populate(objectMap, "physicalCores", s.PhysicalCores) + populate(objectMap, "scopeType", s.ScopeType) + populate(objectMap, "tenantId", s.TenantID) + populateDateTimeRFC3339(objectMap, "terminatedAt", s.TerminatedAt) + populate(objectMap, "uniqueId", s.UniqueID) + populate(objectMap, "version", s.Version) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerEsuLicenseProperties. +func (s *SQLServerEsuLicenseProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "activatedAt": + err = unpopulateDateTimeRFC3339(val, "ActivatedAt", &s.ActivatedAt) + delete(rawMsg, key) + case "activationState": + err = unpopulate(val, "ActivationState", &s.ActivationState) + delete(rawMsg, key) + case "billingPlan": + err = unpopulate(val, "BillingPlan", &s.BillingPlan) + delete(rawMsg, key) + case "physicalCores": + err = unpopulate(val, "PhysicalCores", &s.PhysicalCores) + delete(rawMsg, key) + case "scopeType": + err = unpopulate(val, "ScopeType", &s.ScopeType) + delete(rawMsg, key) + case "tenantId": + err = unpopulate(val, "TenantID", &s.TenantID) + delete(rawMsg, key) + case "terminatedAt": + err = unpopulateDateTimeRFC3339(val, "TerminatedAt", &s.TerminatedAt) + delete(rawMsg, key) + case "uniqueId": + err = unpopulate(val, "UniqueID", &s.UniqueID) + delete(rawMsg, key) + case "version": + err = unpopulate(val, "Version", &s.Version) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerEsuLicenseUpdate. +func (s SQLServerEsuLicenseUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "tags", s.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerEsuLicenseUpdate. +func (s *SQLServerEsuLicenseUpdate) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerEsuLicenseUpdateProperties. +func (s SQLServerEsuLicenseUpdateProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populateDateTimeRFC3339(objectMap, "activatedAt", s.ActivatedAt) + populate(objectMap, "activationState", s.ActivationState) + populate(objectMap, "billingPlan", s.BillingPlan) + populate(objectMap, "physicalCores", s.PhysicalCores) + populate(objectMap, "scopeType", s.ScopeType) + populate(objectMap, "tenantId", s.TenantID) + populateDateTimeRFC3339(objectMap, "terminatedAt", s.TerminatedAt) + populate(objectMap, "uniqueId", s.UniqueID) + populate(objectMap, "version", s.Version) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerEsuLicenseUpdateProperties. +func (s *SQLServerEsuLicenseUpdateProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "activatedAt": + err = unpopulateDateTimeRFC3339(val, "ActivatedAt", &s.ActivatedAt) + delete(rawMsg, key) + case "activationState": + err = unpopulate(val, "ActivationState", &s.ActivationState) + delete(rawMsg, key) + case "billingPlan": + err = unpopulate(val, "BillingPlan", &s.BillingPlan) + delete(rawMsg, key) + case "physicalCores": + err = unpopulate(val, "PhysicalCores", &s.PhysicalCores) + delete(rawMsg, key) + case "scopeType": + err = unpopulate(val, "ScopeType", &s.ScopeType) + delete(rawMsg, key) + case "tenantId": + err = unpopulate(val, "TenantID", &s.TenantID) + delete(rawMsg, key) + case "terminatedAt": + err = unpopulateDateTimeRFC3339(val, "TerminatedAt", &s.TerminatedAt) + delete(rawMsg, key) + case "uniqueId": + err = unpopulate(val, "UniqueID", &s.UniqueID) + delete(rawMsg, key) + case "version": + err = unpopulate(val, "Version", &s.Version) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstance. +func (s SQLServerInstance) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", s.ID) + populate(objectMap, "location", s.Location) + populate(objectMap, "name", s.Name) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "systemData", s.SystemData) + populate(objectMap, "tags", s.Tags) + populate(objectMap, "type", s.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstance. +func (s *SQLServerInstance) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &s.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &s.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &s.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &s.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceJobStatus. +func (s SQLServerInstanceJobStatus) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "backgroundJob", s.BackgroundJob) + populate(objectMap, "id", s.ID) + populate(objectMap, "instanceName", s.InstanceName) + populate(objectMap, "jobException", s.JobException) + populate(objectMap, "jobStatus", s.JobStatus) + populate(objectMap, "sequencerActions", s.SequencerActions) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceJobStatus. +func (s *SQLServerInstanceJobStatus) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "backgroundJob": + err = unpopulate(val, "BackgroundJob", &s.BackgroundJob) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &s.ID) + delete(rawMsg, key) + case "instanceName": + err = unpopulate(val, "InstanceName", &s.InstanceName) + delete(rawMsg, key) + case "jobException": + err = unpopulate(val, "JobException", &s.JobException) + delete(rawMsg, key) + case "jobStatus": + err = unpopulate(val, "JobStatus", &s.JobStatus) + delete(rawMsg, key) + case "sequencerActions": + err = unpopulate(val, "SequencerActions", &s.SequencerActions) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceJobsStatusRequest. +func (s SQLServerInstanceJobsStatusRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "featureName", s.FeatureName) + populate(objectMap, "jobType", s.JobType) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceJobsStatusRequest. +func (s *SQLServerInstanceJobsStatusRequest) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "featureName": + err = unpopulate(val, "FeatureName", &s.FeatureName) + delete(rawMsg, key) + case "jobType": + err = unpopulate(val, "JobType", &s.JobType) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceJobsStatusResponse. +func (s SQLServerInstanceJobsStatusResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "jobsStatus", s.JobsStatus) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceJobsStatusResponse. +func (s *SQLServerInstanceJobsStatusResponse) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "jobsStatus": + err = unpopulate(val, "JobsStatus", &s.JobsStatus) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceListResult. +func (s SQLServerInstanceListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", s.NextLink) + populate(objectMap, "value", s.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceListResult. +func (s *SQLServerInstanceListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &s.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &s.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceProperties. +func (s SQLServerInstanceProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "alwaysOnRole", s.AlwaysOnRole) + populate(objectMap, "azureDefenderStatus", s.AzureDefenderStatus) + populateDateTimeRFC3339(objectMap, "azureDefenderStatusLastUpdated", s.AzureDefenderStatusLastUpdated) + populate(objectMap, "backupPolicy", s.BackupPolicy) + populate(objectMap, "clientConnection", s.ClientConnection) + populate(objectMap, "collation", s.Collation) + populate(objectMap, "containerResourceId", s.ContainerResourceID) + populate(objectMap, "cores", s.Cores) + populate(objectMap, "createTime", s.CreateTime) + populate(objectMap, "currentVersion", s.CurrentVersion) + populate(objectMap, "databaseMirroringEndpoint", s.DatabaseMirroringEndpoint) + populate(objectMap, "dbMasterKeyExists", s.DbMasterKeyExists) + populate(objectMap, "edition", s.Edition) + populate(objectMap, "failoverCluster", s.FailoverCluster) + populate(objectMap, "hostType", s.HostType) + populate(objectMap, "instanceName", s.InstanceName) + populate(objectMap, "isHadrEnabled", s.IsHadrEnabled) + populateDateTimeRFC3339(objectMap, "lastInventoryUploadTime", s.LastInventoryUploadTime) + populateDateTimeRFC3339(objectMap, "lastUsageUploadTime", s.LastUsageUploadTime) + populate(objectMap, "licenseType", s.LicenseType) + populate(objectMap, "migration", s.Migration) + populate(objectMap, "monitoring", s.Monitoring) + populate(objectMap, "patchLevel", s.PatchLevel) + populate(objectMap, "productId", s.ProductID) + populate(objectMap, "provisioningState", s.ProvisioningState) + populate(objectMap, "serviceType", s.ServiceType) + populate(objectMap, "status", s.Status) + populate(objectMap, "tcpDynamicPorts", s.TCPDynamicPorts) + populate(objectMap, "tcpStaticPorts", s.TCPStaticPorts) + populate(objectMap, "traceFlags", s.TraceFlags) + populateDateTimeRFC3339(objectMap, "upgradeLockedUntil", s.UpgradeLockedUntil) + populate(objectMap, "vCore", s.VCore) + populate(objectMap, "version", s.Version) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceProperties. +func (s *SQLServerInstanceProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "alwaysOnRole": + err = unpopulate(val, "AlwaysOnRole", &s.AlwaysOnRole) + delete(rawMsg, key) + case "azureDefenderStatus": + err = unpopulate(val, "AzureDefenderStatus", &s.AzureDefenderStatus) + delete(rawMsg, key) + case "azureDefenderStatusLastUpdated": + err = unpopulateDateTimeRFC3339(val, "AzureDefenderStatusLastUpdated", &s.AzureDefenderStatusLastUpdated) + delete(rawMsg, key) + case "backupPolicy": + err = unpopulate(val, "BackupPolicy", &s.BackupPolicy) + delete(rawMsg, key) + case "clientConnection": + err = unpopulate(val, "ClientConnection", &s.ClientConnection) + delete(rawMsg, key) + case "collation": + err = unpopulate(val, "Collation", &s.Collation) + delete(rawMsg, key) + case "containerResourceId": + err = unpopulate(val, "ContainerResourceID", &s.ContainerResourceID) + delete(rawMsg, key) + case "cores": + err = unpopulate(val, "Cores", &s.Cores) + delete(rawMsg, key) + case "createTime": + err = unpopulate(val, "CreateTime", &s.CreateTime) + delete(rawMsg, key) + case "currentVersion": + err = unpopulate(val, "CurrentVersion", &s.CurrentVersion) + delete(rawMsg, key) + case "databaseMirroringEndpoint": + err = unpopulate(val, "DatabaseMirroringEndpoint", &s.DatabaseMirroringEndpoint) + delete(rawMsg, key) + case "dbMasterKeyExists": + err = unpopulate(val, "DbMasterKeyExists", &s.DbMasterKeyExists) + delete(rawMsg, key) + case "edition": + err = unpopulate(val, "Edition", &s.Edition) + delete(rawMsg, key) + case "failoverCluster": + err = unpopulate(val, "FailoverCluster", &s.FailoverCluster) + delete(rawMsg, key) + case "hostType": + err = unpopulate(val, "HostType", &s.HostType) + delete(rawMsg, key) + case "instanceName": + err = unpopulate(val, "InstanceName", &s.InstanceName) + delete(rawMsg, key) + case "isHadrEnabled": + err = unpopulate(val, "IsHadrEnabled", &s.IsHadrEnabled) + delete(rawMsg, key) + case "lastInventoryUploadTime": + err = unpopulateDateTimeRFC3339(val, "LastInventoryUploadTime", &s.LastInventoryUploadTime) + delete(rawMsg, key) + case "lastUsageUploadTime": + err = unpopulateDateTimeRFC3339(val, "LastUsageUploadTime", &s.LastUsageUploadTime) + delete(rawMsg, key) + case "licenseType": + err = unpopulate(val, "LicenseType", &s.LicenseType) + delete(rawMsg, key) + case "migration": + err = unpopulate(val, "Migration", &s.Migration) + delete(rawMsg, key) + case "monitoring": + err = unpopulate(val, "Monitoring", &s.Monitoring) + delete(rawMsg, key) + case "patchLevel": + err = unpopulate(val, "PatchLevel", &s.PatchLevel) + delete(rawMsg, key) + case "productId": + err = unpopulate(val, "ProductID", &s.ProductID) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &s.ProvisioningState) + delete(rawMsg, key) + case "serviceType": + err = unpopulate(val, "ServiceType", &s.ServiceType) + delete(rawMsg, key) + case "status": + err = unpopulate(val, "Status", &s.Status) + delete(rawMsg, key) + case "tcpDynamicPorts": + err = unpopulate(val, "TCPDynamicPorts", &s.TCPDynamicPorts) + delete(rawMsg, key) + case "tcpStaticPorts": + err = unpopulate(val, "TCPStaticPorts", &s.TCPStaticPorts) + delete(rawMsg, key) + case "traceFlags": + err = unpopulate(val, "TraceFlags", &s.TraceFlags) + delete(rawMsg, key) + case "upgradeLockedUntil": + err = unpopulateDateTimeRFC3339(val, "UpgradeLockedUntil", &s.UpgradeLockedUntil) + delete(rawMsg, key) + case "vCore": + err = unpopulate(val, "VCore", &s.VCore) + delete(rawMsg, key) + case "version": + err = unpopulate(val, "Version", &s.Version) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceRunMigrationAssessmentResponse. +func (s SQLServerInstanceRunMigrationAssessmentResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "backgroundJob", s.BackgroundJob) + populate(objectMap, "id", s.ID) + populate(objectMap, "instanceName", s.InstanceName) + populate(objectMap, "jobException", s.JobException) + populate(objectMap, "jobStatus", s.JobStatus) + populate(objectMap, "sequencerActions", s.SequencerActions) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceRunMigrationAssessmentResponse. +func (s *SQLServerInstanceRunMigrationAssessmentResponse) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "backgroundJob": + err = unpopulate(val, "BackgroundJob", &s.BackgroundJob) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &s.ID) + delete(rawMsg, key) + case "instanceName": + err = unpopulate(val, "InstanceName", &s.InstanceName) + delete(rawMsg, key) + case "jobException": + err = unpopulate(val, "JobException", &s.JobException) + delete(rawMsg, key) + case "jobStatus": + err = unpopulate(val, "JobStatus", &s.JobStatus) + delete(rawMsg, key) + case "sequencerActions": + err = unpopulate(val, "SequencerActions", &s.SequencerActions) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceTelemetryColumn. +func (s SQLServerInstanceTelemetryColumn) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "name", s.Name) + populate(objectMap, "type", s.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceTelemetryColumn. +func (s *SQLServerInstanceTelemetryColumn) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &s.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceTelemetryRequest. +func (s SQLServerInstanceTelemetryRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "aggregationType", s.AggregationType) + populate(objectMap, "databaseNames", s.DatabaseNames) + populate(objectMap, "datasetName", s.DatasetName) + populateDateTimeRFC3339(objectMap, "endTime", s.EndTime) + populate(objectMap, "interval", s.Interval) + populateDateTimeRFC3339(objectMap, "startTime", s.StartTime) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceTelemetryRequest. +func (s *SQLServerInstanceTelemetryRequest) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "aggregationType": + err = unpopulate(val, "AggregationType", &s.AggregationType) + delete(rawMsg, key) + case "databaseNames": + err = unpopulate(val, "DatabaseNames", &s.DatabaseNames) + delete(rawMsg, key) + case "datasetName": + err = unpopulate(val, "DatasetName", &s.DatasetName) + delete(rawMsg, key) + case "endTime": + err = unpopulateDateTimeRFC3339(val, "EndTime", &s.EndTime) + delete(rawMsg, key) + case "interval": + err = unpopulate(val, "Interval", &s.Interval) + delete(rawMsg, key) + case "startTime": + err = unpopulateDateTimeRFC3339(val, "StartTime", &s.StartTime) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceTelemetryResponse. +func (s SQLServerInstanceTelemetryResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "columns", s.Columns) + populate(objectMap, "nextLink", s.NextLink) + populate(objectMap, "rows", s.Rows) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceTelemetryResponse. +func (s *SQLServerInstanceTelemetryResponse) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "columns": + err = unpopulate(val, "Columns", &s.Columns) + delete(rawMsg, key) + case "nextLink": + err = unpopulate(val, "NextLink", &s.NextLink) + delete(rawMsg, key) + case "rows": + err = unpopulate(val, "Rows", &s.Rows) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceUpdate. +func (s SQLServerInstanceUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "tags", s.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceUpdate. +func (s *SQLServerInstanceUpdate) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceUpdateProperties. +func (s SQLServerInstanceUpdateProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "alwaysOnRole", s.AlwaysOnRole) + populate(objectMap, "azureDefenderStatus", s.AzureDefenderStatus) + populateDateTimeRFC3339(objectMap, "azureDefenderStatusLastUpdated", s.AzureDefenderStatusLastUpdated) + populate(objectMap, "backupPolicy", s.BackupPolicy) + populate(objectMap, "clientConnection", s.ClientConnection) + populate(objectMap, "collation", s.Collation) + populate(objectMap, "containerResourceId", s.ContainerResourceID) + populate(objectMap, "cores", s.Cores) + populate(objectMap, "createTime", s.CreateTime) + populate(objectMap, "currentVersion", s.CurrentVersion) + populate(objectMap, "dbMasterKeyExists", s.DbMasterKeyExists) + populate(objectMap, "edition", s.Edition) + populate(objectMap, "failoverCluster", s.FailoverCluster) + populate(objectMap, "hostType", s.HostType) + populate(objectMap, "instanceName", s.InstanceName) + populate(objectMap, "isHadrEnabled", s.IsHadrEnabled) + populateDateTimeRFC3339(objectMap, "lastInventoryUploadTime", s.LastInventoryUploadTime) + populateDateTimeRFC3339(objectMap, "lastUsageUploadTime", s.LastUsageUploadTime) + populate(objectMap, "licenseType", s.LicenseType) + populate(objectMap, "migration", s.Migration) + populate(objectMap, "monitoring", s.Monitoring) + populate(objectMap, "patchLevel", s.PatchLevel) + populate(objectMap, "productId", s.ProductID) + populate(objectMap, "provisioningState", s.ProvisioningState) + populate(objectMap, "serviceType", s.ServiceType) + populate(objectMap, "status", s.Status) + populate(objectMap, "tcpDynamicPorts", s.TCPDynamicPorts) + populate(objectMap, "tcpStaticPorts", s.TCPStaticPorts) + populate(objectMap, "traceFlags", s.TraceFlags) + populateDateTimeRFC3339(objectMap, "upgradeLockedUntil", s.UpgradeLockedUntil) + populate(objectMap, "vCore", s.VCore) + populate(objectMap, "version", s.Version) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceUpdateProperties. +func (s *SQLServerInstanceUpdateProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "alwaysOnRole": + err = unpopulate(val, "AlwaysOnRole", &s.AlwaysOnRole) + delete(rawMsg, key) + case "azureDefenderStatus": + err = unpopulate(val, "AzureDefenderStatus", &s.AzureDefenderStatus) + delete(rawMsg, key) + case "azureDefenderStatusLastUpdated": + err = unpopulateDateTimeRFC3339(val, "AzureDefenderStatusLastUpdated", &s.AzureDefenderStatusLastUpdated) + delete(rawMsg, key) + case "backupPolicy": + err = unpopulate(val, "BackupPolicy", &s.BackupPolicy) + delete(rawMsg, key) + case "clientConnection": + err = unpopulate(val, "ClientConnection", &s.ClientConnection) + delete(rawMsg, key) + case "collation": + err = unpopulate(val, "Collation", &s.Collation) + delete(rawMsg, key) + case "containerResourceId": + err = unpopulate(val, "ContainerResourceID", &s.ContainerResourceID) + delete(rawMsg, key) + case "cores": + err = unpopulate(val, "Cores", &s.Cores) + delete(rawMsg, key) + case "createTime": + err = unpopulate(val, "CreateTime", &s.CreateTime) + delete(rawMsg, key) + case "currentVersion": + err = unpopulate(val, "CurrentVersion", &s.CurrentVersion) + delete(rawMsg, key) + case "dbMasterKeyExists": + err = unpopulate(val, "DbMasterKeyExists", &s.DbMasterKeyExists) + delete(rawMsg, key) + case "edition": + err = unpopulate(val, "Edition", &s.Edition) + delete(rawMsg, key) + case "failoverCluster": + err = unpopulate(val, "FailoverCluster", &s.FailoverCluster) + delete(rawMsg, key) + case "hostType": + err = unpopulate(val, "HostType", &s.HostType) + delete(rawMsg, key) + case "instanceName": + err = unpopulate(val, "InstanceName", &s.InstanceName) + delete(rawMsg, key) + case "isHadrEnabled": + err = unpopulate(val, "IsHadrEnabled", &s.IsHadrEnabled) + delete(rawMsg, key) + case "lastInventoryUploadTime": + err = unpopulateDateTimeRFC3339(val, "LastInventoryUploadTime", &s.LastInventoryUploadTime) + delete(rawMsg, key) + case "lastUsageUploadTime": + err = unpopulateDateTimeRFC3339(val, "LastUsageUploadTime", &s.LastUsageUploadTime) + delete(rawMsg, key) + case "licenseType": + err = unpopulate(val, "LicenseType", &s.LicenseType) + delete(rawMsg, key) + case "migration": + err = unpopulate(val, "Migration", &s.Migration) + delete(rawMsg, key) + case "monitoring": + err = unpopulate(val, "Monitoring", &s.Monitoring) + delete(rawMsg, key) + case "patchLevel": + err = unpopulate(val, "PatchLevel", &s.PatchLevel) + delete(rawMsg, key) + case "productId": + err = unpopulate(val, "ProductID", &s.ProductID) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &s.ProvisioningState) + delete(rawMsg, key) + case "serviceType": + err = unpopulate(val, "ServiceType", &s.ServiceType) + delete(rawMsg, key) + case "status": + err = unpopulate(val, "Status", &s.Status) + delete(rawMsg, key) + case "tcpDynamicPorts": + err = unpopulate(val, "TCPDynamicPorts", &s.TCPDynamicPorts) + delete(rawMsg, key) + case "tcpStaticPorts": + err = unpopulate(val, "TCPStaticPorts", &s.TCPStaticPorts) + delete(rawMsg, key) + case "traceFlags": + err = unpopulate(val, "TraceFlags", &s.TraceFlags) + delete(rawMsg, key) + case "upgradeLockedUntil": + err = unpopulateDateTimeRFC3339(val, "UpgradeLockedUntil", &s.UpgradeLockedUntil) + delete(rawMsg, key) + case "vCore": + err = unpopulate(val, "VCore", &s.VCore) + delete(rawMsg, key) + case "version": + err = unpopulate(val, "Version", &s.Version) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerLicense. +func (s SQLServerLicense) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", s.ID) + populate(objectMap, "location", s.Location) + populate(objectMap, "name", s.Name) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "systemData", s.SystemData) + populate(objectMap, "tags", s.Tags) + populate(objectMap, "type", s.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerLicense. +func (s *SQLServerLicense) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &s.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &s.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &s.SystemData) delete(rawMsg, key) - case "licenseType": - err = unpopulate(val, "LicenseType", &s.LicenseType) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) delete(rawMsg, key) - case "provisioningState": - err = unpopulate(val, "ProvisioningState", &s.ProvisioningState) + case "type": + err = unpopulate(val, "Type", &s.Type) delete(rawMsg, key) - case "startTime": - err = unpopulate(val, "StartTime", &s.StartTime) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SQLServerLicenseListResult. +func (s SQLServerLicenseListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", s.NextLink) + populate(objectMap, "value", s.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerLicenseListResult. +func (s *SQLServerLicenseListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &s.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &s.Value) delete(rawMsg, key) } if err != nil { @@ -1617,20 +5287,22 @@ func (s *SQLManagedInstanceProperties) UnmarshalJSON(data []byte) error { return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceSKU. -func (s SQLManagedInstanceSKU) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type SQLServerLicenseProperties. +func (s SQLServerLicenseProperties) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "capacity", s.Capacity) - populate(objectMap, "dev", s.Dev) - populate(objectMap, "family", s.Family) - objectMap["name"] = "vCore" - populate(objectMap, "size", s.Size) - populate(objectMap, "tier", s.Tier) + populate(objectMap, "activationState", s.ActivationState) + populate(objectMap, "billingPlan", s.BillingPlan) + populateDateTimeRFC3339(objectMap, "lastActivatedAt", s.LastActivatedAt) + populateDateTimeRFC3339(objectMap, "lastDeactivatedAt", s.LastDeactivatedAt) + populate(objectMap, "licenseCategory", s.LicenseCategory) + populate(objectMap, "physicalCores", s.PhysicalCores) + populate(objectMap, "scopeType", s.ScopeType) + populate(objectMap, "tenantId", s.TenantID) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceSKU. -func (s *SQLManagedInstanceSKU) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerLicenseProperties. +func (s *SQLServerLicenseProperties) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { return fmt.Errorf("unmarshalling type %T: %v", s, err) @@ -1638,23 +5310,29 @@ func (s *SQLManagedInstanceSKU) UnmarshalJSON(data []byte) error { for key, val := range rawMsg { var err error switch key { - case "capacity": - err = unpopulate(val, "Capacity", &s.Capacity) + case "activationState": + err = unpopulate(val, "ActivationState", &s.ActivationState) delete(rawMsg, key) - case "dev": - err = unpopulate(val, "Dev", &s.Dev) + case "billingPlan": + err = unpopulate(val, "BillingPlan", &s.BillingPlan) delete(rawMsg, key) - case "family": - err = unpopulate(val, "Family", &s.Family) + case "lastActivatedAt": + err = unpopulateDateTimeRFC3339(val, "LastActivatedAt", &s.LastActivatedAt) delete(rawMsg, key) - case "name": - err = unpopulate(val, "Name", &s.Name) + case "lastDeactivatedAt": + err = unpopulateDateTimeRFC3339(val, "LastDeactivatedAt", &s.LastDeactivatedAt) delete(rawMsg, key) - case "size": - err = unpopulate(val, "Size", &s.Size) + case "licenseCategory": + err = unpopulate(val, "LicenseCategory", &s.LicenseCategory) delete(rawMsg, key) - case "tier": - err = unpopulate(val, "Tier", &s.Tier) + case "physicalCores": + err = unpopulate(val, "PhysicalCores", &s.PhysicalCores) + delete(rawMsg, key) + case "scopeType": + err = unpopulate(val, "ScopeType", &s.ScopeType) + delete(rawMsg, key) + case "tenantId": + err = unpopulate(val, "TenantID", &s.TenantID) delete(rawMsg, key) } if err != nil { @@ -1664,15 +5342,16 @@ func (s *SQLManagedInstanceSKU) UnmarshalJSON(data []byte) error { return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLManagedInstanceUpdate. -func (s SQLManagedInstanceUpdate) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type SQLServerLicenseUpdate. +func (s SQLServerLicenseUpdate) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) + populate(objectMap, "properties", s.Properties) populate(objectMap, "tags", s.Tags) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLManagedInstanceUpdate. -func (s *SQLManagedInstanceUpdate) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerLicenseUpdate. +func (s *SQLServerLicenseUpdate) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { return fmt.Errorf("unmarshalling type %T: %v", s, err) @@ -1680,6 +5359,9 @@ func (s *SQLManagedInstanceUpdate) UnmarshalJSON(data []byte) error { for key, val := range rawMsg { var err error switch key { + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) case "tags": err = unpopulate(val, "Tags", &s.Tags) delete(rawMsg, key) @@ -1691,21 +5373,22 @@ func (s *SQLManagedInstanceUpdate) UnmarshalJSON(data []byte) error { return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLServerInstance. -func (s SQLServerInstance) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type SQLServerLicenseUpdateProperties. +func (s SQLServerLicenseUpdateProperties) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "id", s.ID) - populate(objectMap, "location", s.Location) - populate(objectMap, "name", s.Name) - populate(objectMap, "properties", s.Properties) - populate(objectMap, "systemData", s.SystemData) - populate(objectMap, "tags", s.Tags) - populate(objectMap, "type", s.Type) + populate(objectMap, "activationState", s.ActivationState) + populate(objectMap, "billingPlan", s.BillingPlan) + populateDateTimeRFC3339(objectMap, "lastActivatedAt", s.LastActivatedAt) + populateDateTimeRFC3339(objectMap, "lastDeactivatedAt", s.LastDeactivatedAt) + populate(objectMap, "licenseCategory", s.LicenseCategory) + populate(objectMap, "physicalCores", s.PhysicalCores) + populate(objectMap, "scopeType", s.ScopeType) + populate(objectMap, "tenantId", s.TenantID) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstance. -func (s *SQLServerInstance) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerLicenseUpdateProperties. +func (s *SQLServerLicenseUpdateProperties) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { return fmt.Errorf("unmarshalling type %T: %v", s, err) @@ -1713,26 +5396,29 @@ func (s *SQLServerInstance) UnmarshalJSON(data []byte) error { for key, val := range rawMsg { var err error switch key { - case "id": - err = unpopulate(val, "ID", &s.ID) + case "activationState": + err = unpopulate(val, "ActivationState", &s.ActivationState) delete(rawMsg, key) - case "location": - err = unpopulate(val, "Location", &s.Location) + case "billingPlan": + err = unpopulate(val, "BillingPlan", &s.BillingPlan) delete(rawMsg, key) - case "name": - err = unpopulate(val, "Name", &s.Name) + case "lastActivatedAt": + err = unpopulateDateTimeRFC3339(val, "LastActivatedAt", &s.LastActivatedAt) delete(rawMsg, key) - case "properties": - err = unpopulate(val, "Properties", &s.Properties) + case "lastDeactivatedAt": + err = unpopulateDateTimeRFC3339(val, "LastDeactivatedAt", &s.LastDeactivatedAt) delete(rawMsg, key) - case "systemData": - err = unpopulate(val, "SystemData", &s.SystemData) + case "licenseCategory": + err = unpopulate(val, "LicenseCategory", &s.LicenseCategory) delete(rawMsg, key) - case "tags": - err = unpopulate(val, "Tags", &s.Tags) + case "physicalCores": + err = unpopulate(val, "PhysicalCores", &s.PhysicalCores) delete(rawMsg, key) - case "type": - err = unpopulate(val, "Type", &s.Type) + case "scopeType": + err = unpopulate(val, "ScopeType", &s.ScopeType) + delete(rawMsg, key) + case "tenantId": + err = unpopulate(val, "TenantID", &s.TenantID) delete(rawMsg, key) } if err != nil { @@ -1742,16 +5428,17 @@ func (s *SQLServerInstance) UnmarshalJSON(data []byte) error { return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceListResult. -func (s SQLServerInstanceListResult) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type SequencerAction. +func (s SequencerAction) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "nextLink", s.NextLink) - populate(objectMap, "value", s.Value) + populate(objectMap, "actionId", s.ActionID) + populate(objectMap, "result", s.Result) + populate(objectMap, "state", s.State) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceListResult. -func (s *SQLServerInstanceListResult) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type SequencerAction. +func (s *SequencerAction) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { return fmt.Errorf("unmarshalling type %T: %v", s, err) @@ -1759,11 +5446,14 @@ func (s *SQLServerInstanceListResult) UnmarshalJSON(data []byte) error { for key, val := range rawMsg { var err error switch key { - case "nextLink": - err = unpopulate(val, "NextLink", &s.NextLink) + case "actionId": + err = unpopulate(val, "ActionID", &s.ActionID) delete(rawMsg, key) - case "value": - err = unpopulate(val, "Value", &s.Value) + case "result": + err = unpopulate(val, "Result", &s.Result) + delete(rawMsg, key) + case "state": + err = unpopulate(val, "State", &s.State) delete(rawMsg, key) } if err != nil { @@ -1773,32 +5463,19 @@ func (s *SQLServerInstanceListResult) UnmarshalJSON(data []byte) error { return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceProperties. -func (s SQLServerInstanceProperties) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type ServerAssessmentsItem. +func (s ServerAssessmentsItem) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "azureDefenderStatus", s.AzureDefenderStatus) - populateDateTimeRFC3339(objectMap, "azureDefenderStatusLastUpdated", s.AzureDefenderStatusLastUpdated) - populate(objectMap, "collation", s.Collation) - populate(objectMap, "containerResourceId", s.ContainerResourceID) - populate(objectMap, "createTime", s.CreateTime) - populate(objectMap, "currentVersion", s.CurrentVersion) - populate(objectMap, "edition", s.Edition) - populate(objectMap, "hostType", s.HostType) - populate(objectMap, "instanceName", s.InstanceName) - populate(objectMap, "licenseType", s.LicenseType) - populate(objectMap, "patchLevel", s.PatchLevel) - populate(objectMap, "productId", s.ProductID) - populate(objectMap, "provisioningState", s.ProvisioningState) - populate(objectMap, "status", s.Status) - populate(objectMap, "tcpDynamicPorts", s.TCPDynamicPorts) - populate(objectMap, "tcpStaticPorts", s.TCPStaticPorts) - populate(objectMap, "vCore", s.VCore) - populate(objectMap, "version", s.Version) + populate(objectMap, "appliesToMigrationTargetPlatform", s.AppliesToMigrationTargetPlatform) + populate(objectMap, "featureId", s.FeatureID) + populate(objectMap, "impactedObjects", s.ImpactedObjects) + populate(objectMap, "issueCategory", s.IssueCategory) + populate(objectMap, "moreInformation", s.MoreInformation) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceProperties. -func (s *SQLServerInstanceProperties) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type ServerAssessmentsItem. +func (s *ServerAssessmentsItem) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { return fmt.Errorf("unmarshalling type %T: %v", s, err) @@ -1806,59 +5483,20 @@ func (s *SQLServerInstanceProperties) UnmarshalJSON(data []byte) error { for key, val := range rawMsg { var err error switch key { - case "azureDefenderStatus": - err = unpopulate(val, "AzureDefenderStatus", &s.AzureDefenderStatus) - delete(rawMsg, key) - case "azureDefenderStatusLastUpdated": - err = unpopulateDateTimeRFC3339(val, "AzureDefenderStatusLastUpdated", &s.AzureDefenderStatusLastUpdated) - delete(rawMsg, key) - case "collation": - err = unpopulate(val, "Collation", &s.Collation) - delete(rawMsg, key) - case "containerResourceId": - err = unpopulate(val, "ContainerResourceID", &s.ContainerResourceID) - delete(rawMsg, key) - case "createTime": - err = unpopulate(val, "CreateTime", &s.CreateTime) - delete(rawMsg, key) - case "currentVersion": - err = unpopulate(val, "CurrentVersion", &s.CurrentVersion) - delete(rawMsg, key) - case "edition": - err = unpopulate(val, "Edition", &s.Edition) - delete(rawMsg, key) - case "hostType": - err = unpopulate(val, "HostType", &s.HostType) - delete(rawMsg, key) - case "instanceName": - err = unpopulate(val, "InstanceName", &s.InstanceName) - delete(rawMsg, key) - case "licenseType": - err = unpopulate(val, "LicenseType", &s.LicenseType) - delete(rawMsg, key) - case "patchLevel": - err = unpopulate(val, "PatchLevel", &s.PatchLevel) - delete(rawMsg, key) - case "productId": - err = unpopulate(val, "ProductID", &s.ProductID) - delete(rawMsg, key) - case "provisioningState": - err = unpopulate(val, "ProvisioningState", &s.ProvisioningState) + case "appliesToMigrationTargetPlatform": + err = unpopulate(val, "AppliesToMigrationTargetPlatform", &s.AppliesToMigrationTargetPlatform) delete(rawMsg, key) - case "status": - err = unpopulate(val, "Status", &s.Status) - delete(rawMsg, key) - case "tcpDynamicPorts": - err = unpopulate(val, "TCPDynamicPorts", &s.TCPDynamicPorts) + case "featureId": + err = unpopulate(val, "FeatureID", &s.FeatureID) delete(rawMsg, key) - case "tcpStaticPorts": - err = unpopulate(val, "TCPStaticPorts", &s.TCPStaticPorts) + case "impactedObjects": + err = unpopulate(val, "ImpactedObjects", &s.ImpactedObjects) delete(rawMsg, key) - case "vCore": - err = unpopulate(val, "VCore", &s.VCore) + case "issueCategory": + err = unpopulate(val, "IssueCategory", &s.IssueCategory) delete(rawMsg, key) - case "version": - err = unpopulate(val, "Version", &s.Version) + case "moreInformation": + err = unpopulate(val, "MoreInformation", &s.MoreInformation) delete(rawMsg, key) } if err != nil { @@ -1868,15 +5506,17 @@ func (s *SQLServerInstanceProperties) UnmarshalJSON(data []byte) error { return nil } -// MarshalJSON implements the json.Marshaller interface for type SQLServerInstanceUpdate. -func (s SQLServerInstanceUpdate) MarshalJSON() ([]byte, error) { +// MarshalJSON implements the json.Marshaller interface for type ServerAssessmentsPropertiesItemsItem. +func (s ServerAssessmentsPropertiesItemsItem) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) - populate(objectMap, "tags", s.Tags) + populate(objectMap, "impactDetail", s.ImpactDetail) + populate(objectMap, "name", s.Name) + populate(objectMap, "objectType", s.ObjectType) return json.Marshal(objectMap) } -// UnmarshalJSON implements the json.Unmarshaller interface for type SQLServerInstanceUpdate. -func (s *SQLServerInstanceUpdate) UnmarshalJSON(data []byte) error { +// UnmarshalJSON implements the json.Unmarshaller interface for type ServerAssessmentsPropertiesItemsItem. +func (s *ServerAssessmentsPropertiesItemsItem) UnmarshalJSON(data []byte) error { var rawMsg map[string]json.RawMessage if err := json.Unmarshal(data, &rawMsg); err != nil { return fmt.Errorf("unmarshalling type %T: %v", s, err) @@ -1884,8 +5524,14 @@ func (s *SQLServerInstanceUpdate) UnmarshalJSON(data []byte) error { for key, val := range rawMsg { var err error switch key { - case "tags": - err = unpopulate(val, "Tags", &s.Tags) + case "impactDetail": + err = unpopulate(val, "ImpactDetail", &s.ImpactDetail) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "objectType": + err = unpopulate(val, "ObjectType", &s.ObjectType) delete(rawMsg, key) } if err != nil { @@ -1942,6 +5588,41 @@ func (s *SystemData) UnmarshalJSON(data []byte) error { return nil } +// MarshalJSON implements the json.Marshaller interface for type TargetReadiness. +func (t TargetReadiness) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "azureSqlDatabase", t.AzureSQLDatabase) + populate(objectMap, "azureSqlManagedInstance", t.AzureSQLManagedInstance) + populate(objectMap, "azureSqlVirtualMachine", t.AzureSQLVirtualMachine) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type TargetReadiness. +func (t *TargetReadiness) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", t, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "azureSqlDatabase": + err = unpopulate(val, "AzureSQLDatabase", &t.AzureSQLDatabase) + delete(rawMsg, key) + case "azureSqlManagedInstance": + err = unpopulate(val, "AzureSQLManagedInstance", &t.AzureSQLManagedInstance) + delete(rawMsg, key) + case "azureSqlVirtualMachine": + err = unpopulate(val, "AzureSQLVirtualMachine", &t.AzureSQLVirtualMachine) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", t, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type TrackedResource. func (t TrackedResource) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) @@ -1989,6 +5670,53 @@ func (t *TrackedResource) UnmarshalJSON(data []byte) error { return nil } +// MarshalJSON implements the json.Marshaller interface for type TrackedResourceAutoGenerated. +func (t TrackedResourceAutoGenerated) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", t.ID) + populate(objectMap, "location", t.Location) + populate(objectMap, "name", t.Name) + populate(objectMap, "systemData", t.SystemData) + populate(objectMap, "tags", t.Tags) + populate(objectMap, "type", t.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type TrackedResourceAutoGenerated. +func (t *TrackedResourceAutoGenerated) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", t, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &t.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &t.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &t.Name) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &t.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &t.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &t.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", t, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type UploadServicePrincipal. func (u UploadServicePrincipal) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) @@ -2084,7 +5812,7 @@ func populateAny(m map[string]any, k string, v any) { } func unpopulate(data json.RawMessage, fn string, v any) error { - if data == nil { + if data == nil || string(data) == "null" { return nil } if err := json.Unmarshal(data, v); err != nil { diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/operations_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/operations_client.go index 44cd308e7af7..22567f9ae00c 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/operations_client.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/operations_client.go @@ -39,7 +39,7 @@ func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientO // NewListPager - Lists all of the available Azure Data Services on Azure Arc API operations. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method. func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse] { return runtime.NewPager(runtime.PagingHandler[OperationsClientListResponse]{ @@ -72,7 +72,7 @@ func (client *OperationsClient) listCreateRequest(ctx context.Context, options * return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/operations_client_example_test.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/operations_client_example_test.go deleted file mode 100644 index 2f9d2e6d0733..000000000000 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/operations_client_example_test.go +++ /dev/null @@ -1,346 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armazurearcdata_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/ListOperation.json -func ExampleOperationsClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewOperationsClient().NewListPager(nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.OperationListResult = armazurearcdata.OperationListResult{ - // Value: []*armazurearcdata.Operation{ - // { - // Name: to.Ptr("Microsoft.AzureArcData/Locations/OperationStatuses/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("read OperationStatuses"), - // Operation: to.Ptr("read_OperationStatuses"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("Locations/OperationStatuses"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/Locations/OperationStatuses/write"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("write OperationStatuses"), - // Operation: to.Ptr("write_OperationStatuses"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("Locations/OperationStatuses"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/dataControllers/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("read dataControllers"), - // Operation: to.Ptr("DataControllers_ListInSubscription"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("dataControllers"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/dataControllers/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("read dataControllers"), - // Operation: to.Ptr("DataControllers_ListInGroup"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("dataControllers"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/dataControllers/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Retrieves a dataController resource"), - // Operation: to.Ptr("DataControllers_GetDataController"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("dataControllers"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/dataControllers/write"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Creates or replaces a dataController resource"), - // Operation: to.Ptr("DataControllers_PutDataController"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("dataControllers"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/dataControllers/delete"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Deletes a dataController resource"), - // Operation: to.Ptr("DataControllers_DeleteDataController"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("dataControllers"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/dataControllers/write"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Updates a dataController resource"), - // Operation: to.Ptr("DataControllers_PatchDataController"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("dataControllers"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("read sqlManagedInstances"), - // Operation: to.Ptr("SqlManagedInstances_List"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlManagedInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Gets all sqlManagedInstances in a resource group."), - // Operation: to.Ptr("SqlManagedInstances_ListByResourceGroup"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlManagedInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Retrieves a SQL Managed Instance resource"), - // Operation: to.Ptr("SqlManagedInstances_Get"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlManagedInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances/write"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Creates or replaces a SQL Managed Instance resource"), - // Operation: to.Ptr("SqlManagedInstances_Create"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlManagedInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances/delete"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Deletes a SQL Managed Instance resource"), - // Operation: to.Ptr("SqlManagedInstances_Delete"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlManagedInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances/write"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Updates a SQL Managed Instance resource"), - // Operation: to.Ptr("SqlManagedInstances_Update"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlManagedInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlServerInstances/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("read sqlServerInstances"), - // Operation: to.Ptr("SqlServerInstances_List"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlServerInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlServerInstances/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Gets all sqlServerInstances in a resource group."), - // Operation: to.Ptr("SqlServerInstances_ListByResourceGroup"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlServerInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlServerInstances/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Retrieves a SQL Server Instance resource"), - // Operation: to.Ptr("SqlServerInstances_Get"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlServerInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlServerInstances/write"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Creates or replaces a SQL Server Instance resource"), - // Operation: to.Ptr("SqlServerInstances_Create"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlServerInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlServerInstances/delete"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Deletes a SQL Server Instance resource"), - // Operation: to.Ptr("SqlServerInstances_Delete"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlServerInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/sqlServerInstances/write"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Updates a SQL Server Instance resource"), - // Operation: to.Ptr("SqlServerInstances_Update"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("sqlServerInstances"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/dataControllers/activeDirectoryConnectors/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("read activeDirectoryConnectors"), - // Operation: to.Ptr("ActiveDirectoryConnectors_List"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("dataControllers/activeDirectoryConnectors"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/dataControllers/activeDirectoryConnectors/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Retrieves an active directory connector resource"), - // Operation: to.Ptr("ActiveDirectoryConnectors_Get"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("dataControllers/activeDirectoryConnectors"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/dataControllers/activeDirectoryConnectors/write"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Creates or replaces an active directory connector resource."), - // Operation: to.Ptr("ActiveDirectoryConnectors_Create"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("dataControllers/activeDirectoryConnectors"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/dataControllers/activeDirectoryConnectors/delete"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Deletes an active directory connector resource"), - // Operation: to.Ptr("ActiveDirectoryConnectors_Delete"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("dataControllers/activeDirectoryConnectors"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/postgresInstances/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Retrieves details of Postgres Instances."), - // Operation: to.Ptr("Get Postgres Instance details."), - // Provider: to.Ptr("Azure Arc Data Resource Provider."), - // Resource: to.Ptr("Microsoft.AzureArcData"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/postgresInstances/write"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Create a new or change properties of existing Postgres Instances."), - // Operation: to.Ptr("Create new or update existing Postgres Instances."), - // Provider: to.Ptr("Azure Arc Data Resource Provider."), - // Resource: to.Ptr("Microsoft.AzureArcData"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/postgresInstances/delete"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Delete exisiting Postgres Instances."), - // Operation: to.Ptr("Delete exisiting Postgres Instances."), - // Provider: to.Ptr("Azure Arc Data Resource Provider."), - // Resource: to.Ptr("Microsoft.AzureArcData"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/register/action"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Register the subscription for Microsoft.AzureArcData"), - // Operation: to.Ptr("Register the Microsoft.AzureArcData"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("Microsoft.AzureArcData"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/unregister/action"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("Unregister the subscription for Microsoft.AzureArcData"), - // Operation: to.Ptr("Unregister the Microsoft.AzureArcData"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("Microsoft.AzureArcData"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.AzureArcData/Operations/read"), - // Display: &armazurearcdata.OperationDisplay{ - // Description: to.Ptr("read Operations"), - // Operation: to.Ptr("read_Operations"), - // Provider: to.Ptr("Microsoft.AzureArcData"), - // Resource: to.Ptr("Operations"), - // }, - // IsDataAction: to.Ptr(false), - // }}, - // } - } -} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/options.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/options.go index 3da91f5fd3de..6c3831c3efd6 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/options.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/options.go @@ -73,6 +73,28 @@ type DataControllersClientListInSubscriptionOptions struct { // placeholder for future optional parameters } +// FailoverGroupsClientBeginCreateOptions contains the optional parameters for the FailoverGroupsClient.BeginCreate method. +type FailoverGroupsClientBeginCreateOptions struct { + // Resumes the LRO from the provided token. + ResumeToken string +} + +// FailoverGroupsClientBeginDeleteOptions contains the optional parameters for the FailoverGroupsClient.BeginDelete method. +type FailoverGroupsClientBeginDeleteOptions struct { + // Resumes the LRO from the provided token. + ResumeToken string +} + +// FailoverGroupsClientGetOptions contains the optional parameters for the FailoverGroupsClient.Get method. +type FailoverGroupsClientGetOptions struct { + // placeholder for future optional parameters +} + +// FailoverGroupsClientListOptions contains the optional parameters for the FailoverGroupsClient.NewListPager method. +type FailoverGroupsClientListOptions struct { + // placeholder for future optional parameters +} + // OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method. type OperationsClientListOptions struct { // placeholder for future optional parameters @@ -148,6 +170,143 @@ type SQLManagedInstancesClientUpdateOptions struct { // placeholder for future optional parameters } +// SQLServerAvailabilityGroupsClientAddDatabasesOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.AddDatabases +// method. +type SQLServerAvailabilityGroupsClientAddDatabasesOptions struct { + // placeholder for future optional parameters +} + +// SQLServerAvailabilityGroupsClientBeginCreateAvailabilityGroupOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.BeginCreateAvailabilityGroup +// method. +type SQLServerAvailabilityGroupsClientBeginCreateAvailabilityGroupOptions struct { + // Resumes the LRO from the provided token. + ResumeToken string +} + +// SQLServerAvailabilityGroupsClientBeginCreateDistributedAvailabilityGroupOptions contains the optional parameters for the +// SQLServerAvailabilityGroupsClient.BeginCreateDistributedAvailabilityGroup method. +type SQLServerAvailabilityGroupsClientBeginCreateDistributedAvailabilityGroupOptions struct { + // Resumes the LRO from the provided token. + ResumeToken string +} + +// SQLServerAvailabilityGroupsClientBeginDeleteOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.BeginDelete +// method. +type SQLServerAvailabilityGroupsClientBeginDeleteOptions struct { + // Resumes the LRO from the provided token. + ResumeToken string +} + +// SQLServerAvailabilityGroupsClientBeginUpdateOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.BeginUpdate +// method. +type SQLServerAvailabilityGroupsClientBeginUpdateOptions struct { + // Resumes the LRO from the provided token. + ResumeToken string +} + +// SQLServerAvailabilityGroupsClientCreateOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.Create +// method. +type SQLServerAvailabilityGroupsClientCreateOptions struct { + // placeholder for future optional parameters +} + +// SQLServerAvailabilityGroupsClientDetailViewOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.DetailView +// method. +type SQLServerAvailabilityGroupsClientDetailViewOptions struct { + // placeholder for future optional parameters +} + +// SQLServerAvailabilityGroupsClientFailoverOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.Failover +// method. +type SQLServerAvailabilityGroupsClientFailoverOptions struct { + // placeholder for future optional parameters +} + +// SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.ForceFailoverAllowDataLoss +// method. +type SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossOptions struct { + // placeholder for future optional parameters +} + +// SQLServerAvailabilityGroupsClientGetOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.Get +// method. +type SQLServerAvailabilityGroupsClientGetOptions struct { + // placeholder for future optional parameters +} + +// SQLServerAvailabilityGroupsClientListOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.NewListPager +// method. +type SQLServerAvailabilityGroupsClientListOptions struct { + // placeholder for future optional parameters +} + +// SQLServerAvailabilityGroupsClientRemoveDatabasesOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.RemoveDatabases +// method. +type SQLServerAvailabilityGroupsClientRemoveDatabasesOptions struct { + // placeholder for future optional parameters +} + +// SQLServerDatabasesClientBeginDeleteOptions contains the optional parameters for the SQLServerDatabasesClient.BeginDelete +// method. +type SQLServerDatabasesClientBeginDeleteOptions struct { + // Resumes the LRO from the provided token. + ResumeToken string +} + +// SQLServerDatabasesClientBeginUpdateOptions contains the optional parameters for the SQLServerDatabasesClient.BeginUpdate +// method. +type SQLServerDatabasesClientBeginUpdateOptions struct { + // Resumes the LRO from the provided token. + ResumeToken string +} + +// SQLServerDatabasesClientCreateOptions contains the optional parameters for the SQLServerDatabasesClient.Create method. +type SQLServerDatabasesClientCreateOptions struct { + // placeholder for future optional parameters +} + +// SQLServerDatabasesClientGetOptions contains the optional parameters for the SQLServerDatabasesClient.Get method. +type SQLServerDatabasesClientGetOptions struct { + // placeholder for future optional parameters +} + +// SQLServerDatabasesClientListOptions contains the optional parameters for the SQLServerDatabasesClient.NewListPager method. +type SQLServerDatabasesClientListOptions struct { + // placeholder for future optional parameters +} + +// SQLServerEsuLicensesClientCreateOptions contains the optional parameters for the SQLServerEsuLicensesClient.Create method. +type SQLServerEsuLicensesClientCreateOptions struct { + // placeholder for future optional parameters +} + +// SQLServerEsuLicensesClientDeleteOptions contains the optional parameters for the SQLServerEsuLicensesClient.Delete method. +type SQLServerEsuLicensesClientDeleteOptions struct { + // placeholder for future optional parameters +} + +// SQLServerEsuLicensesClientGetOptions contains the optional parameters for the SQLServerEsuLicensesClient.Get method. +type SQLServerEsuLicensesClientGetOptions struct { + // placeholder for future optional parameters +} + +// SQLServerEsuLicensesClientListByResourceGroupOptions contains the optional parameters for the SQLServerEsuLicensesClient.NewListByResourceGroupPager +// method. +type SQLServerEsuLicensesClientListByResourceGroupOptions struct { + // placeholder for future optional parameters +} + +// SQLServerEsuLicensesClientListOptions contains the optional parameters for the SQLServerEsuLicensesClient.NewListPager +// method. +type SQLServerEsuLicensesClientListOptions struct { + // placeholder for future optional parameters +} + +// SQLServerEsuLicensesClientUpdateOptions contains the optional parameters for the SQLServerEsuLicensesClient.Update method. +type SQLServerEsuLicensesClientUpdateOptions struct { + // placeholder for future optional parameters +} + // SQLServerInstancesClientBeginCreateOptions contains the optional parameters for the SQLServerInstancesClient.BeginCreate // method. type SQLServerInstancesClientBeginCreateOptions struct { @@ -162,6 +321,27 @@ type SQLServerInstancesClientBeginDeleteOptions struct { ResumeToken string } +// SQLServerInstancesClientBeginGetTelemetryOptions contains the optional parameters for the SQLServerInstancesClient.BeginGetTelemetry +// method. +type SQLServerInstancesClientBeginGetTelemetryOptions struct { + // Resumes the LRO from the provided token. + ResumeToken string +} + +// SQLServerInstancesClientBeginUpdateOptions contains the optional parameters for the SQLServerInstancesClient.BeginUpdate +// method. +type SQLServerInstancesClientBeginUpdateOptions struct { + // Resumes the LRO from the provided token. + ResumeToken string +} + +// SQLServerInstancesClientGetJobsStatusOptions contains the optional parameters for the SQLServerInstancesClient.GetJobsStatus +// method. +type SQLServerInstancesClientGetJobsStatusOptions struct { + // Contains the parameters to get SQL Server instance agent jobs status. + SQLServerInstanceJobsStatusRequest *SQLServerInstanceJobsStatusRequest +} + // SQLServerInstancesClientGetOptions contains the optional parameters for the SQLServerInstancesClient.Get method. type SQLServerInstancesClientGetOptions struct { // placeholder for future optional parameters @@ -178,7 +358,51 @@ type SQLServerInstancesClientListOptions struct { // placeholder for future optional parameters } -// SQLServerInstancesClientUpdateOptions contains the optional parameters for the SQLServerInstancesClient.Update method. -type SQLServerInstancesClientUpdateOptions struct { +// SQLServerInstancesClientPostUpgradeOptions contains the optional parameters for the SQLServerInstancesClient.PostUpgrade +// method. +type SQLServerInstancesClientPostUpgradeOptions struct { + // placeholder for future optional parameters +} + +// SQLServerInstancesClientPreUpgradeOptions contains the optional parameters for the SQLServerInstancesClient.PreUpgrade +// method. +type SQLServerInstancesClientPreUpgradeOptions struct { + // placeholder for future optional parameters +} + +// SQLServerInstancesClientRunMigrationAssessmentOptions contains the optional parameters for the SQLServerInstancesClient.RunMigrationAssessment +// method. +type SQLServerInstancesClientRunMigrationAssessmentOptions struct { + // placeholder for future optional parameters +} + +// SQLServerLicensesClientCreateOptions contains the optional parameters for the SQLServerLicensesClient.Create method. +type SQLServerLicensesClientCreateOptions struct { + // placeholder for future optional parameters +} + +// SQLServerLicensesClientDeleteOptions contains the optional parameters for the SQLServerLicensesClient.Delete method. +type SQLServerLicensesClientDeleteOptions struct { + // placeholder for future optional parameters +} + +// SQLServerLicensesClientGetOptions contains the optional parameters for the SQLServerLicensesClient.Get method. +type SQLServerLicensesClientGetOptions struct { + // placeholder for future optional parameters +} + +// SQLServerLicensesClientListByResourceGroupOptions contains the optional parameters for the SQLServerLicensesClient.NewListByResourceGroupPager +// method. +type SQLServerLicensesClientListByResourceGroupOptions struct { + // placeholder for future optional parameters +} + +// SQLServerLicensesClientListOptions contains the optional parameters for the SQLServerLicensesClient.NewListPager method. +type SQLServerLicensesClientListOptions struct { + // placeholder for future optional parameters +} + +// SQLServerLicensesClientUpdateOptions contains the optional parameters for the SQLServerLicensesClient.Update method. +type SQLServerLicensesClientUpdateOptions struct { // placeholder for future optional parameters } diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/postgresinstances_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/postgresinstances_client.go index a608285976d6..eb3cb5c3a153 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/postgresinstances_client.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/postgresinstances_client.go @@ -46,7 +46,7 @@ func NewPostgresInstancesClient(subscriptionID string, credential azcore.TokenCr // BeginCreate - Creates or replaces a postgres Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - postgresInstanceName - Name of Postgres Instance // - resource - The postgres instance @@ -73,7 +73,7 @@ func (client *PostgresInstancesClient) BeginCreate(ctx context.Context, resource // Create - Creates or replaces a postgres Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *PostgresInstancesClient) create(ctx context.Context, resourceGroupName string, postgresInstanceName string, resource PostgresInstance, options *PostgresInstancesClientBeginCreateOptions) (*http.Response, error) { var err error const operationName = "PostgresInstancesClient.BeginCreate" @@ -115,7 +115,7 @@ func (client *PostgresInstancesClient) createCreateRequest(ctx context.Context, return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} if err := runtime.MarshalAsJSON(req, resource); err != nil { @@ -127,7 +127,7 @@ func (client *PostgresInstancesClient) createCreateRequest(ctx context.Context, // BeginDelete - Deletes a postgres Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - postgresInstanceName - Name of Postgres Instance // - options - PostgresInstancesClientBeginDeleteOptions contains the optional parameters for the PostgresInstancesClient.BeginDelete @@ -152,7 +152,7 @@ func (client *PostgresInstancesClient) BeginDelete(ctx context.Context, resource // Delete - Deletes a postgres Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *PostgresInstancesClient) deleteOperation(ctx context.Context, resourceGroupName string, postgresInstanceName string, options *PostgresInstancesClientBeginDeleteOptions) (*http.Response, error) { var err error const operationName = "PostgresInstancesClient.BeginDelete" @@ -194,7 +194,7 @@ func (client *PostgresInstancesClient) deleteCreateRequest(ctx context.Context, return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -203,7 +203,7 @@ func (client *PostgresInstancesClient) deleteCreateRequest(ctx context.Context, // Get - Retrieves a postgres Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - postgresInstanceName - Name of Postgres Instance // - options - PostgresInstancesClientGetOptions contains the optional parameters for the PostgresInstancesClient.Get method. @@ -249,7 +249,7 @@ func (client *PostgresInstancesClient) getCreateRequest(ctx context.Context, res return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -266,7 +266,7 @@ func (client *PostgresInstancesClient) getHandleResponse(resp *http.Response) (P // NewListPager - List postgres Instance resources in the subscription // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - options - PostgresInstancesClientListOptions contains the optional parameters for the PostgresInstancesClient.NewListPager // method. func (client *PostgresInstancesClient) NewListPager(options *PostgresInstancesClientListOptions) *runtime.Pager[PostgresInstancesClientListResponse] { @@ -304,7 +304,7 @@ func (client *PostgresInstancesClient) listCreateRequest(ctx context.Context, op return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -321,7 +321,7 @@ func (client *PostgresInstancesClient) listHandleResponse(resp *http.Response) ( // NewListByResourceGroupPager - Get a postgres Instances list by Resource group name. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - options - PostgresInstancesClientListByResourceGroupOptions contains the optional parameters for the PostgresInstancesClient.NewListByResourceGroupPager // method. @@ -364,7 +364,7 @@ func (client *PostgresInstancesClient) listByResourceGroupCreateRequest(ctx cont return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -382,7 +382,7 @@ func (client *PostgresInstancesClient) listByResourceGroupHandleResponse(resp *h // Update - Updates a postgres Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - postgresInstanceName - Name of Postgres Instance // - parameters - The Postgres Instance. @@ -430,7 +430,7 @@ func (client *PostgresInstancesClient) updateCreateRequest(ctx context.Context, return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} if err := runtime.MarshalAsJSON(req, parameters); err != nil { diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/postgresinstances_client_example_test.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/postgresinstances_client_example_test.go deleted file mode 100644 index e8e65f78c13c..000000000000 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/postgresinstances_client_example_test.go +++ /dev/null @@ -1,472 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armazurearcdata_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/ListSubscriptionPostgresInstance.json -func ExamplePostgresInstancesClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewPostgresInstancesClient().NewListPager(nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.PostgresInstanceListResult = armazurearcdata.PostgresInstanceListResult{ - // Value: []*armazurearcdata.PostgresInstance{ - // { - // Name: to.Ptr("testpostgresInstances1"), - // Type: to.Ptr("Microsoft.AzureArcData/PostgresInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/PostgresInstances/testpostgresInstances1"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.PostgresInstanceProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // }, - // SKU: &armazurearcdata.PostgresInstanceSKU{ - // Name: to.Ptr("default"), - // Dev: to.Ptr(true), - // Tier: to.Ptr("Hyperscale"), - // }, - // }, - // { - // Name: to.Ptr("testpostgresInstances2"), - // Type: to.Ptr("Microsoft.AzureArcData/PostgresInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/PostgresInstances/testpostgresInstances2"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.PostgresInstanceProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // }, - // SKU: &armazurearcdata.PostgresInstanceSKU{ - // Name: to.Ptr("default"), - // Dev: to.Ptr(true), - // Tier: to.Ptr("Hyperscale"), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/ListByResourceGroupPostgresInstance.json -func ExamplePostgresInstancesClient_NewListByResourceGroupPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewPostgresInstancesClient().NewListByResourceGroupPager("testrg", nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.PostgresInstanceListResult = armazurearcdata.PostgresInstanceListResult{ - // Value: []*armazurearcdata.PostgresInstance{ - // { - // Name: to.Ptr("testpostgresInstances1"), - // Type: to.Ptr("Microsoft.AzureArcData/PostgresInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/PostgresInstances/testpostgresInstances1"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.PostgresInstanceProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // }, - // SKU: &armazurearcdata.PostgresInstanceSKU{ - // Name: to.Ptr("default"), - // Dev: to.Ptr(true), - // Tier: to.Ptr("Hyperscale"), - // }, - // }, - // { - // Name: to.Ptr("testpostgresInstances2"), - // Type: to.Ptr("Microsoft.AzureArcData/PostgresInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/PostgresInstances/testpostgresInstances2"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.PostgresInstanceProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // }, - // SKU: &armazurearcdata.PostgresInstanceSKU{ - // Name: to.Ptr("default"), - // Dev: to.Ptr(true), - // Tier: to.Ptr("Hyperscale"), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/GetPostgresInstance.json -func ExamplePostgresInstancesClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewPostgresInstancesClient().Get(ctx, "testrg", "testpostgresInstances", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.PostgresInstance = armazurearcdata.PostgresInstance{ - // Name: to.Ptr("testpostgresInstances"), - // Type: to.Ptr("Microsoft.AzureArcData/PostgresInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/PostgresInstances/testpostgresInstances"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.PostgresInstanceProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // }, - // SKU: &armazurearcdata.PostgresInstanceSKU{ - // Name: to.Ptr("default"), - // Dev: to.Ptr(true), - // Tier: to.Ptr("Hyperscale"), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/CreateOrUpdatePostgresInstance.json -func ExamplePostgresInstancesClient_BeginCreate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewPostgresInstancesClient().BeginCreate(ctx, "testrg", "testpostgresInstance", armazurearcdata.PostgresInstance{ - Location: to.Ptr("eastus"), - ExtendedLocation: &armazurearcdata.ExtendedLocation{ - Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - }, - Properties: &armazurearcdata.PostgresInstanceProperties{ - Admin: to.Ptr("admin"), - BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - Password: to.Ptr("********"), - Username: to.Ptr("username"), - }, - DataControllerID: to.Ptr("dataControllerId"), - K8SRaw: map[string]any{ - "apiVersion": "apiVersion", - "kind": "postgresql-12", - "metadata": map[string]any{ - "name": "pg1", - "creationTimestamp": "2020-08-25T14:55:10Z", - "generation": float64(1), - "namespace": "test", - "resourceVersion": "527780", - "selfLink": "/apis/arcdata.microsoft.com/v1alpha1/namespaces/test/postgresql-12s/pg1", - "uid": "1111aaaa-ffff-ffff-ffff-99999aaaaaaa", - }, - "spec": map[string]any{ - "backups": map[string]any{ - "deltaMinutes": float64(3), - "fullMinutes": float64(10), - "tiers": []any{ - map[string]any{ - "retention": map[string]any{ - "maximums": []any{ - "6", - "512MB", - }, - "minimums": []any{ - "3", - }, - }, - "storage": map[string]any{ - "volumeSize": "1Gi", - }, - }, - }, - }, - "engine": map[string]any{ - "extensions": []any{ - map[string]any{ - "name": "citus", - }, - }, - }, - "scale": map[string]any{ - "shards": float64(3), - }, - "scheduling": map[string]any{ - "default": map[string]any{ - "resources": map[string]any{ - "requests": map[string]any{ - "memory": "256Mi", - }, - }, - }, - }, - "service": map[string]any{ - "type": "NodePort", - }, - "storage": map[string]any{ - "data": map[string]any{ - "className": "local-storage", - "size": "5Gi", - }, - "logs": map[string]any{ - "className": "local-storage", - "size": "5Gi", - }, - }, - }, - "status": map[string]any{ - "externalEndpoint": nil, - "readyPods": "4/4", - "state": "Ready", - }, - }, - }, - SKU: &armazurearcdata.PostgresInstanceSKU{ - Name: to.Ptr("default"), - Dev: to.Ptr(true), - Tier: to.Ptr("Hyperscale"), - }, - }, nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - res, err := poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.PostgresInstance = armazurearcdata.PostgresInstance{ - // Name: to.Ptr("testpostgresInstance"), - // Type: to.Ptr("Microsoft.AzureArcData/PostgresInstance"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/PostgresInstance/testpostgresInstance"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.PostgresInstanceProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // }, - // SKU: &armazurearcdata.PostgresInstanceSKU{ - // Name: to.Ptr("default"), - // Dev: to.Ptr(true), - // Tier: to.Ptr("Hyperscale"), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/DeletePostgresInstance.json -func ExamplePostgresInstancesClient_BeginDelete() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewPostgresInstancesClient().BeginDelete(ctx, "testrg", "testpostgresInstance", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - _, err = poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/UpdatePostgresInstance.json -func ExamplePostgresInstancesClient_Update() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewPostgresInstancesClient().Update(ctx, "testrg", "testpostgresInstance", armazurearcdata.PostgresInstanceUpdate{ - Tags: map[string]*string{ - "mytag": to.Ptr("myval"), - }, - }, nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.PostgresInstance = armazurearcdata.PostgresInstance{ - // Name: to.Ptr("testpostgresInstance"), - // Type: to.Ptr("Microsoft.AzureArcData/PostgresInstance"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/PostgresInstance/testpostgresInstance"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.PostgresInstanceProperties{ - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // }, - // SKU: &armazurearcdata.PostgresInstanceSKU{ - // Name: to.Ptr("default"), - // Dev: to.Ptr(true), - // Tier: to.Ptr("Hyperscale"), - // }, - // } -} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/response_types.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/response_types.go deleted file mode 100644 index a4c3b660ff5a..000000000000 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/response_types.go +++ /dev/null @@ -1,178 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. - -package armazurearcdata - -// ActiveDirectoryConnectorsClientCreateResponse contains the response from method ActiveDirectoryConnectorsClient.BeginCreate. -type ActiveDirectoryConnectorsClientCreateResponse struct { - // Active directory connector resource - ActiveDirectoryConnectorResource -} - -// ActiveDirectoryConnectorsClientDeleteResponse contains the response from method ActiveDirectoryConnectorsClient.BeginDelete. -type ActiveDirectoryConnectorsClientDeleteResponse struct { - // placeholder for future response values -} - -// ActiveDirectoryConnectorsClientGetResponse contains the response from method ActiveDirectoryConnectorsClient.Get. -type ActiveDirectoryConnectorsClientGetResponse struct { - // Active directory connector resource - ActiveDirectoryConnectorResource -} - -// ActiveDirectoryConnectorsClientListResponse contains the response from method ActiveDirectoryConnectorsClient.NewListPager. -type ActiveDirectoryConnectorsClientListResponse struct { - // A list of active directory connectors - ActiveDirectoryConnectorListResult -} - -// DataControllersClientDeleteDataControllerResponse contains the response from method DataControllersClient.BeginDeleteDataController. -type DataControllersClientDeleteDataControllerResponse struct { - // placeholder for future response values -} - -// DataControllersClientGetDataControllerResponse contains the response from method DataControllersClient.GetDataController. -type DataControllersClientGetDataControllerResponse struct { - // Data controller resource - DataControllerResource -} - -// DataControllersClientListInGroupResponse contains the response from method DataControllersClient.NewListInGroupPager. -type DataControllersClientListInGroupResponse struct { - // A list of data controllers. - PageOfDataControllerResource -} - -// DataControllersClientListInSubscriptionResponse contains the response from method DataControllersClient.NewListInSubscriptionPager. -type DataControllersClientListInSubscriptionResponse struct { - // A list of data controllers. - PageOfDataControllerResource -} - -// DataControllersClientPatchDataControllerResponse contains the response from method DataControllersClient.BeginPatchDataController. -type DataControllersClientPatchDataControllerResponse struct { - // Data controller resource - DataControllerResource -} - -// DataControllersClientPutDataControllerResponse contains the response from method DataControllersClient.BeginPutDataController. -type DataControllersClientPutDataControllerResponse struct { - // Data controller resource - DataControllerResource -} - -// OperationsClientListResponse contains the response from method OperationsClient.NewListPager. -type OperationsClientListResponse struct { - // Result of the request to list Azure Data Services on Azure Arc operations. - OperationListResult -} - -// PostgresInstancesClientCreateResponse contains the response from method PostgresInstancesClient.BeginCreate. -type PostgresInstancesClientCreateResponse struct { - // A Postgres Instance. - PostgresInstance -} - -// PostgresInstancesClientDeleteResponse contains the response from method PostgresInstancesClient.BeginDelete. -type PostgresInstancesClientDeleteResponse struct { - // placeholder for future response values -} - -// PostgresInstancesClientGetResponse contains the response from method PostgresInstancesClient.Get. -type PostgresInstancesClientGetResponse struct { - // A Postgres Instance. - PostgresInstance -} - -// PostgresInstancesClientListByResourceGroupResponse contains the response from method PostgresInstancesClient.NewListByResourceGroupPager. -type PostgresInstancesClientListByResourceGroupResponse struct { - // A list of PostgresInstance. - PostgresInstanceListResult -} - -// PostgresInstancesClientListResponse contains the response from method PostgresInstancesClient.NewListPager. -type PostgresInstancesClientListResponse struct { - // A list of PostgresInstance. - PostgresInstanceListResult -} - -// PostgresInstancesClientUpdateResponse contains the response from method PostgresInstancesClient.Update. -type PostgresInstancesClientUpdateResponse struct { - // A Postgres Instance. - PostgresInstance -} - -// SQLManagedInstancesClientCreateResponse contains the response from method SQLManagedInstancesClient.BeginCreate. -type SQLManagedInstancesClientCreateResponse struct { - // A SqlManagedInstance. - SQLManagedInstance -} - -// SQLManagedInstancesClientDeleteResponse contains the response from method SQLManagedInstancesClient.BeginDelete. -type SQLManagedInstancesClientDeleteResponse struct { - // placeholder for future response values -} - -// SQLManagedInstancesClientGetResponse contains the response from method SQLManagedInstancesClient.Get. -type SQLManagedInstancesClientGetResponse struct { - // A SqlManagedInstance. - SQLManagedInstance -} - -// SQLManagedInstancesClientListByResourceGroupResponse contains the response from method SQLManagedInstancesClient.NewListByResourceGroupPager. -type SQLManagedInstancesClientListByResourceGroupResponse struct { - // A list of SqlManagedInstance. - SQLManagedInstanceListResult -} - -// SQLManagedInstancesClientListResponse contains the response from method SQLManagedInstancesClient.NewListPager. -type SQLManagedInstancesClientListResponse struct { - // A list of SqlManagedInstance. - SQLManagedInstanceListResult -} - -// SQLManagedInstancesClientUpdateResponse contains the response from method SQLManagedInstancesClient.Update. -type SQLManagedInstancesClientUpdateResponse struct { - // A SqlManagedInstance. - SQLManagedInstance -} - -// SQLServerInstancesClientCreateResponse contains the response from method SQLServerInstancesClient.BeginCreate. -type SQLServerInstancesClientCreateResponse struct { - // A SqlServerInstance. - SQLServerInstance -} - -// SQLServerInstancesClientDeleteResponse contains the response from method SQLServerInstancesClient.BeginDelete. -type SQLServerInstancesClientDeleteResponse struct { - // placeholder for future response values -} - -// SQLServerInstancesClientGetResponse contains the response from method SQLServerInstancesClient.Get. -type SQLServerInstancesClientGetResponse struct { - // A SqlServerInstance. - SQLServerInstance -} - -// SQLServerInstancesClientListByResourceGroupResponse contains the response from method SQLServerInstancesClient.NewListByResourceGroupPager. -type SQLServerInstancesClientListByResourceGroupResponse struct { - // A list of SqlServerInstance. - SQLServerInstanceListResult -} - -// SQLServerInstancesClientListResponse contains the response from method SQLServerInstancesClient.NewListPager. -type SQLServerInstancesClientListResponse struct { - // A list of SqlServerInstance. - SQLServerInstanceListResult -} - -// SQLServerInstancesClientUpdateResponse contains the response from method SQLServerInstancesClient.Update. -type SQLServerInstancesClientUpdateResponse struct { - // A SqlServerInstance. - SQLServerInstance -} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/responses.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/responses.go new file mode 100644 index 000000000000..ee16b3df39f7 --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/responses.go @@ -0,0 +1,401 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package armazurearcdata + +// ActiveDirectoryConnectorsClientCreateResponse contains the response from method ActiveDirectoryConnectorsClient.BeginCreate. +type ActiveDirectoryConnectorsClientCreateResponse struct { + // Active directory connector resource + ActiveDirectoryConnectorResource +} + +// ActiveDirectoryConnectorsClientDeleteResponse contains the response from method ActiveDirectoryConnectorsClient.BeginDelete. +type ActiveDirectoryConnectorsClientDeleteResponse struct { + // placeholder for future response values +} + +// ActiveDirectoryConnectorsClientGetResponse contains the response from method ActiveDirectoryConnectorsClient.Get. +type ActiveDirectoryConnectorsClientGetResponse struct { + // Active directory connector resource + ActiveDirectoryConnectorResource +} + +// ActiveDirectoryConnectorsClientListResponse contains the response from method ActiveDirectoryConnectorsClient.NewListPager. +type ActiveDirectoryConnectorsClientListResponse struct { + // A list of active directory connectors + ActiveDirectoryConnectorListResult +} + +// DataControllersClientDeleteDataControllerResponse contains the response from method DataControllersClient.BeginDeleteDataController. +type DataControllersClientDeleteDataControllerResponse struct { + // placeholder for future response values +} + +// DataControllersClientGetDataControllerResponse contains the response from method DataControllersClient.GetDataController. +type DataControllersClientGetDataControllerResponse struct { + // Data controller resource + DataControllerResource +} + +// DataControllersClientListInGroupResponse contains the response from method DataControllersClient.NewListInGroupPager. +type DataControllersClientListInGroupResponse struct { + // A list of data controllers. + PageOfDataControllerResource +} + +// DataControllersClientListInSubscriptionResponse contains the response from method DataControllersClient.NewListInSubscriptionPager. +type DataControllersClientListInSubscriptionResponse struct { + // A list of data controllers. + PageOfDataControllerResource +} + +// DataControllersClientPatchDataControllerResponse contains the response from method DataControllersClient.BeginPatchDataController. +type DataControllersClientPatchDataControllerResponse struct { + // Data controller resource + DataControllerResource +} + +// DataControllersClientPutDataControllerResponse contains the response from method DataControllersClient.BeginPutDataController. +type DataControllersClientPutDataControllerResponse struct { + // Data controller resource + DataControllerResource +} + +// FailoverGroupsClientCreateResponse contains the response from method FailoverGroupsClient.BeginCreate. +type FailoverGroupsClientCreateResponse struct { + // A failover group resource. + FailoverGroupResource +} + +// FailoverGroupsClientDeleteResponse contains the response from method FailoverGroupsClient.BeginDelete. +type FailoverGroupsClientDeleteResponse struct { + // placeholder for future response values +} + +// FailoverGroupsClientGetResponse contains the response from method FailoverGroupsClient.Get. +type FailoverGroupsClientGetResponse struct { + // A failover group resource. + FailoverGroupResource +} + +// FailoverGroupsClientListResponse contains the response from method FailoverGroupsClient.NewListPager. +type FailoverGroupsClientListResponse struct { + // A list of failover groups. + FailoverGroupListResult +} + +// OperationsClientListResponse contains the response from method OperationsClient.NewListPager. +type OperationsClientListResponse struct { + // Result of the request to list Azure Data Services on Azure Arc operations. + OperationListResult +} + +// PostgresInstancesClientCreateResponse contains the response from method PostgresInstancesClient.BeginCreate. +type PostgresInstancesClientCreateResponse struct { + // A Postgres Instance. + PostgresInstance +} + +// PostgresInstancesClientDeleteResponse contains the response from method PostgresInstancesClient.BeginDelete. +type PostgresInstancesClientDeleteResponse struct { + // placeholder for future response values +} + +// PostgresInstancesClientGetResponse contains the response from method PostgresInstancesClient.Get. +type PostgresInstancesClientGetResponse struct { + // A Postgres Instance. + PostgresInstance +} + +// PostgresInstancesClientListByResourceGroupResponse contains the response from method PostgresInstancesClient.NewListByResourceGroupPager. +type PostgresInstancesClientListByResourceGroupResponse struct { + // A list of PostgresInstance. + PostgresInstanceListResult +} + +// PostgresInstancesClientListResponse contains the response from method PostgresInstancesClient.NewListPager. +type PostgresInstancesClientListResponse struct { + // A list of PostgresInstance. + PostgresInstanceListResult +} + +// PostgresInstancesClientUpdateResponse contains the response from method PostgresInstancesClient.Update. +type PostgresInstancesClientUpdateResponse struct { + // A Postgres Instance. + PostgresInstance +} + +// SQLManagedInstancesClientCreateResponse contains the response from method SQLManagedInstancesClient.BeginCreate. +type SQLManagedInstancesClientCreateResponse struct { + // A SqlManagedInstance. + SQLManagedInstance +} + +// SQLManagedInstancesClientDeleteResponse contains the response from method SQLManagedInstancesClient.BeginDelete. +type SQLManagedInstancesClientDeleteResponse struct { + // placeholder for future response values +} + +// SQLManagedInstancesClientGetResponse contains the response from method SQLManagedInstancesClient.Get. +type SQLManagedInstancesClientGetResponse struct { + // A SqlManagedInstance. + SQLManagedInstance +} + +// SQLManagedInstancesClientListByResourceGroupResponse contains the response from method SQLManagedInstancesClient.NewListByResourceGroupPager. +type SQLManagedInstancesClientListByResourceGroupResponse struct { + // A list of SqlManagedInstance. + SQLManagedInstanceListResult +} + +// SQLManagedInstancesClientListResponse contains the response from method SQLManagedInstancesClient.NewListPager. +type SQLManagedInstancesClientListResponse struct { + // A list of SqlManagedInstance. + SQLManagedInstanceListResult +} + +// SQLManagedInstancesClientUpdateResponse contains the response from method SQLManagedInstancesClient.Update. +type SQLManagedInstancesClientUpdateResponse struct { + // A SqlManagedInstance. + SQLManagedInstance +} + +// SQLServerAvailabilityGroupsClientAddDatabasesResponse contains the response from method SQLServerAvailabilityGroupsClient.AddDatabases. +type SQLServerAvailabilityGroupsClientAddDatabasesResponse struct { + // Arc Sql Server Availability Group + SQLServerAvailabilityGroupResource +} + +// SQLServerAvailabilityGroupsClientCreateAvailabilityGroupResponse contains the response from method SQLServerAvailabilityGroupsClient.BeginCreateAvailabilityGroup. +type SQLServerAvailabilityGroupsClientCreateAvailabilityGroupResponse struct { + // Arc Sql Server Availability Group + SQLServerAvailabilityGroupResource +} + +// SQLServerAvailabilityGroupsClientCreateDistributedAvailabilityGroupResponse contains the response from method SQLServerAvailabilityGroupsClient.BeginCreateDistributedAvailabilityGroup. +type SQLServerAvailabilityGroupsClientCreateDistributedAvailabilityGroupResponse struct { + // Arc Sql Server Availability Group + SQLServerAvailabilityGroupResource +} + +// SQLServerAvailabilityGroupsClientCreateResponse contains the response from method SQLServerAvailabilityGroupsClient.Create. +type SQLServerAvailabilityGroupsClientCreateResponse struct { + // Arc Sql Server Availability Group + SQLServerAvailabilityGroupResource +} + +// SQLServerAvailabilityGroupsClientDeleteResponse contains the response from method SQLServerAvailabilityGroupsClient.BeginDelete. +type SQLServerAvailabilityGroupsClientDeleteResponse struct { + // placeholder for future response values +} + +// SQLServerAvailabilityGroupsClientDetailViewResponse contains the response from method SQLServerAvailabilityGroupsClient.DetailView. +type SQLServerAvailabilityGroupsClientDetailViewResponse struct { + // Arc Sql Server Availability Group + SQLServerAvailabilityGroupResource +} + +// SQLServerAvailabilityGroupsClientFailoverResponse contains the response from method SQLServerAvailabilityGroupsClient.Failover. +type SQLServerAvailabilityGroupsClientFailoverResponse struct { + // Arc Sql Server Availability Group + SQLServerAvailabilityGroupResource +} + +// SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse contains the response from method SQLServerAvailabilityGroupsClient.ForceFailoverAllowDataLoss. +type SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse struct { + // Arc Sql Server Availability Group + SQLServerAvailabilityGroupResource +} + +// SQLServerAvailabilityGroupsClientGetResponse contains the response from method SQLServerAvailabilityGroupsClient.Get. +type SQLServerAvailabilityGroupsClientGetResponse struct { + // Arc Sql Server Availability Group + SQLServerAvailabilityGroupResource +} + +// SQLServerAvailabilityGroupsClientListResponse contains the response from method SQLServerAvailabilityGroupsClient.NewListPager. +type SQLServerAvailabilityGroupsClientListResponse struct { + // A list of Arc Sql Server Availability Groups. + ArcSQLServerAvailabilityGroupListResult +} + +// SQLServerAvailabilityGroupsClientRemoveDatabasesResponse contains the response from method SQLServerAvailabilityGroupsClient.RemoveDatabases. +type SQLServerAvailabilityGroupsClientRemoveDatabasesResponse struct { + // Arc Sql Server Availability Group + SQLServerAvailabilityGroupResource +} + +// SQLServerAvailabilityGroupsClientUpdateResponse contains the response from method SQLServerAvailabilityGroupsClient.BeginUpdate. +type SQLServerAvailabilityGroupsClientUpdateResponse struct { + // Arc Sql Server Availability Group + SQLServerAvailabilityGroupResource +} + +// SQLServerDatabasesClientCreateResponse contains the response from method SQLServerDatabasesClient.Create. +type SQLServerDatabasesClientCreateResponse struct { + // Arc Sql Server database + SQLServerDatabaseResource +} + +// SQLServerDatabasesClientDeleteResponse contains the response from method SQLServerDatabasesClient.BeginDelete. +type SQLServerDatabasesClientDeleteResponse struct { + // placeholder for future response values +} + +// SQLServerDatabasesClientGetResponse contains the response from method SQLServerDatabasesClient.Get. +type SQLServerDatabasesClientGetResponse struct { + // Arc Sql Server database + SQLServerDatabaseResource +} + +// SQLServerDatabasesClientListResponse contains the response from method SQLServerDatabasesClient.NewListPager. +type SQLServerDatabasesClientListResponse struct { + // A list of Arc Sql Server database. + ArcSQLServerDatabaseListResult +} + +// SQLServerDatabasesClientUpdateResponse contains the response from method SQLServerDatabasesClient.BeginUpdate. +type SQLServerDatabasesClientUpdateResponse struct { + // Arc Sql Server database + SQLServerDatabaseResource +} + +// SQLServerEsuLicensesClientCreateResponse contains the response from method SQLServerEsuLicensesClient.Create. +type SQLServerEsuLicensesClientCreateResponse struct { + // Describe SQL Server ESU license resource. + SQLServerEsuLicense +} + +// SQLServerEsuLicensesClientDeleteResponse contains the response from method SQLServerEsuLicensesClient.Delete. +type SQLServerEsuLicensesClientDeleteResponse struct { + // placeholder for future response values +} + +// SQLServerEsuLicensesClientGetResponse contains the response from method SQLServerEsuLicensesClient.Get. +type SQLServerEsuLicensesClientGetResponse struct { + // Describe SQL Server ESU license resource. + SQLServerEsuLicense +} + +// SQLServerEsuLicensesClientListByResourceGroupResponse contains the response from method SQLServerEsuLicensesClient.NewListByResourceGroupPager. +type SQLServerEsuLicensesClientListByResourceGroupResponse struct { + // A list of SQL Server ESU licenses. + SQLServerEsuLicenseListResult +} + +// SQLServerEsuLicensesClientListResponse contains the response from method SQLServerEsuLicensesClient.NewListPager. +type SQLServerEsuLicensesClientListResponse struct { + // A list of SQL Server ESU licenses. + SQLServerEsuLicenseListResult +} + +// SQLServerEsuLicensesClientUpdateResponse contains the response from method SQLServerEsuLicensesClient.Update. +type SQLServerEsuLicensesClientUpdateResponse struct { + // Describe SQL Server ESU license resource. + SQLServerEsuLicense +} + +// SQLServerInstancesClientCreateResponse contains the response from method SQLServerInstancesClient.BeginCreate. +type SQLServerInstancesClientCreateResponse struct { + // A SqlServerInstance. + SQLServerInstance +} + +// SQLServerInstancesClientDeleteResponse contains the response from method SQLServerInstancesClient.BeginDelete. +type SQLServerInstancesClientDeleteResponse struct { + // placeholder for future response values +} + +// SQLServerInstancesClientGetJobsStatusResponse contains the response from method SQLServerInstancesClient.GetJobsStatus. +type SQLServerInstancesClientGetJobsStatusResponse struct { + // The response for the status of the jobs running on the SQL Server instance. + SQLServerInstanceJobsStatusResponse +} + +// SQLServerInstancesClientGetResponse contains the response from method SQLServerInstancesClient.Get. +type SQLServerInstancesClientGetResponse struct { + // A SqlServerInstance. + SQLServerInstance +} + +// SQLServerInstancesClientGetTelemetryResponse contains the response from method SQLServerInstancesClient.BeginGetTelemetry. +type SQLServerInstancesClientGetTelemetryResponse struct { + // A section of the telemetry response for the SQL Server instance. + SQLServerInstanceTelemetryResponse +} + +// SQLServerInstancesClientListByResourceGroupResponse contains the response from method SQLServerInstancesClient.NewListByResourceGroupPager. +type SQLServerInstancesClientListByResourceGroupResponse struct { + // A list of SqlServerInstance. + SQLServerInstanceListResult +} + +// SQLServerInstancesClientListResponse contains the response from method SQLServerInstancesClient.NewListPager. +type SQLServerInstancesClientListResponse struct { + // A list of SqlServerInstance. + SQLServerInstanceListResult +} + +// SQLServerInstancesClientPostUpgradeResponse contains the response from method SQLServerInstancesClient.PostUpgrade. +type SQLServerInstancesClientPostUpgradeResponse struct { + // A SqlServerInstance. + SQLServerInstance +} + +// SQLServerInstancesClientPreUpgradeResponse contains the response from method SQLServerInstancesClient.PreUpgrade. +type SQLServerInstancesClientPreUpgradeResponse struct { + // A SqlServerInstance. + SQLServerInstance +} + +// SQLServerInstancesClientRunMigrationAssessmentResponse contains the response from method SQLServerInstancesClient.RunMigrationAssessment. +type SQLServerInstancesClientRunMigrationAssessmentResponse struct { + // The response for running migration assessment on the SQL Server instance. + SQLServerInstanceRunMigrationAssessmentResponse +} + +// SQLServerInstancesClientUpdateResponse contains the response from method SQLServerInstancesClient.BeginUpdate. +type SQLServerInstancesClientUpdateResponse struct { + // A SqlServerInstance. + SQLServerInstance +} + +// SQLServerLicensesClientCreateResponse contains the response from method SQLServerLicensesClient.Create. +type SQLServerLicensesClientCreateResponse struct { + // Describe SQL Server license resource. + SQLServerLicense +} + +// SQLServerLicensesClientDeleteResponse contains the response from method SQLServerLicensesClient.Delete. +type SQLServerLicensesClientDeleteResponse struct { + // placeholder for future response values +} + +// SQLServerLicensesClientGetResponse contains the response from method SQLServerLicensesClient.Get. +type SQLServerLicensesClientGetResponse struct { + // Describe SQL Server license resource. + SQLServerLicense +} + +// SQLServerLicensesClientListByResourceGroupResponse contains the response from method SQLServerLicensesClient.NewListByResourceGroupPager. +type SQLServerLicensesClientListByResourceGroupResponse struct { + // A list of SQL Server licenses. + SQLServerLicenseListResult +} + +// SQLServerLicensesClientListResponse contains the response from method SQLServerLicensesClient.NewListPager. +type SQLServerLicensesClientListResponse struct { + // A list of SQL Server licenses. + SQLServerLicenseListResult +} + +// SQLServerLicensesClientUpdateResponse contains the response from method SQLServerLicensesClient.Update. +type SQLServerLicensesClientUpdateResponse struct { + // Describe SQL Server license resource. + SQLServerLicense +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlmanagedinstances_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlmanagedinstances_client.go index 8720dc30c287..d9cb402e96a2 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlmanagedinstances_client.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlmanagedinstances_client.go @@ -46,7 +46,7 @@ func NewSQLManagedInstancesClient(subscriptionID string, credential azcore.Token // BeginCreate - Creates or replaces a SQL Managed Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - sqlManagedInstanceName - Name of SQL Managed Instance // - sqlManagedInstance - The SQL Managed Instance to be created or updated. @@ -73,7 +73,7 @@ func (client *SQLManagedInstancesClient) BeginCreate(ctx context.Context, resour // Create - Creates or replaces a SQL Managed Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *SQLManagedInstancesClient) create(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, sqlManagedInstance SQLManagedInstance, options *SQLManagedInstancesClientBeginCreateOptions) (*http.Response, error) { var err error const operationName = "SQLManagedInstancesClient.BeginCreate" @@ -115,7 +115,7 @@ func (client *SQLManagedInstancesClient) createCreateRequest(ctx context.Context return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} if err := runtime.MarshalAsJSON(req, sqlManagedInstance); err != nil { @@ -127,7 +127,7 @@ func (client *SQLManagedInstancesClient) createCreateRequest(ctx context.Context // BeginDelete - Deletes a SQL Managed Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - sqlManagedInstanceName - Name of SQL Managed Instance // - options - SQLManagedInstancesClientBeginDeleteOptions contains the optional parameters for the SQLManagedInstancesClient.BeginDelete @@ -152,7 +152,7 @@ func (client *SQLManagedInstancesClient) BeginDelete(ctx context.Context, resour // Delete - Deletes a SQL Managed Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *SQLManagedInstancesClient) deleteOperation(ctx context.Context, resourceGroupName string, sqlManagedInstanceName string, options *SQLManagedInstancesClientBeginDeleteOptions) (*http.Response, error) { var err error const operationName = "SQLManagedInstancesClient.BeginDelete" @@ -194,7 +194,7 @@ func (client *SQLManagedInstancesClient) deleteCreateRequest(ctx context.Context return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -203,7 +203,7 @@ func (client *SQLManagedInstancesClient) deleteCreateRequest(ctx context.Context // Get - Retrieves a SQL Managed Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - sqlManagedInstanceName - Name of SQL Managed Instance // - options - SQLManagedInstancesClientGetOptions contains the optional parameters for the SQLManagedInstancesClient.Get method. @@ -249,7 +249,7 @@ func (client *SQLManagedInstancesClient) getCreateRequest(ctx context.Context, r return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -266,7 +266,7 @@ func (client *SQLManagedInstancesClient) getHandleResponse(resp *http.Response) // NewListPager - List sqlManagedInstance resources in the subscription // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - options - SQLManagedInstancesClientListOptions contains the optional parameters for the SQLManagedInstancesClient.NewListPager // method. func (client *SQLManagedInstancesClient) NewListPager(options *SQLManagedInstancesClientListOptions) *runtime.Pager[SQLManagedInstancesClientListResponse] { @@ -304,7 +304,7 @@ func (client *SQLManagedInstancesClient) listCreateRequest(ctx context.Context, return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -321,7 +321,7 @@ func (client *SQLManagedInstancesClient) listHandleResponse(resp *http.Response) // NewListByResourceGroupPager - Gets all sqlManagedInstances in a resource group. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - options - SQLManagedInstancesClientListByResourceGroupOptions contains the optional parameters for the SQLManagedInstancesClient.NewListByResourceGroupPager // method. @@ -364,7 +364,7 @@ func (client *SQLManagedInstancesClient) listByResourceGroupCreateRequest(ctx co return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -382,7 +382,7 @@ func (client *SQLManagedInstancesClient) listByResourceGroupHandleResponse(resp // Update - Updates a SQL Managed Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - sqlManagedInstanceName - Name of SQL Managed Instance // - parameters - The SQL Managed Instance. @@ -430,7 +430,7 @@ func (client *SQLManagedInstancesClient) updateCreateRequest(ctx context.Context return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} if err := runtime.MarshalAsJSON(req, parameters); err != nil { diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlmanagedinstances_client_example_test.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlmanagedinstances_client_example_test.go deleted file mode 100644 index 04c983e5b706..000000000000 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlmanagedinstances_client_example_test.go +++ /dev/null @@ -1,669 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armazurearcdata_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/ListSubscriptionSqlManagedInstance.json -func ExampleSQLManagedInstancesClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewSQLManagedInstancesClient().NewListPager(nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.SQLManagedInstanceListResult = armazurearcdata.SQLManagedInstanceListResult{ - // Value: []*armazurearcdata.SQLManagedInstance{ - // { - // Name: to.Ptr("sqlManagedInstances1"), - // Type: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/SqlManagedInstances/sqlManagedInstance1"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.SQLManagedInstanceProperties{ - // ActiveDirectoryInformation: &armazurearcdata.ActiveDirectoryInformation{ - // KeytabInformation: &armazurearcdata.KeytabInformation{ - // }, - // }, - // Admin: to.Ptr("Admin user"), - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // EndTime: to.Ptr("Instance end time"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // K8SRaw: &armazurearcdata.SQLManagedInstanceK8SRaw{ - // AdditionalProperties: map[string]any{ - // "additionalProperty": float64(1234), - // }, - // Spec: &armazurearcdata.SQLManagedInstanceK8SSpec{ - // Replicas: to.Ptr[int32](1), - // Scheduling: &armazurearcdata.K8SScheduling{ - // Default: &armazurearcdata.K8SSchedulingOptions{ - // Resources: &armazurearcdata.K8SResourceRequirements{ - // Limits: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // Requests: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // }, - // }, - // }, - // }, - // }, - // LicenseType: to.Ptr(armazurearcdata.ArcSQLManagedInstanceLicenseTypeLicenseIncluded), - // StartTime: to.Ptr("Instance start time"), - // }, - // SKU: &armazurearcdata.SQLManagedInstanceSKU{ - // Name: to.Ptr("vCore"), - // Dev: to.Ptr(true), - // Tier: to.Ptr(armazurearcdata.SQLManagedInstanceSKUTierGeneralPurpose), - // }, - // }, - // { - // Name: to.Ptr("sqlManagedInstances2"), - // Type: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/SqlManagedInstances/sqlManagedInstance2"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.SQLManagedInstanceProperties{ - // ActiveDirectoryInformation: &armazurearcdata.ActiveDirectoryInformation{ - // KeytabInformation: &armazurearcdata.KeytabInformation{ - // }, - // }, - // Admin: to.Ptr("Admin user"), - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // EndTime: to.Ptr("Instance end time"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // K8SRaw: &armazurearcdata.SQLManagedInstanceK8SRaw{ - // AdditionalProperties: map[string]any{ - // "additionalProperty": float64(1234), - // }, - // Spec: &armazurearcdata.SQLManagedInstanceK8SSpec{ - // Replicas: to.Ptr[int32](1), - // Scheduling: &armazurearcdata.K8SScheduling{ - // Default: &armazurearcdata.K8SSchedulingOptions{ - // Resources: &armazurearcdata.K8SResourceRequirements{ - // Limits: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // Requests: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // }, - // }, - // }, - // }, - // }, - // LicenseType: to.Ptr(armazurearcdata.ArcSQLManagedInstanceLicenseTypeLicenseIncluded), - // StartTime: to.Ptr("Instance start time"), - // }, - // SKU: &armazurearcdata.SQLManagedInstanceSKU{ - // Name: to.Ptr("vCore"), - // Dev: to.Ptr(true), - // Tier: to.Ptr(armazurearcdata.SQLManagedInstanceSKUTierGeneralPurpose), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/ListByResourceGroupSqlManagedInstance.json -func ExampleSQLManagedInstancesClient_NewListByResourceGroupPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewSQLManagedInstancesClient().NewListByResourceGroupPager("testrg", nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.SQLManagedInstanceListResult = armazurearcdata.SQLManagedInstanceListResult{ - // Value: []*armazurearcdata.SQLManagedInstance{ - // { - // Name: to.Ptr("sqlManagedInstances1"), - // Type: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/sqlManagedInstances/sqlManagedInstance1"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.SQLManagedInstanceProperties{ - // ActiveDirectoryInformation: &armazurearcdata.ActiveDirectoryInformation{ - // KeytabInformation: &armazurearcdata.KeytabInformation{ - // }, - // }, - // Admin: to.Ptr("Admin user"), - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // EndTime: to.Ptr("Instance end time"), - // K8SRaw: &armazurearcdata.SQLManagedInstanceK8SRaw{ - // AdditionalProperties: map[string]any{ - // "additionalProperty": float64(1234), - // }, - // Spec: &armazurearcdata.SQLManagedInstanceK8SSpec{ - // Replicas: to.Ptr[int32](1), - // Scheduling: &armazurearcdata.K8SScheduling{ - // Default: &armazurearcdata.K8SSchedulingOptions{ - // Resources: &armazurearcdata.K8SResourceRequirements{ - // Limits: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // Requests: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // }, - // }, - // }, - // }, - // }, - // LicenseType: to.Ptr(armazurearcdata.ArcSQLManagedInstanceLicenseTypeLicenseIncluded), - // StartTime: to.Ptr("Instance start time"), - // }, - // SKU: &armazurearcdata.SQLManagedInstanceSKU{ - // Name: to.Ptr("vCore"), - // Dev: to.Ptr(true), - // Tier: to.Ptr(armazurearcdata.SQLManagedInstanceSKUTierGeneralPurpose), - // }, - // }, - // { - // Name: to.Ptr("sqlManagedInstances2"), - // Type: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/sqlManagedInstances/sqlManagedInstance2"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.SQLManagedInstanceProperties{ - // ActiveDirectoryInformation: &armazurearcdata.ActiveDirectoryInformation{ - // KeytabInformation: &armazurearcdata.KeytabInformation{ - // }, - // }, - // Admin: to.Ptr("Admin user"), - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // EndTime: to.Ptr("Instance end time"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // K8SRaw: &armazurearcdata.SQLManagedInstanceK8SRaw{ - // AdditionalProperties: map[string]any{ - // "additionalProperty": float64(1234), - // }, - // Spec: &armazurearcdata.SQLManagedInstanceK8SSpec{ - // Replicas: to.Ptr[int32](1), - // Scheduling: &armazurearcdata.K8SScheduling{ - // Default: &armazurearcdata.K8SSchedulingOptions{ - // Resources: &armazurearcdata.K8SResourceRequirements{ - // Limits: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // Requests: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // }, - // }, - // }, - // }, - // }, - // LicenseType: to.Ptr(armazurearcdata.ArcSQLManagedInstanceLicenseTypeLicenseIncluded), - // StartTime: to.Ptr("Instance start time"), - // }, - // SKU: &armazurearcdata.SQLManagedInstanceSKU{ - // Name: to.Ptr("vCore"), - // Dev: to.Ptr(true), - // Tier: to.Ptr(armazurearcdata.SQLManagedInstanceSKUTierGeneralPurpose), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/GetSqlManagedInstance.json -func ExampleSQLManagedInstancesClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewSQLManagedInstancesClient().Get(ctx, "testrg", "testsqlManagedInstance", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.SQLManagedInstance = armazurearcdata.SQLManagedInstance{ - // Name: to.Ptr("testsqlManagedInstance"), - // Type: to.Ptr("Microsoft.AzureArcData/sqlManagedInstance"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/sqlManagedInstances/testsqlManagedInstance"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.SQLManagedInstanceProperties{ - // ActiveDirectoryInformation: &armazurearcdata.ActiveDirectoryInformation{ - // KeytabInformation: &armazurearcdata.KeytabInformation{ - // }, - // }, - // Admin: to.Ptr("Admin user"), - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // EndTime: to.Ptr("Instance end time"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // K8SRaw: &armazurearcdata.SQLManagedInstanceK8SRaw{ - // AdditionalProperties: map[string]any{ - // "additionalProperty": float64(1234), - // }, - // Spec: &armazurearcdata.SQLManagedInstanceK8SSpec{ - // Replicas: to.Ptr[int32](1), - // Scheduling: &armazurearcdata.K8SScheduling{ - // Default: &armazurearcdata.K8SSchedulingOptions{ - // Resources: &armazurearcdata.K8SResourceRequirements{ - // Limits: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // Requests: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // }, - // }, - // }, - // }, - // }, - // LicenseType: to.Ptr(armazurearcdata.ArcSQLManagedInstanceLicenseTypeLicenseIncluded), - // StartTime: to.Ptr("Instance start time"), - // }, - // SKU: &armazurearcdata.SQLManagedInstanceSKU{ - // Name: to.Ptr("vCore"), - // Dev: to.Ptr(true), - // Tier: to.Ptr(armazurearcdata.SQLManagedInstanceSKUTierGeneralPurpose), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/CreateOrUpdateSqlManagedInstance.json -func ExampleSQLManagedInstancesClient_BeginCreate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewSQLManagedInstancesClient().BeginCreate(ctx, "testrg", "testsqlManagedInstance", armazurearcdata.SQLManagedInstance{ - Location: to.Ptr("northeurope"), - Tags: map[string]*string{ - "mytag": to.Ptr("myval"), - }, - ExtendedLocation: &armazurearcdata.ExtendedLocation{ - Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - }, - Properties: &armazurearcdata.SQLManagedInstanceProperties{ - ActiveDirectoryInformation: &armazurearcdata.ActiveDirectoryInformation{ - KeytabInformation: &armazurearcdata.KeytabInformation{ - Keytab: to.Ptr("********"), - }, - }, - Admin: to.Ptr("Admin user"), - BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - Password: to.Ptr("********"), - Username: to.Ptr("username"), - }, - ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - EndTime: to.Ptr("Instance end time"), - ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - K8SRaw: &armazurearcdata.SQLManagedInstanceK8SRaw{ - AdditionalProperties: map[string]any{ - "additionalProperty": float64(1234), - }, - Spec: &armazurearcdata.SQLManagedInstanceK8SSpec{ - Replicas: to.Ptr[int32](1), - Scheduling: &armazurearcdata.K8SScheduling{ - Default: &armazurearcdata.K8SSchedulingOptions{ - Resources: &armazurearcdata.K8SResourceRequirements{ - Limits: map[string]*string{ - "additionalProperty": to.Ptr("additionalValue"), - "cpu": to.Ptr("1"), - "memory": to.Ptr("8Gi"), - }, - Requests: map[string]*string{ - "additionalProperty": to.Ptr("additionalValue"), - "cpu": to.Ptr("1"), - "memory": to.Ptr("8Gi"), - }, - }, - }, - }, - }, - }, - LicenseType: to.Ptr(armazurearcdata.ArcSQLManagedInstanceLicenseTypeLicenseIncluded), - StartTime: to.Ptr("Instance start time"), - }, - SKU: &armazurearcdata.SQLManagedInstanceSKU{ - Name: to.Ptr("vCore"), - Dev: to.Ptr(true), - Tier: to.Ptr(armazurearcdata.SQLManagedInstanceSKUTierGeneralPurpose), - }, - }, nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - res, err := poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.SQLManagedInstance = armazurearcdata.SQLManagedInstance{ - // Name: to.Ptr("testsqlManagedInstance"), - // Type: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/sqlManagedInstances/testsqlManagedInstance"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.SQLManagedInstanceProperties{ - // ActiveDirectoryInformation: &armazurearcdata.ActiveDirectoryInformation{ - // KeytabInformation: &armazurearcdata.KeytabInformation{ - // }, - // }, - // Admin: to.Ptr("Admin user"), - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // EndTime: to.Ptr("Instance end time"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // K8SRaw: &armazurearcdata.SQLManagedInstanceK8SRaw{ - // AdditionalProperties: map[string]any{ - // "additionalProperty": float64(1234), - // }, - // Spec: &armazurearcdata.SQLManagedInstanceK8SSpec{ - // Replicas: to.Ptr[int32](1), - // Scheduling: &armazurearcdata.K8SScheduling{ - // Default: &armazurearcdata.K8SSchedulingOptions{ - // Resources: &armazurearcdata.K8SResourceRequirements{ - // Limits: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // Requests: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // }, - // }, - // }, - // }, - // }, - // LicenseType: to.Ptr(armazurearcdata.ArcSQLManagedInstanceLicenseTypeLicenseIncluded), - // StartTime: to.Ptr("Instance start time"), - // }, - // SKU: &armazurearcdata.SQLManagedInstanceSKU{ - // Name: to.Ptr("vCore"), - // Dev: to.Ptr(true), - // Tier: to.Ptr(armazurearcdata.SQLManagedInstanceSKUTierGeneralPurpose), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/DeleteSqlManagedInstance.json -func ExampleSQLManagedInstancesClient_BeginDelete() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewSQLManagedInstancesClient().BeginDelete(ctx, "testrg", "testsqlManagedInstance", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - _, err = poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/UpdateSqlManagedInstance.json -func ExampleSQLManagedInstancesClient_Update() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewSQLManagedInstancesClient().Update(ctx, "testrg", "testsqlManagedInstance", armazurearcdata.SQLManagedInstanceUpdate{ - Tags: map[string]*string{ - "mytag": to.Ptr("myval"), - }, - }, nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.SQLManagedInstance = armazurearcdata.SQLManagedInstance{ - // Name: to.Ptr("testsqlManagedInstance"), - // Type: to.Ptr("Microsoft.AzureArcData/sqlManagedInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/sqlManagedInstances/testsqlManagedInstance"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // ExtendedLocation: &armazurearcdata.ExtendedLocation{ - // Name: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.ExtendedLocation/customLocations/arclocation"), - // Type: to.Ptr(armazurearcdata.ExtendedLocationTypesCustomLocation), - // }, - // Properties: &armazurearcdata.SQLManagedInstanceProperties{ - // ActiveDirectoryInformation: &armazurearcdata.ActiveDirectoryInformation{ - // KeytabInformation: &armazurearcdata.KeytabInformation{ - // }, - // }, - // Admin: to.Ptr("Admin user"), - // BasicLoginInformation: &armazurearcdata.BasicLoginInformation{ - // Username: to.Ptr("username"), - // }, - // ClusterID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s"), - // EndTime: to.Ptr("Instance end time"), - // ExtensionID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Kubernetes/connectedClusters/connectedk8s/providers/Microsoft.KubernetesConfiguration/extensions/extension"), - // K8SRaw: &armazurearcdata.SQLManagedInstanceK8SRaw{ - // AdditionalProperties: map[string]any{ - // "additionalProperty": float64(1234), - // }, - // Spec: &armazurearcdata.SQLManagedInstanceK8SSpec{ - // Replicas: to.Ptr[int32](1), - // Scheduling: &armazurearcdata.K8SScheduling{ - // Default: &armazurearcdata.K8SSchedulingOptions{ - // Resources: &armazurearcdata.K8SResourceRequirements{ - // Limits: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // Requests: map[string]*string{ - // "additionalProperty": to.Ptr("additionalValue"), - // "cpu": to.Ptr("1"), - // "memory": to.Ptr("8Gi"), - // }, - // }, - // }, - // }, - // }, - // }, - // LicenseType: to.Ptr(armazurearcdata.ArcSQLManagedInstanceLicenseTypeLicenseIncluded), - // StartTime: to.Ptr("Instance start time"), - // }, - // SKU: &armazurearcdata.SQLManagedInstanceSKU{ - // Name: to.Ptr("vCore"), - // Dev: to.Ptr(true), - // Tier: to.Ptr(armazurearcdata.SQLManagedInstanceSKUTierGeneralPurpose), - // }, - // } -} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserveravailabilitygroups_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserveravailabilitygroups_client.go new file mode 100644 index 000000000000..ecd0e114cee6 --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserveravailabilitygroups_client.go @@ -0,0 +1,940 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package armazurearcdata + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// SQLServerAvailabilityGroupsClient contains the methods for the SQLServerAvailabilityGroups group. +// Don't use this type directly, use NewSQLServerAvailabilityGroupsClient() instead. +type SQLServerAvailabilityGroupsClient struct { + internal *arm.Client + subscriptionID string +} + +// NewSQLServerAvailabilityGroupsClient creates a new instance of SQLServerAvailabilityGroupsClient with the specified values. +// - subscriptionID - The ID of the Azure subscription +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewSQLServerAvailabilityGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SQLServerAvailabilityGroupsClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &SQLServerAvailabilityGroupsClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// AddDatabases - Request adding database(s) to an existing availability group. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - availabilityGroupName - Name of SQL Availability Group +// - databases - The database names to add to the SQL Server availability group resource. +// - options - SQLServerAvailabilityGroupsClientAddDatabasesOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.AddDatabases +// method. +func (client *SQLServerAvailabilityGroupsClient) AddDatabases(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, databases Databases, options *SQLServerAvailabilityGroupsClientAddDatabasesOptions) (SQLServerAvailabilityGroupsClientAddDatabasesResponse, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.AddDatabases" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.addDatabasesCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, databases, options) + if err != nil { + return SQLServerAvailabilityGroupsClientAddDatabasesResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerAvailabilityGroupsClientAddDatabasesResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerAvailabilityGroupsClientAddDatabasesResponse{}, err + } + resp, err := client.addDatabasesHandleResponse(httpResp) + return resp, err +} + +// addDatabasesCreateRequest creates the AddDatabases request. +func (client *SQLServerAvailabilityGroupsClient) addDatabasesCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, databases Databases, options *SQLServerAvailabilityGroupsClientAddDatabasesOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/availabilityGroups/{availabilityGroupName}/addDatabases" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if availabilityGroupName == "" { + return nil, errors.New("parameter availabilityGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{availabilityGroupName}", url.PathEscape(availabilityGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, databases); err != nil { + return nil, err + } + return req, nil +} + +// addDatabasesHandleResponse handles the AddDatabases response. +func (client *SQLServerAvailabilityGroupsClient) addDatabasesHandleResponse(resp *http.Response) (SQLServerAvailabilityGroupsClientAddDatabasesResponse, error) { + result := SQLServerAvailabilityGroupsClientAddDatabasesResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerAvailabilityGroupResource); err != nil { + return SQLServerAvailabilityGroupsClientAddDatabasesResponse{}, err + } + return result, nil +} + +// Create - Creates or replaces an Arc Sql Server Availability Group. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - availabilityGroupName - Name of SQL Availability Group +// - sqlServerAvailabilityGroupResource - The request body for availability group resource. +// - options - SQLServerAvailabilityGroupsClientCreateOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.Create +// method. +func (client *SQLServerAvailabilityGroupsClient) Create(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, sqlServerAvailabilityGroupResource SQLServerAvailabilityGroupResource, options *SQLServerAvailabilityGroupsClientCreateOptions) (SQLServerAvailabilityGroupsClientCreateResponse, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.Create" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, sqlServerAvailabilityGroupResource, options) + if err != nil { + return SQLServerAvailabilityGroupsClientCreateResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerAvailabilityGroupsClientCreateResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusCreated) { + err = runtime.NewResponseError(httpResp) + return SQLServerAvailabilityGroupsClientCreateResponse{}, err + } + resp, err := client.createHandleResponse(httpResp) + return resp, err +} + +// createCreateRequest creates the Create request. +func (client *SQLServerAvailabilityGroupsClient) createCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, sqlServerAvailabilityGroupResource SQLServerAvailabilityGroupResource, options *SQLServerAvailabilityGroupsClientCreateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/availabilityGroups/{availabilityGroupName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if availabilityGroupName == "" { + return nil, errors.New("parameter availabilityGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{availabilityGroupName}", url.PathEscape(availabilityGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, sqlServerAvailabilityGroupResource); err != nil { + return nil, err + } + return req, nil +} + +// createHandleResponse handles the Create response. +func (client *SQLServerAvailabilityGroupsClient) createHandleResponse(resp *http.Response) (SQLServerAvailabilityGroupsClientCreateResponse, error) { + result := SQLServerAvailabilityGroupsClientCreateResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerAvailabilityGroupResource); err != nil { + return SQLServerAvailabilityGroupsClientCreateResponse{}, err + } + return result, nil +} + +// BeginCreateAvailabilityGroup - Create a SQL Server availability group +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - createAgConfiguration - The configuration for the new SQL Server availability group resource. +// - options - SQLServerAvailabilityGroupsClientBeginCreateAvailabilityGroupOptions contains the optional parameters for the +// SQLServerAvailabilityGroupsClient.BeginCreateAvailabilityGroup method. +func (client *SQLServerAvailabilityGroupsClient) BeginCreateAvailabilityGroup(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, createAgConfiguration AvailabilityGroupCreateUpdateConfiguration, options *SQLServerAvailabilityGroupsClientBeginCreateAvailabilityGroupOptions) (*runtime.Poller[SQLServerAvailabilityGroupsClientCreateAvailabilityGroupResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.createAvailabilityGroup(ctx, resourceGroupName, sqlServerInstanceName, createAgConfiguration, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[SQLServerAvailabilityGroupsClientCreateAvailabilityGroupResponse]{ + FinalStateVia: runtime.FinalStateViaAzureAsyncOp, + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[SQLServerAvailabilityGroupsClientCreateAvailabilityGroupResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// CreateAvailabilityGroup - Create a SQL Server availability group +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +func (client *SQLServerAvailabilityGroupsClient) createAvailabilityGroup(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, createAgConfiguration AvailabilityGroupCreateUpdateConfiguration, options *SQLServerAvailabilityGroupsClientBeginCreateAvailabilityGroupOptions) (*http.Response, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.BeginCreateAvailabilityGroup" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createAvailabilityGroupCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, createAgConfiguration, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// createAvailabilityGroupCreateRequest creates the CreateAvailabilityGroup request. +func (client *SQLServerAvailabilityGroupsClient) createAvailabilityGroupCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, createAgConfiguration AvailabilityGroupCreateUpdateConfiguration, options *SQLServerAvailabilityGroupsClientBeginCreateAvailabilityGroupOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/createAvailabilityGroup" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, createAgConfiguration); err != nil { + return nil, err + } + return req, nil +} + +// BeginCreateDistributedAvailabilityGroup - Create a SQL Server distributed availability group +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - createDagConfiguration - The configuration for the new SQL Server availability group resource. +// - options - SQLServerAvailabilityGroupsClientBeginCreateDistributedAvailabilityGroupOptions contains the optional parameters +// for the SQLServerAvailabilityGroupsClient.BeginCreateDistributedAvailabilityGroup method. +func (client *SQLServerAvailabilityGroupsClient) BeginCreateDistributedAvailabilityGroup(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, createDagConfiguration DistributedAvailabilityGroupCreateUpdateConfiguration, options *SQLServerAvailabilityGroupsClientBeginCreateDistributedAvailabilityGroupOptions) (*runtime.Poller[SQLServerAvailabilityGroupsClientCreateDistributedAvailabilityGroupResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.createDistributedAvailabilityGroup(ctx, resourceGroupName, sqlServerInstanceName, createDagConfiguration, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[SQLServerAvailabilityGroupsClientCreateDistributedAvailabilityGroupResponse]{ + FinalStateVia: runtime.FinalStateViaAzureAsyncOp, + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[SQLServerAvailabilityGroupsClientCreateDistributedAvailabilityGroupResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// CreateDistributedAvailabilityGroup - Create a SQL Server distributed availability group +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +func (client *SQLServerAvailabilityGroupsClient) createDistributedAvailabilityGroup(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, createDagConfiguration DistributedAvailabilityGroupCreateUpdateConfiguration, options *SQLServerAvailabilityGroupsClientBeginCreateDistributedAvailabilityGroupOptions) (*http.Response, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.BeginCreateDistributedAvailabilityGroup" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createDistributedAvailabilityGroupCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, createDagConfiguration, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// createDistributedAvailabilityGroupCreateRequest creates the CreateDistributedAvailabilityGroup request. +func (client *SQLServerAvailabilityGroupsClient) createDistributedAvailabilityGroupCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, createDagConfiguration DistributedAvailabilityGroupCreateUpdateConfiguration, options *SQLServerAvailabilityGroupsClientBeginCreateDistributedAvailabilityGroupOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/createDistributedAvailabilityGroup" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, createDagConfiguration); err != nil { + return nil, err + } + return req, nil +} + +// BeginDelete - Deletes an Arc Sql Server availability group resource. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - availabilityGroupName - Name of SQL Availability Group +// - options - SQLServerAvailabilityGroupsClientBeginDeleteOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.BeginDelete +// method. +func (client *SQLServerAvailabilityGroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientBeginDeleteOptions) (*runtime.Poller[SQLServerAvailabilityGroupsClientDeleteResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.deleteOperation(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[SQLServerAvailabilityGroupsClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[SQLServerAvailabilityGroupsClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Delete - Deletes an Arc Sql Server availability group resource. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +func (client *SQLServerAvailabilityGroupsClient) deleteOperation(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientBeginDeleteOptions) (*http.Response, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.BeginDelete" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.deleteCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusAccepted, http.StatusNoContent) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// deleteCreateRequest creates the Delete request. +func (client *SQLServerAvailabilityGroupsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientBeginDeleteOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/availabilityGroups/{availabilityGroupName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if availabilityGroupName == "" { + return nil, errors.New("parameter availabilityGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{availabilityGroupName}", url.PathEscape(availabilityGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// DetailView - Retrieves detailed properties of the Availability Group. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - availabilityGroupName - Name of SQL Availability Group +// - options - SQLServerAvailabilityGroupsClientDetailViewOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.DetailView +// method. +func (client *SQLServerAvailabilityGroupsClient) DetailView(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientDetailViewOptions) (SQLServerAvailabilityGroupsClientDetailViewResponse, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.DetailView" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.detailViewCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, options) + if err != nil { + return SQLServerAvailabilityGroupsClientDetailViewResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerAvailabilityGroupsClientDetailViewResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerAvailabilityGroupsClientDetailViewResponse{}, err + } + resp, err := client.detailViewHandleResponse(httpResp) + return resp, err +} + +// detailViewCreateRequest creates the DetailView request. +func (client *SQLServerAvailabilityGroupsClient) detailViewCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientDetailViewOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/availabilityGroups/{availabilityGroupName}/getDetailView" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if availabilityGroupName == "" { + return nil, errors.New("parameter availabilityGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{availabilityGroupName}", url.PathEscape(availabilityGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// detailViewHandleResponse handles the DetailView response. +func (client *SQLServerAvailabilityGroupsClient) detailViewHandleResponse(resp *http.Response) (SQLServerAvailabilityGroupsClientDetailViewResponse, error) { + result := SQLServerAvailabilityGroupsClientDetailViewResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerAvailabilityGroupResource); err != nil { + return SQLServerAvailabilityGroupsClientDetailViewResponse{}, err + } + return result, nil +} + +// Failover - Request manual failover of the availability group to this server. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - availabilityGroupName - Name of SQL Availability Group +// - options - SQLServerAvailabilityGroupsClientFailoverOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.Failover +// method. +func (client *SQLServerAvailabilityGroupsClient) Failover(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientFailoverOptions) (SQLServerAvailabilityGroupsClientFailoverResponse, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.Failover" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.failoverCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, options) + if err != nil { + return SQLServerAvailabilityGroupsClientFailoverResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerAvailabilityGroupsClientFailoverResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerAvailabilityGroupsClientFailoverResponse{}, err + } + resp, err := client.failoverHandleResponse(httpResp) + return resp, err +} + +// failoverCreateRequest creates the Failover request. +func (client *SQLServerAvailabilityGroupsClient) failoverCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientFailoverOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/availabilityGroups/{availabilityGroupName}/failover" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if availabilityGroupName == "" { + return nil, errors.New("parameter availabilityGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{availabilityGroupName}", url.PathEscape(availabilityGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// failoverHandleResponse handles the Failover response. +func (client *SQLServerAvailabilityGroupsClient) failoverHandleResponse(resp *http.Response) (SQLServerAvailabilityGroupsClientFailoverResponse, error) { + result := SQLServerAvailabilityGroupsClientFailoverResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerAvailabilityGroupResource); err != nil { + return SQLServerAvailabilityGroupsClientFailoverResponse{}, err + } + return result, nil +} + +// ForceFailoverAllowDataLoss - Request forced failover of the availability group to this server. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - availabilityGroupName - Name of SQL Availability Group +// - options - SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.ForceFailoverAllowDataLoss +// method. +func (client *SQLServerAvailabilityGroupsClient) ForceFailoverAllowDataLoss(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossOptions) (SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.ForceFailoverAllowDataLoss" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.forceFailoverAllowDataLossCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, options) + if err != nil { + return SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse{}, err + } + resp, err := client.forceFailoverAllowDataLossHandleResponse(httpResp) + return resp, err +} + +// forceFailoverAllowDataLossCreateRequest creates the ForceFailoverAllowDataLoss request. +func (client *SQLServerAvailabilityGroupsClient) forceFailoverAllowDataLossCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/availabilityGroups/{availabilityGroupName}/forceFailoverAllowDataLoss" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if availabilityGroupName == "" { + return nil, errors.New("parameter availabilityGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{availabilityGroupName}", url.PathEscape(availabilityGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// forceFailoverAllowDataLossHandleResponse handles the ForceFailoverAllowDataLoss response. +func (client *SQLServerAvailabilityGroupsClient) forceFailoverAllowDataLossHandleResponse(resp *http.Response) (SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse, error) { + result := SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerAvailabilityGroupResource); err != nil { + return SQLServerAvailabilityGroupsClientForceFailoverAllowDataLossResponse{}, err + } + return result, nil +} + +// Get - Retrieves an Arc Sql Server availability group. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - availabilityGroupName - Name of SQL Availability Group +// - options - SQLServerAvailabilityGroupsClientGetOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.Get +// method. +func (client *SQLServerAvailabilityGroupsClient) Get(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientGetOptions) (SQLServerAvailabilityGroupsClientGetResponse, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.Get" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, options) + if err != nil { + return SQLServerAvailabilityGroupsClientGetResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerAvailabilityGroupsClientGetResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerAvailabilityGroupsClientGetResponse{}, err + } + resp, err := client.getHandleResponse(httpResp) + return resp, err +} + +// getCreateRequest creates the Get request. +func (client *SQLServerAvailabilityGroupsClient) getCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, options *SQLServerAvailabilityGroupsClientGetOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/availabilityGroups/{availabilityGroupName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if availabilityGroupName == "" { + return nil, errors.New("parameter availabilityGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{availabilityGroupName}", url.PathEscape(availabilityGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getHandleResponse handles the Get response. +func (client *SQLServerAvailabilityGroupsClient) getHandleResponse(resp *http.Response) (SQLServerAvailabilityGroupsClientGetResponse, error) { + result := SQLServerAvailabilityGroupsClientGetResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerAvailabilityGroupResource); err != nil { + return SQLServerAvailabilityGroupsClientGetResponse{}, err + } + return result, nil +} + +// NewListPager - List the availability group associated with the given Arc Sql Server. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - options - SQLServerAvailabilityGroupsClientListOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.NewListPager +// method. +func (client *SQLServerAvailabilityGroupsClient) NewListPager(resourceGroupName string, sqlServerInstanceName string, options *SQLServerAvailabilityGroupsClientListOptions) *runtime.Pager[SQLServerAvailabilityGroupsClientListResponse] { + return runtime.NewPager(runtime.PagingHandler[SQLServerAvailabilityGroupsClientListResponse]{ + More: func(page SQLServerAvailabilityGroupsClientListResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *SQLServerAvailabilityGroupsClientListResponse) (SQLServerAvailabilityGroupsClientListResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "SQLServerAvailabilityGroupsClient.NewListPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, options) + }, nil) + if err != nil { + return SQLServerAvailabilityGroupsClientListResponse{}, err + } + return client.listHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listCreateRequest creates the List request. +func (client *SQLServerAvailabilityGroupsClient) listCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerAvailabilityGroupsClientListOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/availabilityGroups" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listHandleResponse handles the List response. +func (client *SQLServerAvailabilityGroupsClient) listHandleResponse(resp *http.Response) (SQLServerAvailabilityGroupsClientListResponse, error) { + result := SQLServerAvailabilityGroupsClientListResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.ArcSQLServerAvailabilityGroupListResult); err != nil { + return SQLServerAvailabilityGroupsClientListResponse{}, err + } + return result, nil +} + +// RemoveDatabases - Request removing database(s) from an existing availability group. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - availabilityGroupName - Name of SQL Availability Group +// - databases - The database names to remove from the SQL Server availability group resource. +// - options - SQLServerAvailabilityGroupsClientRemoveDatabasesOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.RemoveDatabases +// method. +func (client *SQLServerAvailabilityGroupsClient) RemoveDatabases(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, databases Databases, options *SQLServerAvailabilityGroupsClientRemoveDatabasesOptions) (SQLServerAvailabilityGroupsClientRemoveDatabasesResponse, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.RemoveDatabases" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.removeDatabasesCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, databases, options) + if err != nil { + return SQLServerAvailabilityGroupsClientRemoveDatabasesResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerAvailabilityGroupsClientRemoveDatabasesResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerAvailabilityGroupsClientRemoveDatabasesResponse{}, err + } + resp, err := client.removeDatabasesHandleResponse(httpResp) + return resp, err +} + +// removeDatabasesCreateRequest creates the RemoveDatabases request. +func (client *SQLServerAvailabilityGroupsClient) removeDatabasesCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, databases Databases, options *SQLServerAvailabilityGroupsClientRemoveDatabasesOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/availabilityGroups/{availabilityGroupName}/removeDatabases" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if availabilityGroupName == "" { + return nil, errors.New("parameter availabilityGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{availabilityGroupName}", url.PathEscape(availabilityGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, databases); err != nil { + return nil, err + } + return req, nil +} + +// removeDatabasesHandleResponse handles the RemoveDatabases response. +func (client *SQLServerAvailabilityGroupsClient) removeDatabasesHandleResponse(resp *http.Response) (SQLServerAvailabilityGroupsClientRemoveDatabasesResponse, error) { + result := SQLServerAvailabilityGroupsClientRemoveDatabasesResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerAvailabilityGroupResource); err != nil { + return SQLServerAvailabilityGroupsClientRemoveDatabasesResponse{}, err + } + return result, nil +} + +// BeginUpdate - Updates an existing Availability Group. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - availabilityGroupName - Name of SQL Availability Group +// - sqlServerAvailabilityGroupUpdate - The requested server availability group resource state. +// - options - SQLServerAvailabilityGroupsClientBeginUpdateOptions contains the optional parameters for the SQLServerAvailabilityGroupsClient.BeginUpdate +// method. +func (client *SQLServerAvailabilityGroupsClient) BeginUpdate(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, sqlServerAvailabilityGroupUpdate SQLServerAvailabilityGroupUpdate, options *SQLServerAvailabilityGroupsClientBeginUpdateOptions) (*runtime.Poller[SQLServerAvailabilityGroupsClientUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.update(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, sqlServerAvailabilityGroupUpdate, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[SQLServerAvailabilityGroupsClientUpdateResponse]{ + FinalStateVia: runtime.FinalStateViaAzureAsyncOp, + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[SQLServerAvailabilityGroupsClientUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Update - Updates an existing Availability Group. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +func (client *SQLServerAvailabilityGroupsClient) update(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, sqlServerAvailabilityGroupUpdate SQLServerAvailabilityGroupUpdate, options *SQLServerAvailabilityGroupsClientBeginUpdateOptions) (*http.Response, error) { + var err error + const operationName = "SQLServerAvailabilityGroupsClient.BeginUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.updateCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, availabilityGroupName, sqlServerAvailabilityGroupUpdate, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// updateCreateRequest creates the Update request. +func (client *SQLServerAvailabilityGroupsClient) updateCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, availabilityGroupName string, sqlServerAvailabilityGroupUpdate SQLServerAvailabilityGroupUpdate, options *SQLServerAvailabilityGroupsClientBeginUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/availabilityGroups/{availabilityGroupName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if availabilityGroupName == "" { + return nil, errors.New("parameter availabilityGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{availabilityGroupName}", url.PathEscape(availabilityGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, sqlServerAvailabilityGroupUpdate); err != nil { + return nil, err + } + return req, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverdatabases_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverdatabases_client.go new file mode 100644 index 000000000000..221ed903285d --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverdatabases_client.go @@ -0,0 +1,419 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package armazurearcdata + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// SQLServerDatabasesClient contains the methods for the SQLServerDatabases group. +// Don't use this type directly, use NewSQLServerDatabasesClient() instead. +type SQLServerDatabasesClient struct { + internal *arm.Client + subscriptionID string +} + +// NewSQLServerDatabasesClient creates a new instance of SQLServerDatabasesClient with the specified values. +// - subscriptionID - The ID of the Azure subscription +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewSQLServerDatabasesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SQLServerDatabasesClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &SQLServerDatabasesClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// Create - Creates or replaces an Arc Sql Server Database. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - databaseName - Name of the database +// - sqlServerDatabaseResource - The request body for database resource. +// - options - SQLServerDatabasesClientCreateOptions contains the optional parameters for the SQLServerDatabasesClient.Create +// method. +func (client *SQLServerDatabasesClient) Create(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, sqlServerDatabaseResource SQLServerDatabaseResource, options *SQLServerDatabasesClientCreateOptions) (SQLServerDatabasesClientCreateResponse, error) { + var err error + const operationName = "SQLServerDatabasesClient.Create" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, databaseName, sqlServerDatabaseResource, options) + if err != nil { + return SQLServerDatabasesClientCreateResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerDatabasesClientCreateResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusCreated) { + err = runtime.NewResponseError(httpResp) + return SQLServerDatabasesClientCreateResponse{}, err + } + resp, err := client.createHandleResponse(httpResp) + return resp, err +} + +// createCreateRequest creates the Create request. +func (client *SQLServerDatabasesClient) createCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, sqlServerDatabaseResource SQLServerDatabaseResource, options *SQLServerDatabasesClientCreateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/databases/{databaseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if databaseName == "" { + return nil, errors.New("parameter databaseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{databaseName}", url.PathEscape(databaseName)) + req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, sqlServerDatabaseResource); err != nil { + return nil, err + } + return req, nil +} + +// createHandleResponse handles the Create response. +func (client *SQLServerDatabasesClient) createHandleResponse(resp *http.Response) (SQLServerDatabasesClientCreateResponse, error) { + result := SQLServerDatabasesClientCreateResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerDatabaseResource); err != nil { + return SQLServerDatabasesClientCreateResponse{}, err + } + return result, nil +} + +// BeginDelete - Deletes an Arc Sql Server database resource. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - databaseName - Name of the database +// - options - SQLServerDatabasesClientBeginDeleteOptions contains the optional parameters for the SQLServerDatabasesClient.BeginDelete +// method. +func (client *SQLServerDatabasesClient) BeginDelete(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, options *SQLServerDatabasesClientBeginDeleteOptions) (*runtime.Poller[SQLServerDatabasesClientDeleteResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.deleteOperation(ctx, resourceGroupName, sqlServerInstanceName, databaseName, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[SQLServerDatabasesClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[SQLServerDatabasesClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Delete - Deletes an Arc Sql Server database resource. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +func (client *SQLServerDatabasesClient) deleteOperation(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, options *SQLServerDatabasesClientBeginDeleteOptions) (*http.Response, error) { + var err error + const operationName = "SQLServerDatabasesClient.BeginDelete" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.deleteCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, databaseName, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusAccepted, http.StatusNoContent) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// deleteCreateRequest creates the Delete request. +func (client *SQLServerDatabasesClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, options *SQLServerDatabasesClientBeginDeleteOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/databases/{databaseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if databaseName == "" { + return nil, errors.New("parameter databaseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{databaseName}", url.PathEscape(databaseName)) + req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// Get - Retrieves an Arc Sql Server database. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - databaseName - Name of the database +// - options - SQLServerDatabasesClientGetOptions contains the optional parameters for the SQLServerDatabasesClient.Get method. +func (client *SQLServerDatabasesClient) Get(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, options *SQLServerDatabasesClientGetOptions) (SQLServerDatabasesClientGetResponse, error) { + var err error + const operationName = "SQLServerDatabasesClient.Get" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, databaseName, options) + if err != nil { + return SQLServerDatabasesClientGetResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerDatabasesClientGetResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerDatabasesClientGetResponse{}, err + } + resp, err := client.getHandleResponse(httpResp) + return resp, err +} + +// getCreateRequest creates the Get request. +func (client *SQLServerDatabasesClient) getCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, options *SQLServerDatabasesClientGetOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/databases/{databaseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if databaseName == "" { + return nil, errors.New("parameter databaseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{databaseName}", url.PathEscape(databaseName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getHandleResponse handles the Get response. +func (client *SQLServerDatabasesClient) getHandleResponse(resp *http.Response) (SQLServerDatabasesClientGetResponse, error) { + result := SQLServerDatabasesClientGetResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerDatabaseResource); err != nil { + return SQLServerDatabasesClientGetResponse{}, err + } + return result, nil +} + +// NewListPager - List the databases associated with the given Arc Sql Server. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - options - SQLServerDatabasesClientListOptions contains the optional parameters for the SQLServerDatabasesClient.NewListPager +// method. +func (client *SQLServerDatabasesClient) NewListPager(resourceGroupName string, sqlServerInstanceName string, options *SQLServerDatabasesClientListOptions) *runtime.Pager[SQLServerDatabasesClientListResponse] { + return runtime.NewPager(runtime.PagingHandler[SQLServerDatabasesClientListResponse]{ + More: func(page SQLServerDatabasesClientListResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *SQLServerDatabasesClientListResponse) (SQLServerDatabasesClientListResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "SQLServerDatabasesClient.NewListPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, options) + }, nil) + if err != nil { + return SQLServerDatabasesClientListResponse{}, err + } + return client.listHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listCreateRequest creates the List request. +func (client *SQLServerDatabasesClient) listCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerDatabasesClientListOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/databases" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listHandleResponse handles the List response. +func (client *SQLServerDatabasesClient) listHandleResponse(resp *http.Response) (SQLServerDatabasesClientListResponse, error) { + result := SQLServerDatabasesClientListResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.ArcSQLServerDatabaseListResult); err != nil { + return SQLServerDatabasesClientListResponse{}, err + } + return result, nil +} + +// BeginUpdate - Updates an existing database. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - databaseName - Name of the database +// - sqlServerDatabaseUpdate - The requested database resource state. +// - options - SQLServerDatabasesClientBeginUpdateOptions contains the optional parameters for the SQLServerDatabasesClient.BeginUpdate +// method. +func (client *SQLServerDatabasesClient) BeginUpdate(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, sqlServerDatabaseUpdate SQLServerDatabaseUpdate, options *SQLServerDatabasesClientBeginUpdateOptions) (*runtime.Poller[SQLServerDatabasesClientUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.update(ctx, resourceGroupName, sqlServerInstanceName, databaseName, sqlServerDatabaseUpdate, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[SQLServerDatabasesClientUpdateResponse]{ + FinalStateVia: runtime.FinalStateViaAzureAsyncOp, + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[SQLServerDatabasesClientUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Update - Updates an existing database. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +func (client *SQLServerDatabasesClient) update(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, sqlServerDatabaseUpdate SQLServerDatabaseUpdate, options *SQLServerDatabasesClientBeginUpdateOptions) (*http.Response, error) { + var err error + const operationName = "SQLServerDatabasesClient.BeginUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.updateCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, databaseName, sqlServerDatabaseUpdate, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// updateCreateRequest creates the Update request. +func (client *SQLServerDatabasesClient) updateCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, databaseName string, sqlServerDatabaseUpdate SQLServerDatabaseUpdate, options *SQLServerDatabasesClientBeginUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/databases/{databaseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + if databaseName == "" { + return nil, errors.New("parameter databaseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{databaseName}", url.PathEscape(databaseName)) + req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, sqlServerDatabaseUpdate); err != nil { + return nil, err + } + return req, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserveresulicenses_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserveresulicenses_client.go new file mode 100644 index 000000000000..4676ae6b511b --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserveresulicenses_client.go @@ -0,0 +1,417 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package armazurearcdata + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// SQLServerEsuLicensesClient contains the methods for the SQLServerEsuLicenses group. +// Don't use this type directly, use NewSQLServerEsuLicensesClient() instead. +type SQLServerEsuLicensesClient struct { + internal *arm.Client + subscriptionID string +} + +// NewSQLServerEsuLicensesClient creates a new instance of SQLServerEsuLicensesClient with the specified values. +// - subscriptionID - The ID of the Azure subscription +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewSQLServerEsuLicensesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SQLServerEsuLicensesClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &SQLServerEsuLicensesClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// Create - Creates or replaces a SQL Server ESU license resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - sqlServerEsuLicenseName - Name of SQL Server ESU License +// - sqlServerEsuLicense - The SQL Server ESU license to be created or updated. +// - options - SQLServerEsuLicensesClientCreateOptions contains the optional parameters for the SQLServerEsuLicensesClient.Create +// method. +func (client *SQLServerEsuLicensesClient) Create(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, sqlServerEsuLicense SQLServerEsuLicense, options *SQLServerEsuLicensesClientCreateOptions) (SQLServerEsuLicensesClientCreateResponse, error) { + var err error + const operationName = "SQLServerEsuLicensesClient.Create" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createCreateRequest(ctx, resourceGroupName, sqlServerEsuLicenseName, sqlServerEsuLicense, options) + if err != nil { + return SQLServerEsuLicensesClientCreateResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerEsuLicensesClientCreateResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusCreated) { + err = runtime.NewResponseError(httpResp) + return SQLServerEsuLicensesClientCreateResponse{}, err + } + resp, err := client.createHandleResponse(httpResp) + return resp, err +} + +// createCreateRequest creates the Create request. +func (client *SQLServerEsuLicensesClient) createCreateRequest(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, sqlServerEsuLicense SQLServerEsuLicense, options *SQLServerEsuLicensesClientCreateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerEsuLicenses/{sqlServerEsuLicenseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerEsuLicenseName == "" { + return nil, errors.New("parameter sqlServerEsuLicenseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerEsuLicenseName}", url.PathEscape(sqlServerEsuLicenseName)) + req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, sqlServerEsuLicense); err != nil { + return nil, err + } + return req, nil +} + +// createHandleResponse handles the Create response. +func (client *SQLServerEsuLicensesClient) createHandleResponse(resp *http.Response) (SQLServerEsuLicensesClientCreateResponse, error) { + result := SQLServerEsuLicensesClientCreateResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerEsuLicense); err != nil { + return SQLServerEsuLicensesClientCreateResponse{}, err + } + return result, nil +} + +// Delete - Deletes a SQL Server ESU license resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - sqlServerEsuLicenseName - Name of SQL Server ESU License +// - options - SQLServerEsuLicensesClientDeleteOptions contains the optional parameters for the SQLServerEsuLicensesClient.Delete +// method. +func (client *SQLServerEsuLicensesClient) Delete(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, options *SQLServerEsuLicensesClientDeleteOptions) (SQLServerEsuLicensesClientDeleteResponse, error) { + var err error + const operationName = "SQLServerEsuLicensesClient.Delete" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.deleteCreateRequest(ctx, resourceGroupName, sqlServerEsuLicenseName, options) + if err != nil { + return SQLServerEsuLicensesClientDeleteResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerEsuLicensesClientDeleteResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusNoContent) { + err = runtime.NewResponseError(httpResp) + return SQLServerEsuLicensesClientDeleteResponse{}, err + } + return SQLServerEsuLicensesClientDeleteResponse{}, nil +} + +// deleteCreateRequest creates the Delete request. +func (client *SQLServerEsuLicensesClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, options *SQLServerEsuLicensesClientDeleteOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerEsuLicenses/{sqlServerEsuLicenseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerEsuLicenseName == "" { + return nil, errors.New("parameter sqlServerEsuLicenseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerEsuLicenseName}", url.PathEscape(sqlServerEsuLicenseName)) + req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// Get - Retrieves a SQL Server ESU license resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - sqlServerEsuLicenseName - Name of SQL Server ESU License +// - options - SQLServerEsuLicensesClientGetOptions contains the optional parameters for the SQLServerEsuLicensesClient.Get +// method. +func (client *SQLServerEsuLicensesClient) Get(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, options *SQLServerEsuLicensesClientGetOptions) (SQLServerEsuLicensesClientGetResponse, error) { + var err error + const operationName = "SQLServerEsuLicensesClient.Get" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getCreateRequest(ctx, resourceGroupName, sqlServerEsuLicenseName, options) + if err != nil { + return SQLServerEsuLicensesClientGetResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerEsuLicensesClientGetResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerEsuLicensesClientGetResponse{}, err + } + resp, err := client.getHandleResponse(httpResp) + return resp, err +} + +// getCreateRequest creates the Get request. +func (client *SQLServerEsuLicensesClient) getCreateRequest(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, options *SQLServerEsuLicensesClientGetOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerEsuLicenses/{sqlServerEsuLicenseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerEsuLicenseName == "" { + return nil, errors.New("parameter sqlServerEsuLicenseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerEsuLicenseName}", url.PathEscape(sqlServerEsuLicenseName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getHandleResponse handles the Get response. +func (client *SQLServerEsuLicensesClient) getHandleResponse(resp *http.Response) (SQLServerEsuLicensesClientGetResponse, error) { + result := SQLServerEsuLicensesClientGetResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerEsuLicense); err != nil { + return SQLServerEsuLicensesClientGetResponse{}, err + } + return result, nil +} + +// NewListPager - List sqlServerEsuLicense resources in the subscription +// +// Generated from API version 2024-05-01-preview +// - options - SQLServerEsuLicensesClientListOptions contains the optional parameters for the SQLServerEsuLicensesClient.NewListPager +// method. +func (client *SQLServerEsuLicensesClient) NewListPager(options *SQLServerEsuLicensesClientListOptions) *runtime.Pager[SQLServerEsuLicensesClientListResponse] { + return runtime.NewPager(runtime.PagingHandler[SQLServerEsuLicensesClientListResponse]{ + More: func(page SQLServerEsuLicensesClientListResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *SQLServerEsuLicensesClientListResponse) (SQLServerEsuLicensesClientListResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "SQLServerEsuLicensesClient.NewListPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listCreateRequest(ctx, options) + }, nil) + if err != nil { + return SQLServerEsuLicensesClientListResponse{}, err + } + return client.listHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listCreateRequest creates the List request. +func (client *SQLServerEsuLicensesClient) listCreateRequest(ctx context.Context, options *SQLServerEsuLicensesClientListOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.AzureArcData/sqlServerEsuLicenses" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listHandleResponse handles the List response. +func (client *SQLServerEsuLicensesClient) listHandleResponse(resp *http.Response) (SQLServerEsuLicensesClientListResponse, error) { + result := SQLServerEsuLicensesClientListResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerEsuLicenseListResult); err != nil { + return SQLServerEsuLicensesClientListResponse{}, err + } + return result, nil +} + +// NewListByResourceGroupPager - Gets all sqlServerEsuLicenses in a resource group. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - options - SQLServerEsuLicensesClientListByResourceGroupOptions contains the optional parameters for the SQLServerEsuLicensesClient.NewListByResourceGroupPager +// method. +func (client *SQLServerEsuLicensesClient) NewListByResourceGroupPager(resourceGroupName string, options *SQLServerEsuLicensesClientListByResourceGroupOptions) *runtime.Pager[SQLServerEsuLicensesClientListByResourceGroupResponse] { + return runtime.NewPager(runtime.PagingHandler[SQLServerEsuLicensesClientListByResourceGroupResponse]{ + More: func(page SQLServerEsuLicensesClientListByResourceGroupResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *SQLServerEsuLicensesClientListByResourceGroupResponse) (SQLServerEsuLicensesClientListByResourceGroupResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "SQLServerEsuLicensesClient.NewListByResourceGroupPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options) + }, nil) + if err != nil { + return SQLServerEsuLicensesClientListByResourceGroupResponse{}, err + } + return client.listByResourceGroupHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listByResourceGroupCreateRequest creates the ListByResourceGroup request. +func (client *SQLServerEsuLicensesClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, options *SQLServerEsuLicensesClientListByResourceGroupOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerEsuLicenses" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listByResourceGroupHandleResponse handles the ListByResourceGroup response. +func (client *SQLServerEsuLicensesClient) listByResourceGroupHandleResponse(resp *http.Response) (SQLServerEsuLicensesClientListByResourceGroupResponse, error) { + result := SQLServerEsuLicensesClientListByResourceGroupResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerEsuLicenseListResult); err != nil { + return SQLServerEsuLicensesClientListByResourceGroupResponse{}, err + } + return result, nil +} + +// Update - Updates a SQL Server ESU license resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - sqlServerEsuLicenseName - Name of SQL Server ESU License +// - parameters - The SQL Server ESU license. +// - options - SQLServerEsuLicensesClientUpdateOptions contains the optional parameters for the SQLServerEsuLicensesClient.Update +// method. +func (client *SQLServerEsuLicensesClient) Update(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, parameters SQLServerEsuLicenseUpdate, options *SQLServerEsuLicensesClientUpdateOptions) (SQLServerEsuLicensesClientUpdateResponse, error) { + var err error + const operationName = "SQLServerEsuLicensesClient.Update" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.updateCreateRequest(ctx, resourceGroupName, sqlServerEsuLicenseName, parameters, options) + if err != nil { + return SQLServerEsuLicensesClientUpdateResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerEsuLicensesClientUpdateResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerEsuLicensesClientUpdateResponse{}, err + } + resp, err := client.updateHandleResponse(httpResp) + return resp, err +} + +// updateCreateRequest creates the Update request. +func (client *SQLServerEsuLicensesClient) updateCreateRequest(ctx context.Context, resourceGroupName string, sqlServerEsuLicenseName string, parameters SQLServerEsuLicenseUpdate, options *SQLServerEsuLicensesClientUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerEsuLicenses/{sqlServerEsuLicenseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerEsuLicenseName == "" { + return nil, errors.New("parameter sqlServerEsuLicenseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerEsuLicenseName}", url.PathEscape(sqlServerEsuLicenseName)) + req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, parameters); err != nil { + return nil, err + } + return req, nil +} + +// updateHandleResponse handles the Update response. +func (client *SQLServerEsuLicensesClient) updateHandleResponse(resp *http.Response) (SQLServerEsuLicensesClientUpdateResponse, error) { + result := SQLServerEsuLicensesClientUpdateResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerEsuLicense); err != nil { + return SQLServerEsuLicensesClientUpdateResponse{}, err + } + return result, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverinstances_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverinstances_client.go index 11898415e53b..4094c7e95e09 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverinstances_client.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverinstances_client.go @@ -46,7 +46,7 @@ func NewSQLServerInstancesClient(subscriptionID string, credential azcore.TokenC // BeginCreate - Creates or replaces a SQL Server Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - sqlServerInstanceName - Name of SQL Server Instance // - sqlServerInstance - The SQL Server Instance to be created or updated. @@ -73,7 +73,7 @@ func (client *SQLServerInstancesClient) BeginCreate(ctx context.Context, resourc // Create - Creates or replaces a SQL Server Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *SQLServerInstancesClient) create(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, sqlServerInstance SQLServerInstance, options *SQLServerInstancesClientBeginCreateOptions) (*http.Response, error) { var err error const operationName = "SQLServerInstancesClient.BeginCreate" @@ -115,7 +115,7 @@ func (client *SQLServerInstancesClient) createCreateRequest(ctx context.Context, return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} if err := runtime.MarshalAsJSON(req, sqlServerInstance); err != nil { @@ -127,7 +127,7 @@ func (client *SQLServerInstancesClient) createCreateRequest(ctx context.Context, // BeginDelete - Deletes a SQL Server Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - sqlServerInstanceName - Name of SQL Server Instance // - options - SQLServerInstancesClientBeginDeleteOptions contains the optional parameters for the SQLServerInstancesClient.BeginDelete @@ -152,7 +152,7 @@ func (client *SQLServerInstancesClient) BeginDelete(ctx context.Context, resourc // Delete - Deletes a SQL Server Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview func (client *SQLServerInstancesClient) deleteOperation(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerInstancesClientBeginDeleteOptions) (*http.Response, error) { var err error const operationName = "SQLServerInstancesClient.BeginDelete" @@ -194,7 +194,7 @@ func (client *SQLServerInstancesClient) deleteCreateRequest(ctx context.Context, return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -203,7 +203,7 @@ func (client *SQLServerInstancesClient) deleteCreateRequest(ctx context.Context, // Get - Retrieves a SQL Server Instance resource // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - sqlServerInstanceName - Name of SQL Server Instance // - options - SQLServerInstancesClientGetOptions contains the optional parameters for the SQLServerInstancesClient.Get method. @@ -249,7 +249,7 @@ func (client *SQLServerInstancesClient) getCreateRequest(ctx context.Context, re return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -264,9 +264,186 @@ func (client *SQLServerInstancesClient) getHandleResponse(resp *http.Response) ( return result, nil } +// GetJobsStatus - Gets jobs status details for sql arc resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - options - SQLServerInstancesClientGetJobsStatusOptions contains the optional parameters for the SQLServerInstancesClient.GetJobsStatus +// method. +func (client *SQLServerInstancesClient) GetJobsStatus(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerInstancesClientGetJobsStatusOptions) (SQLServerInstancesClientGetJobsStatusResponse, error) { + var err error + const operationName = "SQLServerInstancesClient.GetJobsStatus" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getJobsStatusCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, options) + if err != nil { + return SQLServerInstancesClientGetJobsStatusResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerInstancesClientGetJobsStatusResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerInstancesClientGetJobsStatusResponse{}, err + } + resp, err := client.getJobsStatusHandleResponse(httpResp) + return resp, err +} + +// getJobsStatusCreateRequest creates the GetJobsStatus request. +func (client *SQLServerInstancesClient) getJobsStatusCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerInstancesClientGetJobsStatusOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/getJobsStatus" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if options != nil && options.SQLServerInstanceJobsStatusRequest != nil { + if err := runtime.MarshalAsJSON(req, *options.SQLServerInstanceJobsStatusRequest); err != nil { + return nil, err + } + return req, nil + } + return req, nil +} + +// getJobsStatusHandleResponse handles the GetJobsStatus response. +func (client *SQLServerInstancesClient) getJobsStatusHandleResponse(resp *http.Response) (SQLServerInstancesClientGetJobsStatusResponse, error) { + result := SQLServerInstancesClientGetJobsStatusResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerInstanceJobsStatusResponse); err != nil { + return SQLServerInstancesClientGetJobsStatusResponse{}, err + } + return result, nil +} + +// BeginGetTelemetry - Retrieves SQL Server instance telemetry +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - sqlServerInstanceTelemetryRequest - Contains the parameters to get SQL Server instance telemetry. +// - options - SQLServerInstancesClientBeginGetTelemetryOptions contains the optional parameters for the SQLServerInstancesClient.BeginGetTelemetry +// method. +func (client *SQLServerInstancesClient) BeginGetTelemetry(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, sqlServerInstanceTelemetryRequest SQLServerInstanceTelemetryRequest, options *SQLServerInstancesClientBeginGetTelemetryOptions) (*runtime.Poller[*runtime.Pager[SQLServerInstancesClientGetTelemetryResponse]], error) { + pager := runtime.NewPager(runtime.PagingHandler[SQLServerInstancesClientGetTelemetryResponse]{ + More: func(page SQLServerInstancesClientGetTelemetryResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *SQLServerInstancesClientGetTelemetryResponse) (SQLServerInstancesClientGetTelemetryResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "SQLServerInstancesClient.BeginGetTelemetry") + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), *page.NextLink, func(ctx context.Context) (*policy.Request, error) { + return client.getTelemetryCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, sqlServerInstanceTelemetryRequest, options) + }, nil) + if err != nil { + return SQLServerInstancesClientGetTelemetryResponse{}, err + } + return client.getTelemetryHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) + if options == nil || options.ResumeToken == "" { + resp, err := client.getTelemetry(ctx, resourceGroupName, sqlServerInstanceName, sqlServerInstanceTelemetryRequest, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[*runtime.Pager[SQLServerInstancesClientGetTelemetryResponse]]{ + FinalStateVia: runtime.FinalStateViaAzureAsyncOp, + Response: &pager, + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[*runtime.Pager[SQLServerInstancesClientGetTelemetryResponse]]{ + Response: &pager, + Tracer: client.internal.Tracer(), + }) + } +} + +// GetTelemetry - Retrieves SQL Server instance telemetry +// +// Generated from API version 2024-05-01-preview +func (client *SQLServerInstancesClient) getTelemetry(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, sqlServerInstanceTelemetryRequest SQLServerInstanceTelemetryRequest, options *SQLServerInstancesClientBeginGetTelemetryOptions) (*http.Response, error) { + var err error + const operationName = "SQLServerInstancesClient.BeginGetTelemetry" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getTelemetryCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, sqlServerInstanceTelemetryRequest, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// getTelemetryCreateRequest creates the GetTelemetry request. +func (client *SQLServerInstancesClient) getTelemetryCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, sqlServerInstanceTelemetryRequest SQLServerInstanceTelemetryRequest, options *SQLServerInstancesClientBeginGetTelemetryOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/getTelemetry" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, sqlServerInstanceTelemetryRequest); err != nil { + return nil, err + } + return req, nil +} + +// getTelemetryHandleResponse handles the GetTelemetry response. +func (client *SQLServerInstancesClient) getTelemetryHandleResponse(resp *http.Response) (SQLServerInstancesClientGetTelemetryResponse, error) { + result := SQLServerInstancesClientGetTelemetryResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerInstanceTelemetryResponse); err != nil { + return SQLServerInstancesClientGetTelemetryResponse{}, err + } + return result, nil +} + // NewListPager - List sqlServerInstance resources in the subscription // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - options - SQLServerInstancesClientListOptions contains the optional parameters for the SQLServerInstancesClient.NewListPager // method. func (client *SQLServerInstancesClient) NewListPager(options *SQLServerInstancesClientListOptions) *runtime.Pager[SQLServerInstancesClientListResponse] { @@ -304,7 +481,7 @@ func (client *SQLServerInstancesClient) listCreateRequest(ctx context.Context, o return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -321,7 +498,7 @@ func (client *SQLServerInstancesClient) listHandleResponse(resp *http.Response) // NewListByResourceGroupPager - Gets all sqlServerInstances in a resource group. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - options - SQLServerInstancesClientListByResourceGroupOptions contains the optional parameters for the SQLServerInstancesClient.NewListByResourceGroupPager // method. @@ -364,7 +541,7 @@ func (client *SQLServerInstancesClient) listByResourceGroupCreateRequest(ctx con return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -379,40 +556,39 @@ func (client *SQLServerInstancesClient) listByResourceGroupHandleResponse(resp * return result, nil } -// Update - Updates a SQL Server Instance resource +// PostUpgrade - Clean up after upgrading. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2022-03-01-preview +// Generated from API version 2024-05-01-preview // - resourceGroupName - The name of the Azure resource group // - sqlServerInstanceName - Name of SQL Server Instance -// - parameters - The SQL Server Instance. -// - options - SQLServerInstancesClientUpdateOptions contains the optional parameters for the SQLServerInstancesClient.Update +// - options - SQLServerInstancesClientPostUpgradeOptions contains the optional parameters for the SQLServerInstancesClient.PostUpgrade // method. -func (client *SQLServerInstancesClient) Update(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, parameters SQLServerInstanceUpdate, options *SQLServerInstancesClientUpdateOptions) (SQLServerInstancesClientUpdateResponse, error) { +func (client *SQLServerInstancesClient) PostUpgrade(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerInstancesClientPostUpgradeOptions) (SQLServerInstancesClientPostUpgradeResponse, error) { var err error - const operationName = "SQLServerInstancesClient.Update" + const operationName = "SQLServerInstancesClient.PostUpgrade" ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) defer func() { endSpan(err) }() - req, err := client.updateCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, parameters, options) + req, err := client.postUpgradeCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, options) if err != nil { - return SQLServerInstancesClientUpdateResponse{}, err + return SQLServerInstancesClientPostUpgradeResponse{}, err } httpResp, err := client.internal.Pipeline().Do(req) if err != nil { - return SQLServerInstancesClientUpdateResponse{}, err + return SQLServerInstancesClientPostUpgradeResponse{}, err } if !runtime.HasStatusCode(httpResp, http.StatusOK) { err = runtime.NewResponseError(httpResp) - return SQLServerInstancesClientUpdateResponse{}, err + return SQLServerInstancesClientPostUpgradeResponse{}, err } - resp, err := client.updateHandleResponse(httpResp) + resp, err := client.postUpgradeHandleResponse(httpResp) return resp, err } -// updateCreateRequest creates the Update request. -func (client *SQLServerInstancesClient) updateCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, parameters SQLServerInstanceUpdate, options *SQLServerInstancesClientUpdateOptions) (*policy.Request, error) { - urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}" +// postUpgradeCreateRequest creates the PostUpgrade request. +func (client *SQLServerInstancesClient) postUpgradeCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerInstancesClientPostUpgradeOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/postUpgrade" if client.subscriptionID == "" { return nil, errors.New("parameter client.subscriptionID cannot be empty") } @@ -425,25 +601,233 @@ func (client *SQLServerInstancesClient) updateCreateRequest(ctx context.Context, return nil, errors.New("parameter sqlServerInstanceName cannot be empty") } urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) - req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) if err != nil { return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2022-03-01-preview") + reqQP.Set("api-version", "2024-05-01-preview") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} - if err := runtime.MarshalAsJSON(req, parameters); err != nil { + return req, nil +} + +// postUpgradeHandleResponse handles the PostUpgrade response. +func (client *SQLServerInstancesClient) postUpgradeHandleResponse(resp *http.Response) (SQLServerInstancesClientPostUpgradeResponse, error) { + result := SQLServerInstancesClientPostUpgradeResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerInstance); err != nil { + return SQLServerInstancesClientPostUpgradeResponse{}, err + } + return result, nil +} + +// PreUpgrade - Request Upgrade Permission before upgrading. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - options - SQLServerInstancesClientPreUpgradeOptions contains the optional parameters for the SQLServerInstancesClient.PreUpgrade +// method. +func (client *SQLServerInstancesClient) PreUpgrade(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerInstancesClientPreUpgradeOptions) (SQLServerInstancesClientPreUpgradeResponse, error) { + var err error + const operationName = "SQLServerInstancesClient.PreUpgrade" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.preUpgradeCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, options) + if err != nil { + return SQLServerInstancesClientPreUpgradeResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerInstancesClientPreUpgradeResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerInstancesClientPreUpgradeResponse{}, err + } + resp, err := client.preUpgradeHandleResponse(httpResp) + return resp, err +} + +// preUpgradeCreateRequest creates the PreUpgrade request. +func (client *SQLServerInstancesClient) preUpgradeCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerInstancesClientPreUpgradeOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/preUpgrade" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { return nil, err } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} return req, nil } -// updateHandleResponse handles the Update response. -func (client *SQLServerInstancesClient) updateHandleResponse(resp *http.Response) (SQLServerInstancesClientUpdateResponse, error) { - result := SQLServerInstancesClientUpdateResponse{} +// preUpgradeHandleResponse handles the PreUpgrade response. +func (client *SQLServerInstancesClient) preUpgradeHandleResponse(resp *http.Response) (SQLServerInstancesClientPreUpgradeResponse, error) { + result := SQLServerInstancesClientPreUpgradeResponse{} if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerInstance); err != nil { - return SQLServerInstancesClientUpdateResponse{}, err + return SQLServerInstancesClientPreUpgradeResponse{}, err } return result, nil } + +// RunMigrationAssessment - Runs migration assessment for SQL Server instance +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - options - SQLServerInstancesClientRunMigrationAssessmentOptions contains the optional parameters for the SQLServerInstancesClient.RunMigrationAssessment +// method. +func (client *SQLServerInstancesClient) RunMigrationAssessment(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerInstancesClientRunMigrationAssessmentOptions) (SQLServerInstancesClientRunMigrationAssessmentResponse, error) { + var err error + const operationName = "SQLServerInstancesClient.RunMigrationAssessment" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.runMigrationAssessmentCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, options) + if err != nil { + return SQLServerInstancesClientRunMigrationAssessmentResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerInstancesClientRunMigrationAssessmentResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerInstancesClientRunMigrationAssessmentResponse{}, err + } + resp, err := client.runMigrationAssessmentHandleResponse(httpResp) + return resp, err +} + +// runMigrationAssessmentCreateRequest creates the RunMigrationAssessment request. +func (client *SQLServerInstancesClient) runMigrationAssessmentCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, options *SQLServerInstancesClientRunMigrationAssessmentOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}/runMigrationAssessment" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// runMigrationAssessmentHandleResponse handles the RunMigrationAssessment response. +func (client *SQLServerInstancesClient) runMigrationAssessmentHandleResponse(resp *http.Response) (SQLServerInstancesClientRunMigrationAssessmentResponse, error) { + result := SQLServerInstancesClientRunMigrationAssessmentResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerInstanceRunMigrationAssessmentResponse); err != nil { + return SQLServerInstancesClientRunMigrationAssessmentResponse{}, err + } + return result, nil +} + +// BeginUpdate - Updates a SQL Server Instance resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerInstanceName - Name of SQL Server Instance +// - parameters - The SQL Server Instance. +// - options - SQLServerInstancesClientBeginUpdateOptions contains the optional parameters for the SQLServerInstancesClient.BeginUpdate +// method. +func (client *SQLServerInstancesClient) BeginUpdate(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, parameters SQLServerInstanceUpdate, options *SQLServerInstancesClientBeginUpdateOptions) (*runtime.Poller[SQLServerInstancesClientUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.update(ctx, resourceGroupName, sqlServerInstanceName, parameters, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[SQLServerInstancesClientUpdateResponse]{ + FinalStateVia: runtime.FinalStateViaAzureAsyncOp, + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[SQLServerInstancesClientUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Update - Updates a SQL Server Instance resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +func (client *SQLServerInstancesClient) update(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, parameters SQLServerInstanceUpdate, options *SQLServerInstancesClientBeginUpdateOptions) (*http.Response, error) { + var err error + const operationName = "SQLServerInstancesClient.BeginUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.updateCreateRequest(ctx, resourceGroupName, sqlServerInstanceName, parameters, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// updateCreateRequest creates the Update request. +func (client *SQLServerInstancesClient) updateCreateRequest(ctx context.Context, resourceGroupName string, sqlServerInstanceName string, parameters SQLServerInstanceUpdate, options *SQLServerInstancesClientBeginUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerInstances/{sqlServerInstanceName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerInstanceName == "" { + return nil, errors.New("parameter sqlServerInstanceName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerInstanceName}", url.PathEscape(sqlServerInstanceName)) + req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, parameters); err != nil { + return nil, err + } + return req, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverinstances_client_example_test.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverinstances_client_example_test.go deleted file mode 100644 index 2566ba30eb27..000000000000 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverinstances_client_example_test.go +++ /dev/null @@ -1,439 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armazurearcdata_test - -import ( - "context" - "log" - - "time" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/azurearcdata/armazurearcdata" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/ListSubscriptionSqlServerInstance.json -func ExampleSQLServerInstancesClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewSQLServerInstancesClient().NewListPager(nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.SQLServerInstanceListResult = armazurearcdata.SQLServerInstanceListResult{ - // Value: []*armazurearcdata.SQLServerInstance{ - // { - // Name: to.Ptr("sqlServerInstance1"), - // Type: to.Ptr("Microsoft.AzureArcData/SqlServerInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/SqlServerInstances/sqlServerInstance1"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // Properties: &armazurearcdata.SQLServerInstanceProperties{ - // AzureDefenderStatus: to.Ptr(armazurearcdata.DefenderStatusProtected), - // AzureDefenderStatusLastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // Collation: to.Ptr("collation"), - // ContainerResourceID: to.Ptr("Resource id of hosting Arc Machine"), - // CreateTime: to.Ptr("01/01/2020 01:01:01"), - // CurrentVersion: to.Ptr("2008 R2"), - // Edition: to.Ptr(armazurearcdata.EditionTypeDeveloper), - // HostType: to.Ptr(armazurearcdata.HostTypePhysicalServer), - // InstanceName: to.Ptr("name of instance"), - // LicenseType: to.Ptr(armazurearcdata.ArcSQLServerLicenseTypeFree), - // PatchLevel: to.Ptr("patchlevel"), - // ProductID: to.Ptr("sql id"), - // Status: to.Ptr(armazurearcdata.ConnectionStatusRegistered), - // TCPDynamicPorts: to.Ptr("1433"), - // TCPStaticPorts: to.Ptr("1433"), - // VCore: to.Ptr("4"), - // Version: to.Ptr(armazurearcdata.SQLVersionSQLServer2012), - // }, - // }, - // { - // Name: to.Ptr("sqlServerInstance2"), - // Type: to.Ptr("Microsoft.AzureArcData/SqlServerInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/SqlServerInstances/sqlServerInstance2"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // Properties: &armazurearcdata.SQLServerInstanceProperties{ - // AzureDefenderStatus: to.Ptr(armazurearcdata.DefenderStatusProtected), - // AzureDefenderStatusLastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // Collation: to.Ptr("collation"), - // ContainerResourceID: to.Ptr("Arc Machine Name"), - // CreateTime: to.Ptr("01/01/2020 01:01:01"), - // CurrentVersion: to.Ptr("2008 R2"), - // Edition: to.Ptr(armazurearcdata.EditionTypeDeveloper), - // InstanceName: to.Ptr("name of instance"), - // LicenseType: to.Ptr(armazurearcdata.ArcSQLServerLicenseTypeFree), - // PatchLevel: to.Ptr("patchlevel"), - // ProductID: to.Ptr("sql id"), - // Status: to.Ptr(armazurearcdata.ConnectionStatusConnected), - // TCPDynamicPorts: to.Ptr("1433"), - // TCPStaticPorts: to.Ptr("1433"), - // VCore: to.Ptr("4"), - // Version: to.Ptr(armazurearcdata.SQLVersionSQLServer2017), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/ListByResourceGroupSqlServerInstance.json -func ExampleSQLServerInstancesClient_NewListByResourceGroupPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewSQLServerInstancesClient().NewListByResourceGroupPager("testrg", nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.SQLServerInstanceListResult = armazurearcdata.SQLServerInstanceListResult{ - // Value: []*armazurearcdata.SQLServerInstance{ - // { - // Name: to.Ptr("sqlServerInstance1"), - // Type: to.Ptr("Microsoft.AzureArcData/SqlServerInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/SqlServerInstances/sqlServerInstance1"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // Properties: &armazurearcdata.SQLServerInstanceProperties{ - // AzureDefenderStatus: to.Ptr(armazurearcdata.DefenderStatusProtected), - // AzureDefenderStatusLastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // Collation: to.Ptr("collation"), - // ContainerResourceID: to.Ptr("Resource id of hosting Arc Machine"), - // CreateTime: to.Ptr("01/01/2020 01:01:01"), - // CurrentVersion: to.Ptr("2012"), - // Edition: to.Ptr(armazurearcdata.EditionTypeDeveloper), - // HostType: to.Ptr(armazurearcdata.HostTypePhysicalServer), - // InstanceName: to.Ptr("name of instance"), - // LicenseType: to.Ptr(armazurearcdata.ArcSQLServerLicenseTypeFree), - // PatchLevel: to.Ptr("patchlevel"), - // ProductID: to.Ptr("sql id"), - // Status: to.Ptr(armazurearcdata.ConnectionStatusRegistered), - // TCPDynamicPorts: to.Ptr("1433"), - // TCPStaticPorts: to.Ptr("1433"), - // VCore: to.Ptr("4"), - // Version: to.Ptr(armazurearcdata.SQLVersionSQLServer2012), - // }, - // }, - // { - // Name: to.Ptr("sqlServerInstance2"), - // Type: to.Ptr("Microsoft.AzureArcData/SqlServerInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/SqlServerInstances/sqlServerInstance2"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // Properties: &armazurearcdata.SQLServerInstanceProperties{ - // AzureDefenderStatus: to.Ptr(armazurearcdata.DefenderStatusProtected), - // AzureDefenderStatusLastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // Collation: to.Ptr("collation"), - // ContainerResourceID: to.Ptr("Arc Machine Name"), - // CreateTime: to.Ptr("01/01/2020 01:01:01"), - // CurrentVersion: to.Ptr("2008 R2"), - // Edition: to.Ptr(armazurearcdata.EditionTypeDeveloper), - // InstanceName: to.Ptr("name of instance"), - // LicenseType: to.Ptr(armazurearcdata.ArcSQLServerLicenseTypeFree), - // PatchLevel: to.Ptr("patchlevel"), - // ProductID: to.Ptr("sql id"), - // Status: to.Ptr(armazurearcdata.ConnectionStatusConnected), - // TCPDynamicPorts: to.Ptr("1433"), - // TCPStaticPorts: to.Ptr("1433"), - // VCore: to.Ptr("4"), - // Version: to.Ptr(armazurearcdata.SQLVersionSQLServer2017), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/GetSqlServerInstance.json -func ExampleSQLServerInstancesClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewSQLServerInstancesClient().Get(ctx, "testrg", "testsqlServerInstance", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.SQLServerInstance = armazurearcdata.SQLServerInstance{ - // Name: to.Ptr("testsqlServerInstance"), - // Type: to.Ptr("Microsoft.AzureArcData/SqlServerInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/SqlServerInstances/testsqlServerInstance"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // Properties: &armazurearcdata.SQLServerInstanceProperties{ - // AzureDefenderStatus: to.Ptr(armazurearcdata.DefenderStatusProtected), - // AzureDefenderStatusLastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // Collation: to.Ptr("collation"), - // ContainerResourceID: to.Ptr("Resource id of hosting Arc Machine"), - // CreateTime: to.Ptr("01/01/2020 01:01:01"), - // CurrentVersion: to.Ptr("2012"), - // Edition: to.Ptr(armazurearcdata.EditionTypeDeveloper), - // HostType: to.Ptr(armazurearcdata.HostTypePhysicalServer), - // InstanceName: to.Ptr("name of instance"), - // LicenseType: to.Ptr(armazurearcdata.ArcSQLServerLicenseTypeFree), - // PatchLevel: to.Ptr("patchlevel"), - // ProductID: to.Ptr("sql id"), - // Status: to.Ptr(armazurearcdata.ConnectionStatusRegistered), - // TCPDynamicPorts: to.Ptr("1433"), - // TCPStaticPorts: to.Ptr("1433"), - // VCore: to.Ptr("4"), - // Version: to.Ptr(armazurearcdata.SQLVersionSQLServer2012), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/CreateOrUpdateSqlServerInstance.json -func ExampleSQLServerInstancesClient_BeginCreate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewSQLServerInstancesClient().BeginCreate(ctx, "testrg", "testsqlServerInstance", armazurearcdata.SQLServerInstance{ - Location: to.Ptr("northeurope"), - Tags: map[string]*string{ - "mytag": to.Ptr("myval"), - }, - Properties: &armazurearcdata.SQLServerInstanceProperties{ - AzureDefenderStatus: to.Ptr(armazurearcdata.DefenderStatusProtected), - AzureDefenderStatusLastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t }()), - Collation: to.Ptr("collation"), - ContainerResourceID: to.Ptr("Resource id of hosting Arc Machine"), - CurrentVersion: to.Ptr("2012"), - Edition: to.Ptr(armazurearcdata.EditionTypeDeveloper), - HostType: to.Ptr(armazurearcdata.HostTypePhysicalServer), - InstanceName: to.Ptr("name of instance"), - LicenseType: to.Ptr(armazurearcdata.ArcSQLServerLicenseTypeFree), - PatchLevel: to.Ptr("patchlevel"), - ProductID: to.Ptr("sql id"), - Status: to.Ptr(armazurearcdata.ConnectionStatusRegistered), - TCPDynamicPorts: to.Ptr("1433"), - TCPStaticPorts: to.Ptr("1433"), - VCore: to.Ptr("4"), - Version: to.Ptr(armazurearcdata.SQLVersionSQLServer2012), - }, - }, nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - res, err := poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.SQLServerInstance = armazurearcdata.SQLServerInstance{ - // Name: to.Ptr("testsqlServerInstance"), - // Type: to.Ptr("Microsoft.AzureArcData/SqlServerInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/SqlServerInstances/testsqlServerInstance"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // Properties: &armazurearcdata.SQLServerInstanceProperties{ - // AzureDefenderStatus: to.Ptr(armazurearcdata.DefenderStatusProtected), - // AzureDefenderStatusLastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // Collation: to.Ptr("collation"), - // ContainerResourceID: to.Ptr("Resource id of hosting Arc Machine"), - // CreateTime: to.Ptr("01/01/2020 01:01:01"), - // CurrentVersion: to.Ptr("2012"), - // Edition: to.Ptr(armazurearcdata.EditionTypeDeveloper), - // HostType: to.Ptr(armazurearcdata.HostTypePhysicalServer), - // InstanceName: to.Ptr("name of instance"), - // LicenseType: to.Ptr(armazurearcdata.ArcSQLServerLicenseTypeFree), - // PatchLevel: to.Ptr("patchlevel"), - // ProductID: to.Ptr("sql id"), - // Status: to.Ptr(armazurearcdata.ConnectionStatusRegistered), - // TCPDynamicPorts: to.Ptr("1433"), - // TCPStaticPorts: to.Ptr("1433"), - // VCore: to.Ptr("4"), - // Version: to.Ptr(armazurearcdata.SQLVersionSQLServer2012), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/DeleteSqlServerInstance.json -func ExampleSQLServerInstancesClient_BeginDelete() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewSQLServerInstancesClient().BeginDelete(ctx, "testrg", "testsqlServerInstance", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - _, err = poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/azurearcdata/resource-manager/Microsoft.AzureArcData/preview/2022-03-01-preview/examples/UpdateSqlServerInstance.json -func ExampleSQLServerInstancesClient_Update() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armazurearcdata.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewSQLServerInstancesClient().Update(ctx, "testrg", "testsqlServerInstance", armazurearcdata.SQLServerInstanceUpdate{ - Tags: map[string]*string{ - "mytag": to.Ptr("myval"), - }, - }, nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // You could use response here. We use blank identifier for just demo purposes. - _ = res - // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // res.SQLServerInstance = armazurearcdata.SQLServerInstance{ - // Name: to.Ptr("testsqlServerInstance"), - // Type: to.Ptr("Microsoft.AzureArcData/SqlServerInstances"), - // ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.AzureArcData/SqlServerInstances/testsqlServerInstance"), - // SystemData: &armazurearcdata.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()), - // CreatedBy: to.Ptr("user1"), - // CreatedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // LastModifiedBy: to.Ptr("user2"), - // LastModifiedByType: to.Ptr(armazurearcdata.CreatedByTypeUser), - // }, - // Location: to.Ptr("northeurope"), - // Tags: map[string]*string{ - // "mytag": to.Ptr("myval"), - // }, - // Properties: &armazurearcdata.SQLServerInstanceProperties{ - // AzureDefenderStatus: to.Ptr(armazurearcdata.DefenderStatusProtected), - // AzureDefenderStatusLastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()), - // Collation: to.Ptr("collation"), - // ContainerResourceID: to.Ptr("Resource id of hosting Arc Machine"), - // CreateTime: to.Ptr("01/01/2020 01:01:01"), - // CurrentVersion: to.Ptr("2012"), - // Edition: to.Ptr(armazurearcdata.EditionTypeDeveloper), - // HostType: to.Ptr(armazurearcdata.HostTypePhysicalServer), - // InstanceName: to.Ptr("name of instance"), - // LicenseType: to.Ptr(armazurearcdata.ArcSQLServerLicenseTypeFree), - // PatchLevel: to.Ptr("patchlevel"), - // ProductID: to.Ptr("sql id"), - // Status: to.Ptr(armazurearcdata.ConnectionStatusRegistered), - // TCPDynamicPorts: to.Ptr("1433"), - // TCPStaticPorts: to.Ptr("1433"), - // VCore: to.Ptr("4"), - // Version: to.Ptr(armazurearcdata.SQLVersionSQLServer2012), - // }, - // } -} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverlicenses_client.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverlicenses_client.go new file mode 100644 index 000000000000..b7667801cb0d --- /dev/null +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/sqlserverlicenses_client.go @@ -0,0 +1,416 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +package armazurearcdata + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// SQLServerLicensesClient contains the methods for the SQLServerLicenses group. +// Don't use this type directly, use NewSQLServerLicensesClient() instead. +type SQLServerLicensesClient struct { + internal *arm.Client + subscriptionID string +} + +// NewSQLServerLicensesClient creates a new instance of SQLServerLicensesClient with the specified values. +// - subscriptionID - The ID of the Azure subscription +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewSQLServerLicensesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SQLServerLicensesClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &SQLServerLicensesClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// Create - Creates or replaces a SQL Server license resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerLicenseName - Name of SQL Server License +// - sqlServerLicense - The SQL Server license to be created or updated. +// - options - SQLServerLicensesClientCreateOptions contains the optional parameters for the SQLServerLicensesClient.Create +// method. +func (client *SQLServerLicensesClient) Create(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, sqlServerLicense SQLServerLicense, options *SQLServerLicensesClientCreateOptions) (SQLServerLicensesClientCreateResponse, error) { + var err error + const operationName = "SQLServerLicensesClient.Create" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createCreateRequest(ctx, resourceGroupName, sqlServerLicenseName, sqlServerLicense, options) + if err != nil { + return SQLServerLicensesClientCreateResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerLicensesClientCreateResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusCreated) { + err = runtime.NewResponseError(httpResp) + return SQLServerLicensesClientCreateResponse{}, err + } + resp, err := client.createHandleResponse(httpResp) + return resp, err +} + +// createCreateRequest creates the Create request. +func (client *SQLServerLicensesClient) createCreateRequest(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, sqlServerLicense SQLServerLicense, options *SQLServerLicensesClientCreateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerLicenses/{sqlServerLicenseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerLicenseName == "" { + return nil, errors.New("parameter sqlServerLicenseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerLicenseName}", url.PathEscape(sqlServerLicenseName)) + req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, sqlServerLicense); err != nil { + return nil, err + } + return req, nil +} + +// createHandleResponse handles the Create response. +func (client *SQLServerLicensesClient) createHandleResponse(resp *http.Response) (SQLServerLicensesClientCreateResponse, error) { + result := SQLServerLicensesClientCreateResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerLicense); err != nil { + return SQLServerLicensesClientCreateResponse{}, err + } + return result, nil +} + +// Delete - Deletes a SQL Server license resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerLicenseName - Name of SQL Server License +// - options - SQLServerLicensesClientDeleteOptions contains the optional parameters for the SQLServerLicensesClient.Delete +// method. +func (client *SQLServerLicensesClient) Delete(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, options *SQLServerLicensesClientDeleteOptions) (SQLServerLicensesClientDeleteResponse, error) { + var err error + const operationName = "SQLServerLicensesClient.Delete" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.deleteCreateRequest(ctx, resourceGroupName, sqlServerLicenseName, options) + if err != nil { + return SQLServerLicensesClientDeleteResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerLicensesClientDeleteResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusNoContent) { + err = runtime.NewResponseError(httpResp) + return SQLServerLicensesClientDeleteResponse{}, err + } + return SQLServerLicensesClientDeleteResponse{}, nil +} + +// deleteCreateRequest creates the Delete request. +func (client *SQLServerLicensesClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, options *SQLServerLicensesClientDeleteOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerLicenses/{sqlServerLicenseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerLicenseName == "" { + return nil, errors.New("parameter sqlServerLicenseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerLicenseName}", url.PathEscape(sqlServerLicenseName)) + req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// Get - Retrieves a SQL Server license resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerLicenseName - Name of SQL Server License +// - options - SQLServerLicensesClientGetOptions contains the optional parameters for the SQLServerLicensesClient.Get method. +func (client *SQLServerLicensesClient) Get(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, options *SQLServerLicensesClientGetOptions) (SQLServerLicensesClientGetResponse, error) { + var err error + const operationName = "SQLServerLicensesClient.Get" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getCreateRequest(ctx, resourceGroupName, sqlServerLicenseName, options) + if err != nil { + return SQLServerLicensesClientGetResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerLicensesClientGetResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerLicensesClientGetResponse{}, err + } + resp, err := client.getHandleResponse(httpResp) + return resp, err +} + +// getCreateRequest creates the Get request. +func (client *SQLServerLicensesClient) getCreateRequest(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, options *SQLServerLicensesClientGetOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerLicenses/{sqlServerLicenseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerLicenseName == "" { + return nil, errors.New("parameter sqlServerLicenseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerLicenseName}", url.PathEscape(sqlServerLicenseName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getHandleResponse handles the Get response. +func (client *SQLServerLicensesClient) getHandleResponse(resp *http.Response) (SQLServerLicensesClientGetResponse, error) { + result := SQLServerLicensesClientGetResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerLicense); err != nil { + return SQLServerLicensesClientGetResponse{}, err + } + return result, nil +} + +// NewListPager - List sqlServerLicense resources in the subscription +// +// Generated from API version 2024-05-01-preview +// - options - SQLServerLicensesClientListOptions contains the optional parameters for the SQLServerLicensesClient.NewListPager +// method. +func (client *SQLServerLicensesClient) NewListPager(options *SQLServerLicensesClientListOptions) *runtime.Pager[SQLServerLicensesClientListResponse] { + return runtime.NewPager(runtime.PagingHandler[SQLServerLicensesClientListResponse]{ + More: func(page SQLServerLicensesClientListResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *SQLServerLicensesClientListResponse) (SQLServerLicensesClientListResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "SQLServerLicensesClient.NewListPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listCreateRequest(ctx, options) + }, nil) + if err != nil { + return SQLServerLicensesClientListResponse{}, err + } + return client.listHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listCreateRequest creates the List request. +func (client *SQLServerLicensesClient) listCreateRequest(ctx context.Context, options *SQLServerLicensesClientListOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.AzureArcData/sqlServerLicenses" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listHandleResponse handles the List response. +func (client *SQLServerLicensesClient) listHandleResponse(resp *http.Response) (SQLServerLicensesClientListResponse, error) { + result := SQLServerLicensesClientListResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerLicenseListResult); err != nil { + return SQLServerLicensesClientListResponse{}, err + } + return result, nil +} + +// NewListByResourceGroupPager - Gets all sqlServerLicenses in a resource group. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - options - SQLServerLicensesClientListByResourceGroupOptions contains the optional parameters for the SQLServerLicensesClient.NewListByResourceGroupPager +// method. +func (client *SQLServerLicensesClient) NewListByResourceGroupPager(resourceGroupName string, options *SQLServerLicensesClientListByResourceGroupOptions) *runtime.Pager[SQLServerLicensesClientListByResourceGroupResponse] { + return runtime.NewPager(runtime.PagingHandler[SQLServerLicensesClientListByResourceGroupResponse]{ + More: func(page SQLServerLicensesClientListByResourceGroupResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *SQLServerLicensesClientListByResourceGroupResponse) (SQLServerLicensesClientListByResourceGroupResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "SQLServerLicensesClient.NewListByResourceGroupPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options) + }, nil) + if err != nil { + return SQLServerLicensesClientListByResourceGroupResponse{}, err + } + return client.listByResourceGroupHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listByResourceGroupCreateRequest creates the ListByResourceGroup request. +func (client *SQLServerLicensesClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, options *SQLServerLicensesClientListByResourceGroupOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerLicenses" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listByResourceGroupHandleResponse handles the ListByResourceGroup response. +func (client *SQLServerLicensesClient) listByResourceGroupHandleResponse(resp *http.Response) (SQLServerLicensesClientListByResourceGroupResponse, error) { + result := SQLServerLicensesClientListByResourceGroupResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerLicenseListResult); err != nil { + return SQLServerLicensesClientListByResourceGroupResponse{}, err + } + return result, nil +} + +// Update - Updates a SQL Server license resource +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-05-01-preview +// - resourceGroupName - The name of the Azure resource group +// - sqlServerLicenseName - Name of SQL Server License +// - parameters - The SQL Server license. +// - options - SQLServerLicensesClientUpdateOptions contains the optional parameters for the SQLServerLicensesClient.Update +// method. +func (client *SQLServerLicensesClient) Update(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, parameters SQLServerLicenseUpdate, options *SQLServerLicensesClientUpdateOptions) (SQLServerLicensesClientUpdateResponse, error) { + var err error + const operationName = "SQLServerLicensesClient.Update" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.updateCreateRequest(ctx, resourceGroupName, sqlServerLicenseName, parameters, options) + if err != nil { + return SQLServerLicensesClientUpdateResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SQLServerLicensesClientUpdateResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SQLServerLicensesClientUpdateResponse{}, err + } + resp, err := client.updateHandleResponse(httpResp) + return resp, err +} + +// updateCreateRequest creates the Update request. +func (client *SQLServerLicensesClient) updateCreateRequest(ctx context.Context, resourceGroupName string, sqlServerLicenseName string, parameters SQLServerLicenseUpdate, options *SQLServerLicensesClientUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureArcData/sqlServerLicenses/{sqlServerLicenseName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if sqlServerLicenseName == "" { + return nil, errors.New("parameter sqlServerLicenseName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{sqlServerLicenseName}", url.PathEscape(sqlServerLicenseName)) + req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-05-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, parameters); err != nil { + return nil, err + } + return req, nil +} + +// updateHandleResponse handles the Update response. +func (client *SQLServerLicensesClient) updateHandleResponse(resp *http.Response) (SQLServerLicensesClientUpdateResponse, error) { + result := SQLServerLicensesClientUpdateResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SQLServerLicense); err != nil { + return SQLServerLicensesClientUpdateResponse{}, err + } + return result, nil +} diff --git a/sdk/resourcemanager/azurearcdata/armazurearcdata/time_rfc3339.go b/sdk/resourcemanager/azurearcdata/armazurearcdata/time_rfc3339.go index 845b7d5a9330..33592f0a526c 100644 --- a/sdk/resourcemanager/azurearcdata/armazurearcdata/time_rfc3339.go +++ b/sdk/resourcemanager/azurearcdata/armazurearcdata/time_rfc3339.go @@ -19,12 +19,16 @@ import ( ) // Azure reports time in UTC but it doesn't include the 'Z' time zone suffix in some cases. -var tzOffsetRegex = regexp.MustCompile(`(Z|z|\+|-)(\d+:\d+)*"*$`) +var tzOffsetRegex = regexp.MustCompile(`(?:Z|z|\+|-)(?:\d+:\d+)*"*$`) const ( - utcDateTimeJSON = `"2006-01-02T15:04:05.999999999"` - utcDateTime = "2006-01-02T15:04:05.999999999" - dateTimeJSON = `"` + time.RFC3339Nano + `"` + utcDateTime = "2006-01-02T15:04:05.999999999" + utcDateTimeJSON = `"` + utcDateTime + `"` + utcDateTimeNoT = "2006-01-02 15:04:05.999999999" + utcDateTimeJSONNoT = `"` + utcDateTimeNoT + `"` + dateTimeNoT = `2006-01-02 15:04:05.999999999Z07:00` + dateTimeJSON = `"` + time.RFC3339Nano + `"` + dateTimeJSONNoT = `"` + dateTimeNoT + `"` ) type dateTimeRFC3339 time.Time @@ -40,17 +44,33 @@ func (t dateTimeRFC3339) MarshalText() ([]byte, error) { } func (t *dateTimeRFC3339) UnmarshalJSON(data []byte) error { - layout := utcDateTimeJSON - if tzOffsetRegex.Match(data) { + tzOffset := tzOffsetRegex.Match(data) + hasT := strings.Contains(string(data), "T") || strings.Contains(string(data), "t") + var layout string + if tzOffset && hasT { layout = dateTimeJSON + } else if tzOffset { + layout = dateTimeJSONNoT + } else if hasT { + layout = utcDateTimeJSON + } else { + layout = utcDateTimeJSONNoT } return t.Parse(layout, string(data)) } func (t *dateTimeRFC3339) UnmarshalText(data []byte) error { - layout := utcDateTime - if tzOffsetRegex.Match(data) { + tzOffset := tzOffsetRegex.Match(data) + hasT := strings.Contains(string(data), "T") || strings.Contains(string(data), "t") + var layout string + if tzOffset && hasT { layout = time.RFC3339Nano + } else if tzOffset { + layout = dateTimeNoT + } else if hasT { + layout = utcDateTime + } else { + layout = utcDateTimeNoT } return t.Parse(layout, string(data)) } @@ -61,6 +81,10 @@ func (t *dateTimeRFC3339) Parse(layout, value string) error { return err } +func (t dateTimeRFC3339) String() string { + return time.Time(t).Format(time.RFC3339Nano) +} + func populateDateTimeRFC3339(m map[string]any, k string, t *time.Time) { if t == nil { return @@ -74,7 +98,7 @@ func populateDateTimeRFC3339(m map[string]any, k string, t *time.Time) { } func unpopulateDateTimeRFC3339(data json.RawMessage, fn string, t **time.Time) error { - if data == nil || strings.EqualFold(string(data), "null") { + if data == nil || string(data) == "null" { return nil } var aux dateTimeRFC3339