armpostgresqlflexibleservers

package module
v4.0.0-beta.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 22, 2024 License: MIT Imports: 14 Imported by: 0

README

Azure Database for PostgreSQL Module for Go

PkgGoDev

The armpostgresqlflexibleservers module provides operations for working with Azure Database for PostgreSQL.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Go 1.18 or above (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Database for PostgreSQL module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v4

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Database for PostgreSQL. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure Database for PostgreSQL module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armpostgresqlflexibleservers.NewClientFactory(<subscription ID>, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory(<subscription ID>, cred, &options)

Clients

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.

client := clientFactory.NewAdministratorsClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Database for PostgreSQL label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ActiveDirectoryAdministrator 

type ActiveDirectoryAdministrator struct {
	// REQUIRED; Properties of the active directory administrator.
	Properties *AdministratorProperties

	// 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
}

ActiveDirectoryAdministrator - Represents an Active Directory administrator.

func (ActiveDirectoryAdministrator) MarshalJSON 

func (a ActiveDirectoryAdministrator) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ActiveDirectoryAdministrator.

func (*ActiveDirectoryAdministrator) UnmarshalJSON 

func (a *ActiveDirectoryAdministrator) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ActiveDirectoryAdministrator.

type ActiveDirectoryAdministratorAdd 

type ActiveDirectoryAdministratorAdd struct {
	// Properties of the active directory administrator.
	Properties *AdministratorPropertiesForAdd
}

ActiveDirectoryAdministratorAdd - Represents an Active Directory administrator.

func (ActiveDirectoryAdministratorAdd) MarshalJSON 

func (a ActiveDirectoryAdministratorAdd) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ActiveDirectoryAdministratorAdd.

func (*ActiveDirectoryAdministratorAdd) UnmarshalJSON 

func (a *ActiveDirectoryAdministratorAdd) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ActiveDirectoryAdministratorAdd.

type ActiveDirectoryAuthEnum 

type ActiveDirectoryAuthEnum string

ActiveDirectoryAuthEnum - If Enabled, Azure Active Directory authentication is enabled. 

const (
	ActiveDirectoryAuthEnumDisabled ActiveDirectoryAuthEnum = "Disabled"
	ActiveDirectoryAuthEnumEnabled  ActiveDirectoryAuthEnum = "Enabled"
)

func PossibleActiveDirectoryAuthEnumValues 

func PossibleActiveDirectoryAuthEnumValues() []ActiveDirectoryAuthEnum

PossibleActiveDirectoryAuthEnumValues returns the possible values for the ActiveDirectoryAuthEnum const type.

type AdminCredentials 

type AdminCredentials struct {
	// REQUIRED; Password for source server.
	SourceServerPassword *string

	// REQUIRED; Password for target server.
	TargetServerPassword *string
}

AdminCredentials - Server admin credentials.

func (AdminCredentials) MarshalJSON 

func (a AdminCredentials) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdminCredentials.

func (*AdminCredentials) UnmarshalJSON 

func (a *AdminCredentials) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdminCredentials.

type AdministratorListResult 

type AdministratorListResult struct {
	// The link used to get the next page of active directory.
	NextLink *string

	// The list of active directory administrators
	Value []*ActiveDirectoryAdministrator
}

AdministratorListResult - A list of active directory administrators.

func (AdministratorListResult) MarshalJSON 

func (a AdministratorListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdministratorListResult.

func (*AdministratorListResult) UnmarshalJSON 

func (a *AdministratorListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdministratorListResult.

type AdministratorProperties 

type AdministratorProperties struct {
	// The objectId of the Active Directory administrator.
	ObjectID *string

	// Active Directory administrator principal name.
	PrincipalName *string

	// The principal type used to represent the type of Active Directory Administrator.
	PrincipalType *PrincipalType

	// The tenantId of the Active Directory administrator.
	TenantID *string
}

AdministratorProperties - The properties of an Active Directory administrator.

func (AdministratorProperties) MarshalJSON 

func (a AdministratorProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdministratorProperties.

func (*AdministratorProperties) UnmarshalJSON 

func (a *AdministratorProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdministratorProperties.

type AdministratorPropertiesForAdd 

type AdministratorPropertiesForAdd struct {
	// Active Directory administrator principal name.
	PrincipalName *string

	// The principal type used to represent the type of Active Directory Administrator.
	PrincipalType *PrincipalType

	// The tenantId of the Active Directory administrator.
	TenantID *string
}

AdministratorPropertiesForAdd - The properties of an Active Directory administrator.

func (AdministratorPropertiesForAdd) MarshalJSON 

func (a AdministratorPropertiesForAdd) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdministratorPropertiesForAdd.

func (*AdministratorPropertiesForAdd) UnmarshalJSON 

func (a *AdministratorPropertiesForAdd) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdministratorPropertiesForAdd.

type AdministratorsClient 

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

AdministratorsClient contains the methods for the Administrators group. Don't use this type directly, use NewAdministratorsClient() instead.

func NewAdministratorsClient 

func NewAdministratorsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AdministratorsClient, error)

NewAdministratorsClient creates a new instance of AdministratorsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AdministratorsClient) BeginCreate 

func (client *AdministratorsClient) BeginCreate(ctx context.Context, resourceGroupName string, serverName string, objectID string, parameters ActiveDirectoryAdministratorAdd, options *AdministratorsClientBeginCreateOptions) (*runtime.Poller[AdministratorsClientCreateResponse], error)

BeginCreate - Creates a new server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • objectID - Guid of the objectId for the administrator.
  • parameters - The required parameters for adding an active directory administrator for a server.
  • options - AdministratorsClientBeginCreateOptions contains the optional parameters for the AdministratorsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/AdministratorAdd.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAdministratorsClient().BeginCreate(ctx, "testrg", "testserver", "oooooooo-oooo-oooo-oooo-oooooooooooo", armpostgresqlflexibleservers.ActiveDirectoryAdministratorAdd{
	Properties: &armpostgresqlflexibleservers.AdministratorPropertiesForAdd{
		PrincipalName: to.Ptr("testuser1@microsoft.com"),
		PrincipalType: to.Ptr(armpostgresqlflexibleservers.PrincipalTypeUser),
		TenantID:      to.Ptr("tttttttt-tttt-tttt-tttt-tttttttttttt"),
	},
}, 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.ActiveDirectoryAdministrator = armpostgresqlflexibleservers.ActiveDirectoryAdministrator{
// 	Name: to.Ptr("testuser1@microsoft.com"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/administrators"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/administrators/oooooooo-oooo-oooo-oooo-oooooooooooo"),
// 	Properties: &armpostgresqlflexibleservers.AdministratorProperties{
// 		ObjectID: to.Ptr("oooooooo-oooo-oooo-oooo-oooooooooooo"),
// 		PrincipalName: to.Ptr("testuser1@microsoft.com"),
// 		PrincipalType: to.Ptr(armpostgresqlflexibleservers.PrincipalTypeUser),
// 	},
// }

Output:

func (*AdministratorsClient) BeginDelete 

func (client *AdministratorsClient) BeginDelete(ctx context.Context, resourceGroupName string, serverName string, objectID string, options *AdministratorsClientBeginDeleteOptions) (*runtime.Poller[AdministratorsClientDeleteResponse], error)

BeginDelete - Deletes an Active Directory Administrator associated with the server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • objectID - Guid of the objectId for the administrator.
  • options - AdministratorsClientBeginDeleteOptions contains the optional parameters for the AdministratorsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/AdministratorDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAdministratorsClient().BeginDelete(ctx, "testrg", "testserver", "oooooooo-oooo-oooo-oooo-oooooooooooo", 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)
}

Output:

func (*AdministratorsClient) Get 

func (client *AdministratorsClient) Get(ctx context.Context, resourceGroupName string, serverName string, objectID string, options *AdministratorsClientGetOptions) (AdministratorsClientGetResponse, error)

Get - Gets information about a server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • objectID - Guid of the objectId for the administrator.
  • options - AdministratorsClientGetOptions contains the optional parameters for the AdministratorsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/AdministratorGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAdministratorsClient().Get(ctx, "testrg", "pgtestsvc1", "oooooooo-oooo-oooo-oooo-oooooooooooo", 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.ActiveDirectoryAdministrator = armpostgresqlflexibleservers.ActiveDirectoryAdministrator{
// 	Name: to.Ptr("testuser1@microsoft.com"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/administrators"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc1/administrators/oooooooo-oooo-oooo-oooo-oooooooooooo"),
// 	Properties: &armpostgresqlflexibleservers.AdministratorProperties{
// 		ObjectID: to.Ptr("oooooooo-oooo-oooo-oooo-oooooooooooo"),
// 		PrincipalName: to.Ptr("testuer1@microsoft.com"),
// 		PrincipalType: to.Ptr(armpostgresqlflexibleservers.PrincipalTypeUser),
// 		TenantID: to.Ptr("tttttttt-tttt-tttt-tttt-tttttttttttt"),
// 	},
// }

Output:

func (*AdministratorsClient) NewListByServerPager 

func (client *AdministratorsClient) NewListByServerPager(resourceGroupName string, serverName string, options *AdministratorsClientListByServerOptions) *runtime.Pager[AdministratorsClientListByServerResponse]

NewListByServerPager - List all the AAD administrators for a given server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - AdministratorsClientListByServerOptions contains the optional parameters for the AdministratorsClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/AdministratorsListByServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAdministratorsClient().NewListByServerPager("testrg", "pgtestsvc1", 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.AdministratorListResult = armpostgresqlflexibleservers.AdministratorListResult{
	// 	Value: []*armpostgresqlflexibleservers.ActiveDirectoryAdministrator{
	// 		{
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/administrators"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc1/administrators/oooooooo-oooo-oooo-oooo-oooooooooooo"),
	// 			Properties: &armpostgresqlflexibleservers.AdministratorProperties{
	// 				ObjectID: to.Ptr("oooooooo-oooo-oooo-oooo-oooooooooooo"),
	// 				PrincipalName: to.Ptr("testuer1@microsoft.com"),
	// 				PrincipalType: to.Ptr(armpostgresqlflexibleservers.PrincipalTypeUser),
	// 				TenantID: to.Ptr("tttttttt-tttt-tttt-tttt-tttttttttttt"),
	// 			},
	// 		},
	// 		{
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/administrators"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc1/administrators/gggggggg-gggg-gggg-gggg-gggggggggggg"),
	// 			Properties: &armpostgresqlflexibleservers.AdministratorProperties{
	// 				ObjectID: to.Ptr("gggggggg-gggg-gggg-gggg-gggggggggggg"),
	// 				PrincipalName: to.Ptr("testgroup1@microsoft.com"),
	// 				PrincipalType: to.Ptr(armpostgresqlflexibleservers.PrincipalTypeGroup),
	// 				TenantID: to.Ptr("tttttttt-tttt-tttt-tttt-tttttttttttt"),
	// 			},
	// 	}},
	// }
}

Output:

type AdministratorsClientBeginCreateOptions 

type AdministratorsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AdministratorsClientBeginCreateOptions contains the optional parameters for the AdministratorsClient.BeginCreate method.

type AdministratorsClientBeginDeleteOptions 

type AdministratorsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AdministratorsClientBeginDeleteOptions contains the optional parameters for the AdministratorsClient.BeginDelete method.

type AdministratorsClientCreateResponse 

type AdministratorsClientCreateResponse struct {
	// Represents an Active Directory administrator.
	ActiveDirectoryAdministrator
}

AdministratorsClientCreateResponse contains the response from method AdministratorsClient.BeginCreate.

type AdministratorsClientDeleteResponse 

type AdministratorsClientDeleteResponse struct {
}

AdministratorsClientDeleteResponse contains the response from method AdministratorsClient.BeginDelete.

type AdministratorsClientGetOptions 

type AdministratorsClientGetOptions struct {
}

AdministratorsClientGetOptions contains the optional parameters for the AdministratorsClient.Get method.

type AdministratorsClientGetResponse 

type AdministratorsClientGetResponse struct {
	// Represents an Active Directory administrator.
	ActiveDirectoryAdministrator
}

AdministratorsClientGetResponse contains the response from method AdministratorsClient.Get.

type AdministratorsClientListByServerOptions 

type AdministratorsClientListByServerOptions struct {
}

AdministratorsClientListByServerOptions contains the optional parameters for the AdministratorsClient.NewListByServerPager method.

type AdministratorsClientListByServerResponse 

type AdministratorsClientListByServerResponse struct {
	// A list of active directory administrators.
	AdministratorListResult
}

AdministratorsClientListByServerResponse contains the response from method AdministratorsClient.NewListByServerPager.

type ArmServerKeyType 

type ArmServerKeyType string

ArmServerKeyType - Data encryption type to depict if it is System Managed vs Azure Key vault. 

const (
	ArmServerKeyTypeAzureKeyVault ArmServerKeyType = "AzureKeyVault"
	ArmServerKeyTypeSystemManaged ArmServerKeyType = "SystemManaged"
)

func PossibleArmServerKeyTypeValues 

func PossibleArmServerKeyTypeValues() []ArmServerKeyType

PossibleArmServerKeyTypeValues returns the possible values for the ArmServerKeyType const type.

type AuthConfig 

type AuthConfig struct {
	// If Enabled, Azure Active Directory authentication is enabled.
	ActiveDirectoryAuth *ActiveDirectoryAuthEnum

	// If Enabled, Password authentication is enabled.
	PasswordAuth *PasswordAuthEnum

	// Tenant id of the server.
	TenantID *string
}

AuthConfig - Authentication configuration properties of a server

func (AuthConfig) MarshalJSON 

func (a AuthConfig) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AuthConfig.

func (*AuthConfig) UnmarshalJSON 

func (a *AuthConfig) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AuthConfig.

type AzureManagedDiskPerformanceTiers 

type AzureManagedDiskPerformanceTiers string

AzureManagedDiskPerformanceTiers - Name of storage tier for IOPS. 

const (
	AzureManagedDiskPerformanceTiersP1  AzureManagedDiskPerformanceTiers = "P1"
	AzureManagedDiskPerformanceTiersP10 AzureManagedDiskPerformanceTiers = "P10"
	AzureManagedDiskPerformanceTiersP15 AzureManagedDiskPerformanceTiers = "P15"
	AzureManagedDiskPerformanceTiersP2  AzureManagedDiskPerformanceTiers = "P2"
	AzureManagedDiskPerformanceTiersP20 AzureManagedDiskPerformanceTiers = "P20"
	AzureManagedDiskPerformanceTiersP3  AzureManagedDiskPerformanceTiers = "P3"
	AzureManagedDiskPerformanceTiersP30 AzureManagedDiskPerformanceTiers = "P30"
	AzureManagedDiskPerformanceTiersP4  AzureManagedDiskPerformanceTiers = "P4"
	AzureManagedDiskPerformanceTiersP40 AzureManagedDiskPerformanceTiers = "P40"
	AzureManagedDiskPerformanceTiersP50 AzureManagedDiskPerformanceTiers = "P50"
	AzureManagedDiskPerformanceTiersP6  AzureManagedDiskPerformanceTiers = "P6"
	AzureManagedDiskPerformanceTiersP60 AzureManagedDiskPerformanceTiers = "P60"
	AzureManagedDiskPerformanceTiersP70 AzureManagedDiskPerformanceTiers = "P70"
	AzureManagedDiskPerformanceTiersP80 AzureManagedDiskPerformanceTiers = "P80"
)

func PossibleAzureManagedDiskPerformanceTiersValues 

func PossibleAzureManagedDiskPerformanceTiersValues() []AzureManagedDiskPerformanceTiers

PossibleAzureManagedDiskPerformanceTiersValues returns the possible values for the AzureManagedDiskPerformanceTiers const type.

type Backup 

type Backup struct {
	// Backup retention days for the server.
	BackupRetentionDays *int32

	// A value indicating whether Geo-Redundant backup is enabled on the server.
	GeoRedundantBackup *GeoRedundantBackupEnum

	// READ-ONLY; The earliest restore point time (ISO8601 format) for server.
	EarliestRestoreDate *time.Time
}

Backup properties of a server

func (Backup) MarshalJSON 

func (b Backup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Backup.

func (*Backup) UnmarshalJSON 

func (b *Backup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Backup.

type BackupSettings 

type BackupSettings struct {
	// REQUIRED; Backup Name for the current backup
	BackupName *string
}

BackupSettings - The settings for the long term backup.

func (BackupSettings) MarshalJSON 

func (b BackupSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BackupSettings.

func (*BackupSettings) UnmarshalJSON 

func (b *BackupSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BackupSettings.

type BackupStoreDetails 

type BackupStoreDetails struct {
	// REQUIRED; List of SAS uri of storage containers where backup data is to be streamed/copied.
	SasURIList []*string
}

BackupStoreDetails - Details about the target where the backup content will be stored.

func (BackupStoreDetails) MarshalJSON 

func (b BackupStoreDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BackupStoreDetails.

func (*BackupStoreDetails) UnmarshalJSON 

func (b *BackupStoreDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BackupStoreDetails.

type BackupsClient 

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

BackupsClient contains the methods for the Backups group. Don't use this type directly, use NewBackupsClient() instead.

func NewBackupsClient 

func NewBackupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*BackupsClient, error)

NewBackupsClient creates a new instance of BackupsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*BackupsClient) Get 

func (client *BackupsClient) Get(ctx context.Context, resourceGroupName string, serverName string, backupName string, options *BackupsClientGetOptions) (BackupsClientGetResponse, error)

Get - Get specific backup for a given server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • backupName - The name of the backup.
  • options - BackupsClientGetOptions contains the optional parameters for the BackupsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/BackupGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewBackupsClient().Get(ctx, "TestGroup", "postgresqltestserver", "daily_20210615T160516", 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.ServerBackup = armpostgresqlflexibleservers.ServerBackup{
// 	Name: to.Ptr("daily_20210615T160516"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210615T160516"),
// 	Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
// 		BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
// 		CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-15T16:05:19.902Z"); return t}()),
// 		Source: to.Ptr("Automatic"),
// 	},
// }

Output:

func (*BackupsClient) NewListByServerPager 

func (client *BackupsClient) NewListByServerPager(resourceGroupName string, serverName string, options *BackupsClientListByServerOptions) *runtime.Pager[BackupsClientListByServerResponse]

NewListByServerPager - List all the backups for a given server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - BackupsClientListByServerOptions contains the optional parameters for the BackupsClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/BackupListByServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewBackupsClient().NewListByServerPager("TestGroup", "postgresqltestserver", 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.ServerBackupListResult = armpostgresqlflexibleservers.ServerBackupListResult{
	// 	Value: []*armpostgresqlflexibleservers.ServerBackup{
	// 		{
	// 			Name: to.Ptr("daily_20210615T160516"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210615T160516"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-15T16:05:19.902Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("daily_20210616T160520"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210616T160520"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-16T16:05:23.924Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("daily_20210617T160525"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210617T160525"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-17T16:05:28.124Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("daily_20210618T160529"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210618T160529"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-18T16:05:32.273Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("daily_20210619T160533"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210619T160533"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-19T16:05:36.860Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("daily_20210620T160538"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210620T160538"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-20T16:05:41.920Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("daily_20210621T160543"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210621T160543"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-21T16:05:48.852Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("daily_20210622T160803"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210622T160803"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-22T16:08:06.312Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("daily_20210622T210807"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210622T210807"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-22T21:08:10.505Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("daily_20210623T212413"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210623T212413"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-23T21:24:16.940Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("daily_20210624T061328"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/backups"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestserver/backups/daily_20210624T061328"),
	// 			Properties: &armpostgresqlflexibleservers.ServerBackupProperties{
	// 				BackupType: to.Ptr(armpostgresqlflexibleservers.OriginFull),
	// 				CompletedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-24T06:13:31.496Z"); return t}()),
	// 				Source: to.Ptr("Automatic"),
	// 			},
	// 	}},
	// }
}

Output:

type BackupsClientGetOptions 

type BackupsClientGetOptions struct {
}

BackupsClientGetOptions contains the optional parameters for the BackupsClient.Get method.

type BackupsClientGetResponse 

type BackupsClientGetResponse struct {
	// Server backup properties
	ServerBackup
}

BackupsClientGetResponse contains the response from method BackupsClient.Get.

type BackupsClientListByServerOptions 

type BackupsClientListByServerOptions struct {
}

BackupsClientListByServerOptions contains the optional parameters for the BackupsClient.NewListByServerPager method.

type BackupsClientListByServerResponse 

type BackupsClientListByServerResponse struct {
	// A list of server backups.
	ServerBackupListResult
}

BackupsClientListByServerResponse contains the response from method BackupsClient.NewListByServerPager.

type CancelEnum 

type CancelEnum string

CancelEnum - To trigger cancel for entire migration we need to send this flag as True 

const (
	CancelEnumFalse CancelEnum = "False"
	CancelEnumTrue  CancelEnum = "True"
)

func PossibleCancelEnumValues 

func PossibleCancelEnumValues() []CancelEnum

PossibleCancelEnumValues returns the possible values for the CancelEnum const type.

type CapabilitiesListResult 

type CapabilitiesListResult struct {
	// READ-ONLY; Link to retrieve next page of results.
	NextLink *string

	// READ-ONLY; A list of supported capabilities.
	Value []*FlexibleServerCapability
}

CapabilitiesListResult - Capability for the PostgreSQL server

func (CapabilitiesListResult) MarshalJSON 

func (c CapabilitiesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CapabilitiesListResult.

func (*CapabilitiesListResult) UnmarshalJSON 

func (c *CapabilitiesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CapabilitiesListResult.

type CapabilityStatus 

type CapabilityStatus string

CapabilityStatus - The status of the capability. 

const (
	CapabilityStatusAvailable CapabilityStatus = "Available"
	CapabilityStatusDefault   CapabilityStatus = "Default"
	CapabilityStatusDisabled  CapabilityStatus = "Disabled"
	CapabilityStatusVisible   CapabilityStatus = "Visible"
)

func PossibleCapabilityStatusValues 

func PossibleCapabilityStatusValues() []CapabilityStatus

PossibleCapabilityStatusValues returns the possible values for the CapabilityStatus const type.

type CheckNameAvailabilityClient 

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

CheckNameAvailabilityClient contains the methods for the CheckNameAvailability group. Don't use this type directly, use NewCheckNameAvailabilityClient() instead.

func NewCheckNameAvailabilityClient 

func NewCheckNameAvailabilityClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*CheckNameAvailabilityClient, error)

NewCheckNameAvailabilityClient creates a new instance of CheckNameAvailabilityClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*CheckNameAvailabilityClient) Execute 

func (client *CheckNameAvailabilityClient) Execute(ctx context.Context, nameAvailabilityRequest CheckNameAvailabilityRequest, options *CheckNameAvailabilityClientExecuteOptions) (CheckNameAvailabilityClientExecuteResponse, error)

Execute - Check the availability of name for resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • nameAvailabilityRequest - The required parameters for checking if resource name is available.
  • options - CheckNameAvailabilityClientExecuteOptions contains the optional parameters for the CheckNameAvailabilityClient.Execute method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/CheckNameAvailability.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewCheckNameAvailabilityClient().Execute(ctx, armpostgresqlflexibleservers.CheckNameAvailabilityRequest{
	Name: to.Ptr("name1"),
	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
}, 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.NameAvailability = armpostgresqlflexibleservers.NameAvailability{
// 	Message: to.Ptr(""),
// 	NameAvailable: to.Ptr(true),
// 	Name: to.Ptr("name1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// }

Output:

type CheckNameAvailabilityClientExecuteOptions 

type CheckNameAvailabilityClientExecuteOptions struct {
}

CheckNameAvailabilityClientExecuteOptions contains the optional parameters for the CheckNameAvailabilityClient.Execute method.

type CheckNameAvailabilityClientExecuteResponse 

type CheckNameAvailabilityClientExecuteResponse struct {
	// Represents a resource name availability.
	NameAvailability
}

CheckNameAvailabilityClientExecuteResponse contains the response from method CheckNameAvailabilityClient.Execute.

type CheckNameAvailabilityReason 

type CheckNameAvailabilityReason string

CheckNameAvailabilityReason - The reason why the given name is not available. 

const (
	CheckNameAvailabilityReasonAlreadyExists CheckNameAvailabilityReason = "AlreadyExists"
	CheckNameAvailabilityReasonInvalid       CheckNameAvailabilityReason = "Invalid"
)

func PossibleCheckNameAvailabilityReasonValues 

func PossibleCheckNameAvailabilityReasonValues() []CheckNameAvailabilityReason

PossibleCheckNameAvailabilityReasonValues returns the possible values for the CheckNameAvailabilityReason const type.

type CheckNameAvailabilityRequest 

type CheckNameAvailabilityRequest struct {
	// The name of the resource for which availability needs to be checked.
	Name *string

	// The resource type.
	Type *string
}

CheckNameAvailabilityRequest - The check availability request body.

func (CheckNameAvailabilityRequest) MarshalJSON 

func (c CheckNameAvailabilityRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityRequest.

func (*CheckNameAvailabilityRequest) UnmarshalJSON 

func (c *CheckNameAvailabilityRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityRequest.

type CheckNameAvailabilityWithLocationClient 

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

CheckNameAvailabilityWithLocationClient contains the methods for the CheckNameAvailabilityWithLocation group. Don't use this type directly, use NewCheckNameAvailabilityWithLocationClient() instead.

func NewCheckNameAvailabilityWithLocationClient 

func NewCheckNameAvailabilityWithLocationClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*CheckNameAvailabilityWithLocationClient, error)

NewCheckNameAvailabilityWithLocationClient creates a new instance of CheckNameAvailabilityWithLocationClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*CheckNameAvailabilityWithLocationClient) Execute 

func (client *CheckNameAvailabilityWithLocationClient) Execute(ctx context.Context, locationName string, nameAvailabilityRequest CheckNameAvailabilityRequest, options *CheckNameAvailabilityWithLocationClientExecuteOptions) (CheckNameAvailabilityWithLocationClientExecuteResponse, error)

Execute - Check the availability of name for resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • locationName - The name of the location.
  • nameAvailabilityRequest - The required parameters for checking if resource name is available.
  • options - CheckNameAvailabilityWithLocationClientExecuteOptions contains the optional parameters for the CheckNameAvailabilityWithLocationClient.Execute method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/CheckNameAvailabilityLocationBased.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewCheckNameAvailabilityWithLocationClient().Execute(ctx, "westus", armpostgresqlflexibleservers.CheckNameAvailabilityRequest{
	Name: to.Ptr("name1"),
	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
}, 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.NameAvailability = armpostgresqlflexibleservers.NameAvailability{
// 	Message: to.Ptr(""),
// 	NameAvailable: to.Ptr(true),
// 	Name: to.Ptr("name1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// }

Output:

type CheckNameAvailabilityWithLocationClientExecuteOptions 

type CheckNameAvailabilityWithLocationClientExecuteOptions struct {
}

CheckNameAvailabilityWithLocationClientExecuteOptions contains the optional parameters for the CheckNameAvailabilityWithLocationClient.Execute method.

type CheckNameAvailabilityWithLocationClientExecuteResponse 

type CheckNameAvailabilityWithLocationClientExecuteResponse struct {
	// Represents a resource name availability.
	NameAvailability
}

CheckNameAvailabilityWithLocationClientExecuteResponse contains the response from method CheckNameAvailabilityWithLocationClient.Execute.

type ClientFactory 

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

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory 

func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAdministratorsClient 

func (c *ClientFactory) NewAdministratorsClient() *AdministratorsClient

NewAdministratorsClient creates a new instance of AdministratorsClient.

func (*ClientFactory) NewBackupsClient 

func (c *ClientFactory) NewBackupsClient() *BackupsClient

NewBackupsClient creates a new instance of BackupsClient.

func (*ClientFactory) NewCheckNameAvailabilityClient 

func (c *ClientFactory) NewCheckNameAvailabilityClient() *CheckNameAvailabilityClient

NewCheckNameAvailabilityClient creates a new instance of CheckNameAvailabilityClient.

func (*ClientFactory) NewCheckNameAvailabilityWithLocationClient 

func (c *ClientFactory) NewCheckNameAvailabilityWithLocationClient() *CheckNameAvailabilityWithLocationClient

NewCheckNameAvailabilityWithLocationClient creates a new instance of CheckNameAvailabilityWithLocationClient.

func (*ClientFactory) NewConfigurationsClient 

func (c *ClientFactory) NewConfigurationsClient() *ConfigurationsClient

NewConfigurationsClient creates a new instance of ConfigurationsClient.

func (*ClientFactory) NewDatabasesClient 

func (c *ClientFactory) NewDatabasesClient() *DatabasesClient

NewDatabasesClient creates a new instance of DatabasesClient.

func (*ClientFactory) NewFirewallRulesClient 

func (c *ClientFactory) NewFirewallRulesClient() *FirewallRulesClient

NewFirewallRulesClient creates a new instance of FirewallRulesClient.

func (*ClientFactory) NewFlexibleServerClient 

func (c *ClientFactory) NewFlexibleServerClient() *FlexibleServerClient

NewFlexibleServerClient creates a new instance of FlexibleServerClient.

func (*ClientFactory) NewGetPrivateDNSZoneSuffixClient 

func (c *ClientFactory) NewGetPrivateDNSZoneSuffixClient() *GetPrivateDNSZoneSuffixClient

NewGetPrivateDNSZoneSuffixClient creates a new instance of GetPrivateDNSZoneSuffixClient.

func (*ClientFactory) NewLocationBasedCapabilitiesClient 

func (c *ClientFactory) NewLocationBasedCapabilitiesClient() *LocationBasedCapabilitiesClient

NewLocationBasedCapabilitiesClient creates a new instance of LocationBasedCapabilitiesClient.

func (*ClientFactory) NewLogFilesClient 

func (c *ClientFactory) NewLogFilesClient() *LogFilesClient

NewLogFilesClient creates a new instance of LogFilesClient.

func (*ClientFactory) NewLtrBackupOperationsClient 

func (c *ClientFactory) NewLtrBackupOperationsClient() *LtrBackupOperationsClient

NewLtrBackupOperationsClient creates a new instance of LtrBackupOperationsClient.

func (*ClientFactory) NewMigrationsClient 

func (c *ClientFactory) NewMigrationsClient() *MigrationsClient

NewMigrationsClient creates a new instance of MigrationsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewPostgreSQLManagementClient 

func (c *ClientFactory) NewPostgreSQLManagementClient() *PostgreSQLManagementClient

NewPostgreSQLManagementClient creates a new instance of PostgreSQLManagementClient.

func (*ClientFactory) NewPrivateEndpointConnectionClient 

func (c *ClientFactory) NewPrivateEndpointConnectionClient() *PrivateEndpointConnectionClient

NewPrivateEndpointConnectionClient creates a new instance of PrivateEndpointConnectionClient.

func (*ClientFactory) NewPrivateEndpointConnectionsClient 

func (c *ClientFactory) NewPrivateEndpointConnectionsClient() *PrivateEndpointConnectionsClient

NewPrivateEndpointConnectionsClient creates a new instance of PrivateEndpointConnectionsClient.

func (*ClientFactory) NewPrivateLinkResourcesClient 

func (c *ClientFactory) NewPrivateLinkResourcesClient() *PrivateLinkResourcesClient

NewPrivateLinkResourcesClient creates a new instance of PrivateLinkResourcesClient.

func (*ClientFactory) NewQuotaUsagesClient 

func (c *ClientFactory) NewQuotaUsagesClient() *QuotaUsagesClient

NewQuotaUsagesClient creates a new instance of QuotaUsagesClient.

func (*ClientFactory) NewReplicasClient 

func (c *ClientFactory) NewReplicasClient() *ReplicasClient

NewReplicasClient creates a new instance of ReplicasClient.

func (*ClientFactory) NewServerCapabilitiesClient 

func (c *ClientFactory) NewServerCapabilitiesClient() *ServerCapabilitiesClient

NewServerCapabilitiesClient creates a new instance of ServerCapabilitiesClient.

func (*ClientFactory) NewServerThreatProtectionSettingsClient 

func (c *ClientFactory) NewServerThreatProtectionSettingsClient() *ServerThreatProtectionSettingsClient

NewServerThreatProtectionSettingsClient creates a new instance of ServerThreatProtectionSettingsClient.

func (*ClientFactory) NewServersClient 

func (c *ClientFactory) NewServersClient() *ServersClient

NewServersClient creates a new instance of ServersClient.

func (*ClientFactory) NewVirtualEndpointsClient 

func (c *ClientFactory) NewVirtualEndpointsClient() *VirtualEndpointsClient

NewVirtualEndpointsClient creates a new instance of VirtualEndpointsClient.

func (*ClientFactory) NewVirtualNetworkSubnetUsageClient 

func (c *ClientFactory) NewVirtualNetworkSubnetUsageClient() *VirtualNetworkSubnetUsageClient

NewVirtualNetworkSubnetUsageClient creates a new instance of VirtualNetworkSubnetUsageClient.

type Configuration 

type Configuration struct {
	// The properties of a configuration.
	Properties *ConfigurationProperties

	// 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
}

Configuration - Represents a Configuration.

func (Configuration) MarshalJSON 

func (c Configuration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Configuration.

func (*Configuration) UnmarshalJSON 

func (c *Configuration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Configuration.

type ConfigurationDataType 

type ConfigurationDataType string

ConfigurationDataType - Data type of the configuration. 

const (
	ConfigurationDataTypeBoolean     ConfigurationDataType = "Boolean"
	ConfigurationDataTypeEnumeration ConfigurationDataType = "Enumeration"
	ConfigurationDataTypeInteger     ConfigurationDataType = "Integer"
	ConfigurationDataTypeNumeric     ConfigurationDataType = "Numeric"
)

func PossibleConfigurationDataTypeValues 

func PossibleConfigurationDataTypeValues() []ConfigurationDataType

PossibleConfigurationDataTypeValues returns the possible values for the ConfigurationDataType const type.

type ConfigurationForUpdate 

type ConfigurationForUpdate struct {
	// The properties of a configuration.
	Properties *ConfigurationProperties
}

ConfigurationForUpdate - Represents a Configuration.

func (ConfigurationForUpdate) MarshalJSON 

func (c ConfigurationForUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationForUpdate.

func (*ConfigurationForUpdate) UnmarshalJSON 

func (c *ConfigurationForUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationForUpdate.

type ConfigurationListResult 

type ConfigurationListResult struct {
	// The link used to get the next page of operations.
	NextLink *string

	// The list of server configurations.
	Value []*Configuration
}

ConfigurationListResult - A list of server configurations.

func (ConfigurationListResult) MarshalJSON 

func (c ConfigurationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationListResult.

func (*ConfigurationListResult) UnmarshalJSON 

func (c *ConfigurationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationListResult.

type ConfigurationProperties 

type ConfigurationProperties struct {
	// Source of the configuration.
	Source *string

	// Value of the configuration.
	Value *string

	// READ-ONLY; Allowed values of the configuration.
	AllowedValues *string

	// READ-ONLY; Data type of the configuration.
	DataType *ConfigurationDataType

	// READ-ONLY; Default value of the configuration.
	DefaultValue *string

	// READ-ONLY; Description of the configuration.
	Description *string

	// READ-ONLY; Configuration documentation link.
	DocumentationLink *string

	// READ-ONLY; Configuration is pending restart or not.
	IsConfigPendingRestart *bool

	// READ-ONLY; Configuration dynamic or static.
	IsDynamicConfig *bool

	// READ-ONLY; Configuration read-only or not.
	IsReadOnly *bool

	// READ-ONLY; Configuration unit.
	Unit *string
}

ConfigurationProperties - The properties of a configuration.

func (ConfigurationProperties) MarshalJSON 

func (c ConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationProperties.

func (*ConfigurationProperties) UnmarshalJSON 

func (c *ConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationProperties.

type ConfigurationsClient 

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

ConfigurationsClient contains the methods for the Configurations group. Don't use this type directly, use NewConfigurationsClient() instead.

func NewConfigurationsClient 

func NewConfigurationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ConfigurationsClient, error)

NewConfigurationsClient creates a new instance of ConfigurationsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ConfigurationsClient) BeginPut 

func (client *ConfigurationsClient) BeginPut(ctx context.Context, resourceGroupName string, serverName string, configurationName string, parameters Configuration, options *ConfigurationsClientBeginPutOptions) (*runtime.Poller[ConfigurationsClientPutResponse], error)

BeginPut - Updates a configuration of a server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • configurationName - The name of the server configuration.
  • parameters - The required parameters for updating a server configuration.
  • options - ConfigurationsClientBeginPutOptions contains the optional parameters for the ConfigurationsClient.BeginPut method.

func (*ConfigurationsClient) BeginUpdate 

func (client *ConfigurationsClient) BeginUpdate(ctx context.Context, resourceGroupName string, serverName string, configurationName string, parameters ConfigurationForUpdate, options *ConfigurationsClientBeginUpdateOptions) (*runtime.Poller[ConfigurationsClientUpdateResponse], error)

BeginUpdate - Updates a configuration of a server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • configurationName - The name of the server configuration.
  • parameters - The required parameters for updating a server configuration.
  • options - ConfigurationsClientBeginUpdateOptions contains the optional parameters for the ConfigurationsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ConfigurationUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConfigurationsClient().BeginUpdate(ctx, "testrg", "testserver", "event_scheduler", armpostgresqlflexibleservers.ConfigurationForUpdate{
	Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
		Source: to.Ptr("user-override"),
		Value:  to.Ptr("on"),
	},
}, 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.Configuration = armpostgresqlflexibleservers.Configuration{
// 	Name: to.Ptr("event_scheduler"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/event_scheduler"),
// 	Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
// 		Description: to.Ptr("Indicates the status of the Event Scheduler."),
// 		AllowedValues: to.Ptr("ON,OFF,DISABLED"),
// 		DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
// 		DefaultValue: to.Ptr("OFF"),
// 		Source: to.Ptr("user-override"),
// 		Value: to.Ptr("ON"),
// 	},
// }

Output:

func (*ConfigurationsClient) Get 

func (client *ConfigurationsClient) Get(ctx context.Context, resourceGroupName string, serverName string, configurationName string, options *ConfigurationsClientGetOptions) (ConfigurationsClientGetResponse, error)

Get - Gets information about a configuration of server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • configurationName - The name of the server configuration.
  • options - ConfigurationsClientGetOptions contains the optional parameters for the ConfigurationsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ConfigurationGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewConfigurationsClient().Get(ctx, "testrg", "testserver", "array_nulls", 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.Configuration = armpostgresqlflexibleservers.Configuration{
// 	Name: to.Ptr("array_nulls"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/array_nulls"),
// 	Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
// 		Description: to.Ptr("Enable input of NULL elements in arrays."),
// 		AllowedValues: to.Ptr("on,off"),
// 		DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
// 		DefaultValue: to.Ptr("on"),
// 		Source: to.Ptr("system-default"),
// 		Value: to.Ptr("on"),
// 	},
// }

Output:

func (*ConfigurationsClient) NewListByServerPager 

func (client *ConfigurationsClient) NewListByServerPager(resourceGroupName string, serverName string, options *ConfigurationsClientListByServerOptions) *runtime.Pager[ConfigurationsClientListByServerResponse]

NewListByServerPager - List all the configurations in a given server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - ConfigurationsClientListByServerOptions contains the optional parameters for the ConfigurationsClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ConfigurationListByServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewConfigurationsClient().NewListByServerPager("testrg", "testserver", 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.ConfigurationListResult = armpostgresqlflexibleservers.ConfigurationListResult{
	// 	Value: []*armpostgresqlflexibleservers.Configuration{
	// 		{
	// 			Name: to.Ptr("application_name"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/application_name"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the application name to be reported in statistics and logs."),
	// 				AllowedValues: to.Ptr("[A-Za-z0-9._-]*"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataType("String")),
	// 				DefaultValue: to.Ptr(""),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr(""),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("array_nulls"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/array_nulls"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables input of NULL elements in arrays."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("autovacuum"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/autovacuum"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Starts the autovacuum subprocess."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("autovacuum_analyze_scale_factor"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/autovacuum_analyze_scale_factor"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Number of tuple inserts, updates, or deletes prior to analyze as a fraction of reltuples."),
	// 				AllowedValues: to.Ptr("0-100"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("0.1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0.1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("autovacuum_analyze_threshold"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/autovacuum_analyze_threshold"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Minimum number of tuple inserts, updates, or deletes prior to analyze."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("50"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("50"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("autovacuum_naptime"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/autovacuum_naptime"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Time to sleep between autovacuum runs."),
	// 				AllowedValues: to.Ptr("1-2147483"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("60"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("60"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("autovacuum_vacuum_cost_delay"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/autovacuum_vacuum_cost_delay"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Vacuum cost delay in milliseconds, for autovacuum."),
	// 				AllowedValues: to.Ptr("-1-100"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("2"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("2"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("autovacuum_vacuum_cost_limit"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/autovacuum_vacuum_cost_limit"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Vacuum cost amount available before napping, for autovacuum."),
	// 				AllowedValues: to.Ptr("-1-10000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("-1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("-1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("autovacuum_vacuum_scale_factor"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/autovacuum_vacuum_scale_factor"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Number of tuple updates or deletes prior to vacuum as a fraction of reltuples."),
	// 				AllowedValues: to.Ptr("0-100"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("0.2"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0.2"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("autovacuum_vacuum_threshold"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/autovacuum_vacuum_threshold"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Minimum number of tuple updates or deletes prior to vacuum."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("50"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("50"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("autovacuum_work_mem"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/autovacuum_work_mem"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum memory to be used by each autovacuum worker process."),
	// 				AllowedValues: to.Ptr("-1-2097151"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("-1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("-1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("backend_flush_after"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/backend_flush_after"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Number of pages after which previously performed writes are flushed to disk."),
	// 				AllowedValues: to.Ptr("0-256"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("backslash_quote"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/backslash_quote"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets whether \"\\'\" is allowed in string literals."),
	// 				AllowedValues: to.Ptr("safe_encoding,on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("safe_encoding"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("safe_encoding"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("bgwriter_delay"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/bgwriter_delay"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Background writer sleep time between rounds."),
	// 				AllowedValues: to.Ptr("10-10000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("200"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("200"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("bgwriter_flush_after"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/bgwriter_flush_after"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Number of pages after which previously performed writes are flushed to disk."),
	// 				AllowedValues: to.Ptr("0-256"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("64"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("64"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("bgwriter_lru_maxpages"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/bgwriter_lru_maxpages"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Background writer maximum number of LRU pages to flush per round."),
	// 				AllowedValues: to.Ptr("0-1073741823"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("100"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("100"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("bgwriter_lru_multiplier"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/bgwriter_lru_multiplier"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Multiple of the average buffer usage to free per round."),
	// 				AllowedValues: to.Ptr("0-10"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("2"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("2"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("bytea_output"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/bytea_output"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the output format for bytea."),
	// 				AllowedValues: to.Ptr("escape,hex"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("hex"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("hex"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("check_function_bodies"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/check_function_bodies"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Checks function bodies during CREATE FUNCTION."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("checkpoint_completion_target"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/checkpoint_completion_target"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Time spent flushing dirty buffers during checkpoint, as fraction of checkpoint interval."),
	// 				AllowedValues: to.Ptr("0-1"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("0.5"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0.5"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("checkpoint_timeout"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/checkpoint_timeout"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum time between automatic WAL checkpoints."),
	// 				AllowedValues: to.Ptr("30-86400"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("300"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("300"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("checkpoint_warning"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/checkpoint_warning"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables warnings if checkpoint segments are filled more frequently than this."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("30"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("30"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("client_encoding"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/client_encoding"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the client's character set encoding."),
	// 				AllowedValues: to.Ptr("BIG5,EUC_CN,EUC_JP,EUC_JIS_2004,EUC_KR,EUC_TW,GB18030,GBK,ISO_8859_5,ISO_8859_6,ISO_8859_7,ISO_8859_8,JOHAB,KOI8R,KOI8U,LATIN1,LATIN2,LATIN3,LATIN4,LATIN5,LATIN6,LATIN7,LATIN8,LATIN9,LATIN10,MULE_INTERNAL,SJIS,SHIFT_JIS_2004,SQL_ASCII,UHC,UTF8,WIN866,WIN874,WIN1250,WIN1251,WIN1252,WIN1253,WIN1254,WIN1255,WIN1256,WIN1257,WIN1258"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("sql_ascii"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("sql_ascii"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("client_min_messages"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/client_min_messages"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the message levels that are sent to the client."),
	// 				AllowedValues: to.Ptr("debug5,debug4,debug3,debug2,debug1,log,notice,warning,error"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("notice"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("notice"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("commit_delay"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/commit_delay"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the delay in microseconds between transaction commit and flushing WAL to disk."),
	// 				AllowedValues: to.Ptr("0-100000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("commit_siblings"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/commit_siblings"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the minimum concurrent open transactions before performing commit_delay."),
	// 				AllowedValues: to.Ptr("0-1000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("5"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("5"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("constraint_exclusion"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/constraint_exclusion"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner to use constraints to optimize queries."),
	// 				AllowedValues: to.Ptr("partition,on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("partition"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("partition"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("cpu_index_tuple_cost"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/cpu_index_tuple_cost"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the planner's estimate of the cost of processing each index entry during an index scan."),
	// 				AllowedValues: to.Ptr("0-1.79769e+308"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("0.005"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0.005"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("cpu_operator_cost"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/cpu_operator_cost"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the planner's estimate of the cost of processing each operator or function call."),
	// 				AllowedValues: to.Ptr("0-1.79769e+308"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("0.0025"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0.0025"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("cpu_tuple_cost"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/cpu_tuple_cost"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the planner's estimate of the cost of processing each tuple (row)."),
	// 				AllowedValues: to.Ptr("0-1.79769e+308"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("0.01"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0.01"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("cursor_tuple_fraction"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/cursor_tuple_fraction"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the planner's estimate of the fraction of a cursor's rows that will be retrieved."),
	// 				AllowedValues: to.Ptr("0-1"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("0.1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0.1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("DateStyle"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/DateStyle"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the display format for date and time values."),
	// 				AllowedValues: to.Ptr("(ISO|POSTGRES|SQL|GERMAN)(, (DMY|MDY|YMD))?"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataType("String")),
	// 				DefaultValue: to.Ptr("ISO, MDY"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("ISO, MDY"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("deadlock_timeout"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/deadlock_timeout"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the amount of time, in milliseconds, to wait on a lock before checking for deadlock."),
	// 				AllowedValues: to.Ptr("1-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("1000"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("1000"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("debug_pretty_print"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/debug_pretty_print"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Indents parse and plan tree displays."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("debug_print_parse"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/debug_print_parse"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Logs each query's parse tree."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("debug_print_plan"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/debug_print_plan"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Logs each query's execution plan."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("debug_print_rewritten"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/debug_print_rewritten"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Logs each query's rewritten parse tree."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("default_statistics_target"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/default_statistics_target"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the default statistics target."),
	// 				AllowedValues: to.Ptr("1-10000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("100"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("100"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("default_tablespace"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/default_tablespace"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the default tablespace to create tables and indexes in."),
	// 				AllowedValues: to.Ptr("[A-Za-z._]*"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataType("String")),
	// 				DefaultValue: to.Ptr(""),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr(""),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("default_text_search_config"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/default_text_search_config"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets default text search configuration."),
	// 				AllowedValues: to.Ptr("[A-Za-z._]+"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataType("String")),
	// 				DefaultValue: to.Ptr("pg_catalog.english"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("pg_catalog.english"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("default_transaction_deferrable"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/default_transaction_deferrable"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the default deferrable status of new transactions."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("default_transaction_isolation"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/default_transaction_isolation"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the transaction isolation level of each new transaction."),
	// 				AllowedValues: to.Ptr("serializable,repeatable read,read committed,read uncommitted"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("read committed"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("read committed"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("default_transaction_read_only"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/default_transaction_read_only"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the default read-only status of new transactions."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("default_with_oids"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/default_with_oids"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Creates new tables with OIDs by default."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("effective_cache_size"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/effective_cache_size"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the planner's assumption about the size of the disk cache."),
	// 				AllowedValues: to.Ptr("1-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("3145728"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("3145728"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_bitmapscan"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_bitmapscan"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of bitmap-scan plans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_gathermerge"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_gathermerge"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of gather merge plans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_hashagg"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_hashagg"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of hashed aggregation plans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_hashjoin"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_hashjoin"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of hash join plans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_indexonlyscan"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_indexonlyscan"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of index-only-scan plans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_indexscan"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_indexscan"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of index-scan plans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_material"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_material"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of materialization."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_mergejoin"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_mergejoin"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of merge join plans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_nestloop"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_nestloop"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of nested loop join plans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_seqscan"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_seqscan"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of sequential-scan plans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_sort"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_sort"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of explicit sort steps."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("enable_tidscan"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/enable_tidscan"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables the planner's use of TID scan plans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("escape_string_warning"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/escape_string_warning"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Warns about backslash escapes in ordinary string literals."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("exit_on_error"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/exit_on_error"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Terminates session on any error."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("extra_float_digits"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/extra_float_digits"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the number of digits displayed for floating-point values."),
	// 				AllowedValues: to.Ptr("-15-3"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("force_parallel_mode"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/force_parallel_mode"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Forces use of parallel query facilities."),
	// 				AllowedValues: to.Ptr("off,on,regress"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("from_collapse_limit"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/from_collapse_limit"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the FROM-list size beyond which subqueries are not collapsed."),
	// 				AllowedValues: to.Ptr("1-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("8"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("8"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("geqo"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/geqo"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables genetic query optimization."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("geqo_effort"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/geqo_effort"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("GEQO: effort is used to set the default for other GEQO parameters."),
	// 				AllowedValues: to.Ptr("1-10"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("5"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("5"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("geqo_generations"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/geqo_generations"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("GEQO: number of iterations of the algorithm."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("geqo_pool_size"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/geqo_pool_size"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("GEQO: number of individuals in the population."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("geqo_seed"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/geqo_seed"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("GEQO: seed for random path selection."),
	// 				AllowedValues: to.Ptr("0-1"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("geqo_selection_bias"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/geqo_selection_bias"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("GEQO: selective pressure within the population."),
	// 				AllowedValues: to.Ptr("1.5-2"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("2"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("2"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("geqo_threshold"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/geqo_threshold"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the threshold of FROM items beyond which GEQO is used."),
	// 				AllowedValues: to.Ptr("2-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("12"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("12"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("gin_fuzzy_search_limit"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/gin_fuzzy_search_limit"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum allowed result for exact search by GIN."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("gin_pending_list_limit"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/gin_pending_list_limit"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum size of the pending list for GIN index."),
	// 				AllowedValues: to.Ptr("64-2097151"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("4096"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("4096"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("idle_in_transaction_session_timeout"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/idle_in_transaction_session_timeout"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum allowed duration of any idling transaction."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("IntervalStyle"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/IntervalStyle"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the display format for interval values."),
	// 				AllowedValues: to.Ptr("postgres,postgres_verbose,sql_standard,iso_8601"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("postgres"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("postgres"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("join_collapse_limit"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/join_collapse_limit"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the FROM-list size beyond which JOIN constructs are not flattened."),
	// 				AllowedValues: to.Ptr("1-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("8"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("8"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("lc_monetary"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/lc_monetary"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the locale for formatting monetary amounts."),
	// 				AllowedValues: to.Ptr("[A-Za-z0-9._ -]+"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataType("String")),
	// 				DefaultValue: to.Ptr("en_US.utf-8"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("en_US.utf-8"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("lc_numeric"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/lc_numeric"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the locale for formatting numbers."),
	// 				AllowedValues: to.Ptr("[A-Za-z0-9._ -]+"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataType("String")),
	// 				DefaultValue: to.Ptr("en_US.utf-8"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("en_US.utf-8"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("lo_compat_privileges"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/lo_compat_privileges"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables backward compatibility mode for privilege checks on large objects."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("lock_timeout"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/lock_timeout"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum allowed duration (in milliseconds) of any wait for a lock. 0 turns this off."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_autovacuum_min_duration"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_autovacuum_min_duration"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the minimum execution time above which autovacuum actions will be logged."),
	// 				AllowedValues: to.Ptr("-1-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("-1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("-1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_checkpoints"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_checkpoints"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Logs each checkpoint."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_connections"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_connections"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Logs each successful connection."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_destination"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_destination"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the destination for server log output."),
	// 				AllowedValues: to.Ptr("stderr,csvlog"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("stderr"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("stderr"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_disconnections"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_disconnections"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Logs end of a session, including duration."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_duration"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_duration"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Logs the duration of each completed SQL statement."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_error_verbosity"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_error_verbosity"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the verbosity of logged messages."),
	// 				AllowedValues: to.Ptr("terse,default,verbose"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("default"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("default"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_lock_waits"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_lock_waits"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Logs long lock waits."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_min_duration_statement"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_min_duration_statement"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the minimum execution time (in milliseconds) above which statements will be logged. -1 disables logging statement durations."),
	// 				AllowedValues: to.Ptr("-1-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("-1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("-1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_min_error_statement"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_min_error_statement"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Causes all statements generating error at or above this level to be logged."),
	// 				AllowedValues: to.Ptr("debug5,debug4,debug3,debug2,debug1,info,notice,warning,error,log,fatal,panic"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("error"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("error"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_min_messages"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_min_messages"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the message levels that are logged."),
	// 				AllowedValues: to.Ptr("debug5,debug4,debug3,debug2,debug1,info,notice,warning,error,log,fatal,panic"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("warning"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("warning"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_replication_commands"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_replication_commands"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Logs each replication command."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_statement"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_statement"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the type of statements logged."),
	// 				AllowedValues: to.Ptr("none,ddl,mod,all"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("none"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("none"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_statement_stats"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_statement_stats"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("For each query, writes cumulative performance statistics to the server log."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("log_temp_files"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/log_temp_files"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Logs the use of temporary files larger than this number of kilobytes."),
	// 				AllowedValues: to.Ptr("-1-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("-1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("-1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("maintenance_work_mem"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/maintenance_work_mem"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum memory to be used for maintenance operations."),
	// 				AllowedValues: to.Ptr("1024-2097151"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("332800"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("332800"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("max_parallel_workers"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/max_parallel_workers"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum number of parallel workers than can be active at one time."),
	// 				AllowedValues: to.Ptr("0-1024"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("8"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("8"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("max_parallel_workers_per_gather"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/max_parallel_workers_per_gather"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum number of parallel processes per executor node."),
	// 				AllowedValues: to.Ptr("0-1024"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("2"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("2"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("max_pred_locks_per_page"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/max_pred_locks_per_page"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum number of predicate-locked tuples per page."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("2"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("2"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("max_pred_locks_per_relation"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/max_pred_locks_per_relation"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum number of predicate-locked pages and tuples per relation."),
	// 				AllowedValues: to.Ptr("-2147483648-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("-2"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("-2"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("max_standby_archive_delay"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/max_standby_archive_delay"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum delay before canceling queries when a hot standby server is processing archived WAL data."),
	// 				AllowedValues: to.Ptr("-1-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("30000"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("30000"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("max_standby_streaming_delay"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/max_standby_streaming_delay"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum delay before canceling queries when a hot standby server is processing streamed WAL data."),
	// 				AllowedValues: to.Ptr("-1-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("30000"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("30000"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("max_sync_workers_per_subscription"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/max_sync_workers_per_subscription"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Maximum number of table synchronization workers per subscription."),
	// 				AllowedValues: to.Ptr("0-262143"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("2"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("2"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("max_wal_size"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/max_wal_size"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the WAL size that triggers a checkpoint."),
	// 				AllowedValues: to.Ptr("2-2097151"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("1024"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("1024"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("min_parallel_index_scan_size"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/min_parallel_index_scan_size"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the minimum amount of index data for a parallel scan."),
	// 				AllowedValues: to.Ptr("0-715827882"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("64"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("64"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("min_parallel_table_scan_size"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/min_parallel_table_scan_size"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the minimum amount of table data for a parallel scan."),
	// 				AllowedValues: to.Ptr("0-715827882"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("1024"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("1024"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("min_wal_size"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/min_wal_size"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the minimum size to shrink the WAL to."),
	// 				AllowedValues: to.Ptr("2-2097151"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("80"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("80"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("operator_precedence_warning"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/operator_precedence_warning"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Emits a warning for constructs that changed meaning since PostgreSQL 9.4."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("parallel_setup_cost"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/parallel_setup_cost"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the planner's estimate of the cost of starting up worker processes for parallel query."),
	// 				AllowedValues: to.Ptr("0-1.79769e+308"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("1000"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("1000"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("parallel_tuple_cost"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/parallel_tuple_cost"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the planner's estimate of the cost of passing each tuple (row) from worker to master backend."),
	// 				AllowedValues: to.Ptr("0-1.79769e+308"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("0.1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0.1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("quote_all_identifiers"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/quote_all_identifiers"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("When generating SQL fragments, quotes all identifiers."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("random_page_cost"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/random_page_cost"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the planner's estimate of the cost of a nonsequentially fetched disk page."),
	// 				AllowedValues: to.Ptr("0-1.79769e+308"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("4"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("4"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("row_security"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/row_security"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables row security."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("search_path"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/search_path"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the schema search order for names that are not schema-qualified."),
	// 				AllowedValues: to.Ptr("[A-Za-z.\"$, ]+"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataType("String")),
	// 				DefaultValue: to.Ptr("\"$user\", public"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("\"$user\", public"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("seq_page_cost"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/seq_page_cost"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the planner's estimate of the cost of a sequentially fetched disk page."),
	// 				AllowedValues: to.Ptr("0-1.79769e+308"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeNumeric),
	// 				DefaultValue: to.Ptr("1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("session_replication_role"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/session_replication_role"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the session's behavior for triggers and rewrite rules."),
	// 				AllowedValues: to.Ptr("origin,replica,local"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("origin"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("origin"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("standard_conforming_strings"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/standard_conforming_strings"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Causes '...' strings to treat backslashes literally."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("statement_timeout"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/statement_timeout"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum allowed duration (in milliseconds) of any statement. 0 turns this off."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("synchronize_seqscans"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/synchronize_seqscans"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Enables synchronized sequential scans."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("synchronous_commit"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/synchronous_commit"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the current transaction's synchronization level."),
	// 				AllowedValues: to.Ptr("local,remote_write,on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("tcp_keepalives_count"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/tcp_keepalives_count"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Maximum number of TCP keepalive retransmits."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("9"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("9"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("tcp_keepalives_idle"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/tcp_keepalives_idle"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Time between issuing TCP keepalives."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("120"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("120"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("tcp_keepalives_interval"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/tcp_keepalives_interval"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Time between TCP keepalive retransmits."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("30"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("30"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("temp_buffers"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/temp_buffers"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum number of temporary buffers used by each database session."),
	// 				AllowedValues: to.Ptr("100-1073741823"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("1024"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("1024"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("temp_tablespaces"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/temp_tablespaces"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the tablespace(s) to use for temporary tables and sort files."),
	// 				AllowedValues: to.Ptr("[A-Za-z._]*"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataType("String")),
	// 				DefaultValue: to.Ptr(""),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr(""),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("TimeZone"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/TimeZone"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the time zone for displaying and interpreting time stamps."),
	// 				AllowedValues: to.Ptr("[A-Za-z0-9/+_-]+"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataType("String")),
	// 				DefaultValue: to.Ptr("UTC"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("UTC"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("track_activities"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/track_activities"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Collects information about executing commands."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("track_counts"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/track_counts"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Collects statistics on database activity."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("on"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("on"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("track_functions"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/track_functions"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Collects function-level statistics on database activity."),
	// 				AllowedValues: to.Ptr("none,pl,all"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("none"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("none"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("track_io_timing"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/track_io_timing"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Collects timing statistics for database I/O activity."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("transform_null_equals"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/transform_null_equals"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Treats \"expr=NULL\" as \"expr IS NULL\"."),
	// 				AllowedValues: to.Ptr("on,off"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeBoolean),
	// 				DefaultValue: to.Ptr("off"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("off"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vacuum_cost_delay"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/vacuum_cost_delay"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Vacuum cost delay in milliseconds."),
	// 				AllowedValues: to.Ptr("0-100"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vacuum_cost_limit"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/vacuum_cost_limit"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Vacuum cost amount available before napping."),
	// 				AllowedValues: to.Ptr("1-10000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("200"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("200"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vacuum_cost_page_dirty"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/vacuum_cost_page_dirty"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Vacuum cost for a page dirtied by vacuum."),
	// 				AllowedValues: to.Ptr("0-10000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("20"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("20"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vacuum_cost_page_hit"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/vacuum_cost_page_hit"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Vacuum cost for a page found in the buffer cache."),
	// 				AllowedValues: to.Ptr("0-10000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("1"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("1"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vacuum_cost_page_miss"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/vacuum_cost_page_miss"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Vacuum cost for a page not found in the buffer cache."),
	// 				AllowedValues: to.Ptr("0-10000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("10"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("10"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vacuum_defer_cleanup_age"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/vacuum_defer_cleanup_age"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Number of transactions by which VACUUM and HOT cleanup should be deferred, if any."),
	// 				AllowedValues: to.Ptr("0-1000000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("0"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vacuum_freeze_min_age"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/vacuum_freeze_min_age"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Minimum age at which VACUUM should freeze a table row."),
	// 				AllowedValues: to.Ptr("0-1000000000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("50000000"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("50000000"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vacuum_freeze_table_age"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/vacuum_freeze_table_age"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Age at which VACUUM should scan whole table to freeze tuples."),
	// 				AllowedValues: to.Ptr("0-2000000000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("150000000"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("150000000"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vacuum_multixact_freeze_min_age"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/vacuum_multixact_freeze_min_age"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Minimum age at which VACUUM should freeze a MultiXactId in a table row."),
	// 				AllowedValues: to.Ptr("0-1000000000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("5000000"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("5000000"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("vacuum_multixact_freeze_table_age"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/vacuum_multixact_freeze_table_age"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Multixact age at which VACUUM should scan whole table to freeze tuples."),
	// 				AllowedValues: to.Ptr("0-2000000000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("150000000"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("150000000"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("wal_receiver_status_interval"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/wal_receiver_status_interval"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the maximum interval between WAL receiver status reports to the primary."),
	// 				AllowedValues: to.Ptr("0-2147483"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("10"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("10"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("wal_writer_delay"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/wal_writer_delay"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Time between WAL flushes performed in the WAL writer."),
	// 				AllowedValues: to.Ptr("1-10000"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("200"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("200"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("wal_writer_flush_after"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/wal_writer_flush_after"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Amount of WAL written out by WAL writer that triggers a flush."),
	// 				AllowedValues: to.Ptr("0-2147483647"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("128"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("128"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("work_mem"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/work_mem"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets the amount of memory to be used by internal sort operations and hash tables before writing to temporary disk files."),
	// 				AllowedValues: to.Ptr("4096-2097151"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeInteger),
	// 				DefaultValue: to.Ptr("115712"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("115712"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("xmlbinary"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/xmlbinary"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets how binary values are to be encoded in XML."),
	// 				AllowedValues: to.Ptr("base64,hex"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("base64"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("base64"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("xmloption"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/configurations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/configurations/xmloption"),
	// 			Properties: &armpostgresqlflexibleservers.ConfigurationProperties{
	// 				Description: to.Ptr("Sets whether XML data in implicit parsing and serialization operations is to be considered as documents or content fragments."),
	// 				AllowedValues: to.Ptr("content,document"),
	// 				DataType: to.Ptr(armpostgresqlflexibleservers.ConfigurationDataTypeEnumeration),
	// 				DefaultValue: to.Ptr("content"),
	// 				Source: to.Ptr("system-default"),
	// 				Value: to.Ptr("content"),
	// 			},
	// 	}},
	// }
}

Output:

type ConfigurationsClientBeginPutOptions 

type ConfigurationsClientBeginPutOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ConfigurationsClientBeginPutOptions contains the optional parameters for the ConfigurationsClient.BeginPut method.

type ConfigurationsClientBeginUpdateOptions 

type ConfigurationsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ConfigurationsClientBeginUpdateOptions contains the optional parameters for the ConfigurationsClient.BeginUpdate method.

type ConfigurationsClientGetOptions 

type ConfigurationsClientGetOptions struct {
}

ConfigurationsClientGetOptions contains the optional parameters for the ConfigurationsClient.Get method.

type ConfigurationsClientGetResponse 

type ConfigurationsClientGetResponse struct {
	// Represents a Configuration.
	Configuration
}

ConfigurationsClientGetResponse contains the response from method ConfigurationsClient.Get.

type ConfigurationsClientListByServerOptions 

type ConfigurationsClientListByServerOptions struct {
}

ConfigurationsClientListByServerOptions contains the optional parameters for the ConfigurationsClient.NewListByServerPager method.

type ConfigurationsClientListByServerResponse 

type ConfigurationsClientListByServerResponse struct {
	// A list of server configurations.
	ConfigurationListResult
}

ConfigurationsClientListByServerResponse contains the response from method ConfigurationsClient.NewListByServerPager.

type ConfigurationsClientPutResponse 

type ConfigurationsClientPutResponse struct {
	// Represents a Configuration.
	Configuration
}

ConfigurationsClientPutResponse contains the response from method ConfigurationsClient.BeginPut.

type ConfigurationsClientUpdateResponse 

type ConfigurationsClientUpdateResponse struct {
	// Represents a Configuration.
	Configuration
}

ConfigurationsClientUpdateResponse contains the response from method ConfigurationsClient.BeginUpdate.

type CreateMode 

type CreateMode string

CreateMode - The mode to create a new PostgreSQL server. 

const (
	CreateModeCreate             CreateMode = "Create"
	CreateModeDefault            CreateMode = "Default"
	CreateModeGeoRestore         CreateMode = "GeoRestore"
	CreateModePointInTimeRestore CreateMode = "PointInTimeRestore"
	CreateModeReplica            CreateMode = "Replica"
	CreateModeReviveDropped      CreateMode = "ReviveDropped"
	CreateModeUpdate             CreateMode = "Update"
)

func PossibleCreateModeValues 

func PossibleCreateModeValues() []CreateMode

PossibleCreateModeValues returns the possible values for the CreateMode const type.

type CreateModeForUpdate 

type CreateModeForUpdate string

CreateModeForUpdate - The mode to update a new PostgreSQL server. 

const (
	CreateModeForUpdateDefault CreateModeForUpdate = "Default"
	CreateModeForUpdateUpdate  CreateModeForUpdate = "Update"
)

func PossibleCreateModeForUpdateValues 

func PossibleCreateModeForUpdateValues() []CreateModeForUpdate

PossibleCreateModeForUpdateValues returns the possible values for the CreateModeForUpdate const type.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DataEncryption 

type DataEncryption struct {
	// Geo-backup encryption key status for Data encryption enabled server.
	GeoBackupEncryptionKeyStatus *KeyStatusEnum

	// URI for the key in keyvault for data encryption for geo-backup of server.
	GeoBackupKeyURI *string

	// Resource Id for the User assigned identity to be used for data encryption for geo-backup of server.
	GeoBackupUserAssignedIdentityID *string

	// Primary encryption key status for Data encryption enabled server.
	PrimaryEncryptionKeyStatus *KeyStatusEnum

	// URI for the key in keyvault for data encryption of the primary server.
	PrimaryKeyURI *string

	// Resource Id for the User assigned identity to be used for data encryption of the primary server.
	PrimaryUserAssignedIdentityID *string

	// Data encryption type to depict if it is System Managed vs Azure Key vault.
	Type *ArmServerKeyType
}

DataEncryption - Data encryption properties of a server

func (DataEncryption) MarshalJSON 

func (d DataEncryption) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DataEncryption.

func (*DataEncryption) UnmarshalJSON 

func (d *DataEncryption) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DataEncryption.

type Database 

type Database struct {
	// The properties of a database.
	Properties *DatabaseProperties

	// 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
}

Database - Represents a Database.

func (Database) MarshalJSON 

func (d Database) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Database.

func (*Database) UnmarshalJSON 

func (d *Database) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Database.

type DatabaseListResult 

type DatabaseListResult struct {
	// The link used to get the next page of databases.
	NextLink *string

	// The list of databases housed in a server
	Value []*Database
}

DatabaseListResult - A List of databases.

func (DatabaseListResult) MarshalJSON 

func (d DatabaseListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DatabaseListResult.

func (*DatabaseListResult) UnmarshalJSON 

func (d *DatabaseListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DatabaseListResult.

type DatabaseProperties 

type DatabaseProperties struct {
	// The charset of the database.
	Charset *string

	// The collation of the database.
	Collation *string
}

DatabaseProperties - The properties of a database.

func (DatabaseProperties) MarshalJSON 

func (d DatabaseProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DatabaseProperties.

func (*DatabaseProperties) UnmarshalJSON 

func (d *DatabaseProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DatabaseProperties.

type DatabasesClient 

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

DatabasesClient contains the methods for the Databases group. Don't use this type directly, use NewDatabasesClient() instead.

func NewDatabasesClient 

func NewDatabasesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DatabasesClient, error)

NewDatabasesClient creates a new instance of DatabasesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*DatabasesClient) BeginCreate 

func (client *DatabasesClient) BeginCreate(ctx context.Context, resourceGroupName string, serverName string, databaseName string, parameters Database, options *DatabasesClientBeginCreateOptions) (*runtime.Poller[DatabasesClientCreateResponse], error)

BeginCreate - Creates a new database or updates an existing database. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • databaseName - The name of the database.
  • parameters - The required parameters for creating or updating a database.
  • options - DatabasesClientBeginCreateOptions contains the optional parameters for the DatabasesClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/DatabaseCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewDatabasesClient().BeginCreate(ctx, "TestGroup", "testserver", "db1", armpostgresqlflexibleservers.Database{
	Properties: &armpostgresqlflexibleservers.DatabaseProperties{
		Charset:   to.Ptr("utf8"),
		Collation: to.Ptr("en_US.utf8"),
	},
}, 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.Database = armpostgresqlflexibleservers.Database{
// 	Name: to.Ptr("db1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/databases"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/databases/db1"),
// 	Properties: &armpostgresqlflexibleservers.DatabaseProperties{
// 		Charset: to.Ptr("utf8"),
// 		Collation: to.Ptr("en_US.utf8"),
// 	},
// }

Output:

func (*DatabasesClient) BeginDelete 

func (client *DatabasesClient) BeginDelete(ctx context.Context, resourceGroupName string, serverName string, databaseName string, options *DatabasesClientBeginDeleteOptions) (*runtime.Poller[DatabasesClientDeleteResponse], error)

BeginDelete - Deletes a database. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • databaseName - The name of the database.
  • options - DatabasesClientBeginDeleteOptions contains the optional parameters for the DatabasesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/DatabaseDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewDatabasesClient().BeginDelete(ctx, "TestGroup", "testserver", "db1", 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)
}

Output:

func (*DatabasesClient) Get 

func (client *DatabasesClient) Get(ctx context.Context, resourceGroupName string, serverName string, databaseName string, options *DatabasesClientGetOptions) (DatabasesClientGetResponse, error)

Get - Gets information about a database. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • databaseName - The name of the database.
  • options - DatabasesClientGetOptions contains the optional parameters for the DatabasesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/DatabaseGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewDatabasesClient().Get(ctx, "TestGroup", "testserver", "db1", 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.Database = armpostgresqlflexibleservers.Database{
// 	Name: to.Ptr("db1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/databases"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/databases/db1"),
// 	Properties: &armpostgresqlflexibleservers.DatabaseProperties{
// 		Charset: to.Ptr("utf8"),
// 		Collation: to.Ptr("en_US.utf8"),
// 	},
// }

Output:

func (*DatabasesClient) NewListByServerPager 

func (client *DatabasesClient) NewListByServerPager(resourceGroupName string, serverName string, options *DatabasesClientListByServerOptions) *runtime.Pager[DatabasesClientListByServerResponse]

NewListByServerPager - List all the databases in a given server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - DatabasesClientListByServerOptions contains the optional parameters for the DatabasesClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/DatabasesListByServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewDatabasesClient().NewListByServerPager("TestGroup", "testserver", 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.DatabaseListResult = armpostgresqlflexibleservers.DatabaseListResult{
	// 	Value: []*armpostgresqlflexibleservers.Database{
	// 		{
	// 			Name: to.Ptr("db1"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/databases"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/databases/db1"),
	// 			Properties: &armpostgresqlflexibleservers.DatabaseProperties{
	// 				Charset: to.Ptr("utf8"),
	// 				Collation: to.Ptr("en_US.utf8"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("db2"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/databases"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/databases/db2"),
	// 			Properties: &armpostgresqlflexibleservers.DatabaseProperties{
	// 				Charset: to.Ptr("utf8"),
	// 				Collation: to.Ptr("en_US.utf8"),
	// 			},
	// 	}},
	// }
}

Output:

type DatabasesClientBeginCreateOptions 

type DatabasesClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

DatabasesClientBeginCreateOptions contains the optional parameters for the DatabasesClient.BeginCreate method.

type DatabasesClientBeginDeleteOptions 

type DatabasesClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

DatabasesClientBeginDeleteOptions contains the optional parameters for the DatabasesClient.BeginDelete method.

type DatabasesClientCreateResponse 

type DatabasesClientCreateResponse struct {
	// Represents a Database.
	Database
}

DatabasesClientCreateResponse contains the response from method DatabasesClient.BeginCreate.

type DatabasesClientDeleteResponse 

type DatabasesClientDeleteResponse struct {
}

DatabasesClientDeleteResponse contains the response from method DatabasesClient.BeginDelete.

type DatabasesClientGetOptions 

type DatabasesClientGetOptions struct {
}

DatabasesClientGetOptions contains the optional parameters for the DatabasesClient.Get method.

type DatabasesClientGetResponse 

type DatabasesClientGetResponse struct {
	// Represents a Database.
	Database
}

DatabasesClientGetResponse contains the response from method DatabasesClient.Get.

type DatabasesClientListByServerOptions 

type DatabasesClientListByServerOptions struct {
}

DatabasesClientListByServerOptions contains the optional parameters for the DatabasesClient.NewListByServerPager method.

type DatabasesClientListByServerResponse 

type DatabasesClientListByServerResponse struct {
	// A List of databases.
	DatabaseListResult
}

DatabasesClientListByServerResponse contains the response from method DatabasesClient.NewListByServerPager.

type DbLevelValidationStatus 

type DbLevelValidationStatus struct {
	// Name of the database
	DatabaseName *string

	// End date-time of a database level validation
	EndedOn *time.Time

	// Start date-time of a database level validation
	StartedOn *time.Time

	// Summary of database level validations
	Summary []*ValidationSummaryItem
}

DbLevelValidationStatus - Validation status summary for an individual database

func (DbLevelValidationStatus) MarshalJSON 

func (d DbLevelValidationStatus) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DbLevelValidationStatus.

func (*DbLevelValidationStatus) UnmarshalJSON 

func (d *DbLevelValidationStatus) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DbLevelValidationStatus.

type DbMigrationStatus 

type DbMigrationStatus struct {
	// CDC applied changes counter
	AppliedChanges *int32

	// CDC delete counter
	CdcDeleteCounter *int32

	// CDC insert counter
	CdcInsertCounter *int32

	// CDC update counter
	CdcUpdateCounter *int32

	// Name of the database
	DatabaseName *string

	// End date-time of a migration state
	EndedOn *time.Time

	// Number of tables loaded during the migration of a DB
	FullLoadCompletedTables *int32

	// Number of tables errored out during the migration of a DB
	FullLoadErroredTables *int32

	// Number of tables loading during the migration of a DB
	FullLoadLoadingTables *int32

	// Number of tables queued for the migration of a DB
	FullLoadQueuedTables *int32

	// CDC incoming changes counter
	IncomingChanges *int32

	// Lag in seconds between source and target during online phase
	Latency *int32

	// Error message, if any, for the migration state
	Message *string

	// Migration operation of an individual database
	MigrationOperation *string

	// Migration db state of an individual database
	MigrationState *MigrationDbState

	// Start date-time of a migration state
	StartedOn *time.Time
}

DbMigrationStatus - Migration status of an individual database

func (DbMigrationStatus) MarshalJSON 

func (d DbMigrationStatus) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DbMigrationStatus.

func (*DbMigrationStatus) UnmarshalJSON 

func (d *DbMigrationStatus) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DbMigrationStatus.

type DbServerMetadata 

type DbServerMetadata struct {
	// SKU for the database server. This object is empty for PG single server
	SKU *ServerSKU

	// Storage size in MB for database server
	StorageMb *int32

	// Version for database engine
	Version *string

	// READ-ONLY; Location of database server
	Location *string
}

DbServerMetadata - Database server metadata.

func (DbServerMetadata) MarshalJSON 

func (d DbServerMetadata) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DbServerMetadata.

func (*DbServerMetadata) UnmarshalJSON 

func (d *DbServerMetadata) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DbServerMetadata.

type DelegatedSubnetUsage 

type DelegatedSubnetUsage struct {
	// READ-ONLY; Name of the delegated subnet for which IP addresses are in use
	SubnetName *string

	// READ-ONLY; Number of IP addresses used by the delegated subnet
	Usage *int64
}

DelegatedSubnetUsage - Delegated subnet usage data.

func (DelegatedSubnetUsage) MarshalJSON 

func (d DelegatedSubnetUsage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DelegatedSubnetUsage.

func (*DelegatedSubnetUsage) UnmarshalJSON 

func (d *DelegatedSubnetUsage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DelegatedSubnetUsage.

type ExecutionStatus 

type ExecutionStatus string

ExecutionStatus - Service-set extensible enum indicating the status of operation 

const (
	ExecutionStatusCancelled ExecutionStatus = "Cancelled"
	ExecutionStatusFailed    ExecutionStatus = "Failed"
	ExecutionStatusRunning   ExecutionStatus = "Running"
	ExecutionStatusSucceeded ExecutionStatus = "Succeeded"
)

func PossibleExecutionStatusValues 

func PossibleExecutionStatusValues() []ExecutionStatus

PossibleExecutionStatusValues returns the possible values for the ExecutionStatus const type.

type FailoverMode 

type FailoverMode string

FailoverMode - Failover mode. 

const (
	FailoverModeForcedFailover    FailoverMode = "ForcedFailover"
	FailoverModeForcedSwitchover  FailoverMode = "ForcedSwitchover"
	FailoverModePlannedFailover   FailoverMode = "PlannedFailover"
	FailoverModePlannedSwitchover FailoverMode = "PlannedSwitchover"
)

func PossibleFailoverModeValues 

func PossibleFailoverModeValues() []FailoverMode

PossibleFailoverModeValues returns the possible values for the FailoverMode const type.

type FastProvisioningEditionCapability 

type FastProvisioningEditionCapability struct {
	// READ-ONLY; The reason for the capability not being available.
	Reason *string

	// READ-ONLY; Count of servers in cache matching the spec
	ServerCount *int32

	// READ-ONLY; The status of the capability.
	Status *CapabilityStatus

	// READ-ONLY; Fast provisioning supported sku name
	SupportedSKU *string

	// READ-ONLY; Fast provisioning supported version
	SupportedServerVersions *string

	// READ-ONLY; Fast provisioning supported storage in Gb
	SupportedStorageGb *int32

	// READ-ONLY; Fast provisioning supported tier name
	SupportedTier *string
}

FastProvisioningEditionCapability - Represents capability of a fast provisioning edition

func (FastProvisioningEditionCapability) MarshalJSON 

func (f FastProvisioningEditionCapability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FastProvisioningEditionCapability.

func (*FastProvisioningEditionCapability) UnmarshalJSON 

func (f *FastProvisioningEditionCapability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FastProvisioningEditionCapability.

type FastProvisioningSupportedEnum 

type FastProvisioningSupportedEnum string

FastProvisioningSupportedEnum - Gets a value indicating whether fast provisioning is supported. "Enabled" means fast provisioning is supported. "Disabled" stands for fast provisioning is not supported. 

const (
	FastProvisioningSupportedEnumDisabled FastProvisioningSupportedEnum = "Disabled"
	FastProvisioningSupportedEnumEnabled  FastProvisioningSupportedEnum = "Enabled"
)

func PossibleFastProvisioningSupportedEnumValues 

func PossibleFastProvisioningSupportedEnumValues() []FastProvisioningSupportedEnum

PossibleFastProvisioningSupportedEnumValues returns the possible values for the FastProvisioningSupportedEnum const type.

type FirewallRule 

type FirewallRule struct {
	// REQUIRED; The properties of a firewall rule.
	Properties *FirewallRuleProperties

	// 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
}

FirewallRule - Represents a server firewall rule.

func (FirewallRule) MarshalJSON 

func (f FirewallRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FirewallRule.

func (*FirewallRule) UnmarshalJSON 

func (f *FirewallRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FirewallRule.

type FirewallRuleListResult 

type FirewallRuleListResult struct {
	// The link used to get the next page of operations.
	NextLink *string

	// The list of firewall rules in a server.
	Value []*FirewallRule
}

FirewallRuleListResult - A list of firewall rules.

func (FirewallRuleListResult) MarshalJSON 

func (f FirewallRuleListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FirewallRuleListResult.

func (*FirewallRuleListResult) UnmarshalJSON 

func (f *FirewallRuleListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FirewallRuleListResult.

type FirewallRuleProperties 

type FirewallRuleProperties struct {
	// REQUIRED; The end IP address of the server firewall rule. Must be IPv4 format.
	EndIPAddress *string

	// REQUIRED; The start IP address of the server firewall rule. Must be IPv4 format.
	StartIPAddress *string
}

FirewallRuleProperties - The properties of a server firewall rule.

func (FirewallRuleProperties) MarshalJSON 

func (f FirewallRuleProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FirewallRuleProperties.

func (*FirewallRuleProperties) UnmarshalJSON 

func (f *FirewallRuleProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FirewallRuleProperties.

type FirewallRulesClient 

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

FirewallRulesClient contains the methods for the FirewallRules group. Don't use this type directly, use NewFirewallRulesClient() instead.

func NewFirewallRulesClient 

func NewFirewallRulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*FirewallRulesClient, error)

NewFirewallRulesClient creates a new instance of FirewallRulesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*FirewallRulesClient) BeginCreateOrUpdate 

func (client *FirewallRulesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, serverName string, firewallRuleName string, parameters FirewallRule, options *FirewallRulesClientBeginCreateOrUpdateOptions) (*runtime.Poller[FirewallRulesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates a new firewall rule or updates an existing firewall rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • firewallRuleName - The name of the server firewall rule.
  • parameters - The required parameters for creating or updating a firewall rule.
  • options - FirewallRulesClientBeginCreateOrUpdateOptions contains the optional parameters for the FirewallRulesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/FirewallRuleCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewFirewallRulesClient().BeginCreateOrUpdate(ctx, "testrg", "testserver", "rule1", armpostgresqlflexibleservers.FirewallRule{
	Properties: &armpostgresqlflexibleservers.FirewallRuleProperties{
		EndIPAddress:   to.Ptr("255.255.255.255"),
		StartIPAddress: to.Ptr("0.0.0.0"),
	},
}, 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.FirewallRule = armpostgresqlflexibleservers.FirewallRule{
// 	Name: to.Ptr("rule1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/firewallRules"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/testserver/firewallRules/rule1"),
// 	Properties: &armpostgresqlflexibleservers.FirewallRuleProperties{
// 		EndIPAddress: to.Ptr("255.255.255.255"),
// 		StartIPAddress: to.Ptr("0.0.0.0"),
// 	},
// }

Output:

func (*FirewallRulesClient) BeginDelete 

func (client *FirewallRulesClient) BeginDelete(ctx context.Context, resourceGroupName string, serverName string, firewallRuleName string, options *FirewallRulesClientBeginDeleteOptions) (*runtime.Poller[FirewallRulesClientDeleteResponse], error)

BeginDelete - Deletes a PostgreSQL server firewall rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • firewallRuleName - The name of the server firewall rule.
  • options - FirewallRulesClientBeginDeleteOptions contains the optional parameters for the FirewallRulesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/FirewallRuleDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewFirewallRulesClient().BeginDelete(ctx, "testrg", "testserver", "rule1", 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)
}

Output:

func (*FirewallRulesClient) Get 

func (client *FirewallRulesClient) Get(ctx context.Context, resourceGroupName string, serverName string, firewallRuleName string, options *FirewallRulesClientGetOptions) (FirewallRulesClientGetResponse, error)

Get - List all the firewall rules in a given server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • firewallRuleName - The name of the server firewall rule.
  • options - FirewallRulesClientGetOptions contains the optional parameters for the FirewallRulesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/FirewallRuleGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewFirewallRulesClient().Get(ctx, "testrg", "testserver", "rule1", 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.FirewallRule = armpostgresqlflexibleservers.FirewallRule{
// 	Name: to.Ptr("rule1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/firewallRules"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/testserver/firewallRules/rule1"),
// 	Properties: &armpostgresqlflexibleservers.FirewallRuleProperties{
// 		EndIPAddress: to.Ptr("255.255.255.255"),
// 		StartIPAddress: to.Ptr("0.0.0.0"),
// 	},
// }

Output:

func (*FirewallRulesClient) NewListByServerPager 

func (client *FirewallRulesClient) NewListByServerPager(resourceGroupName string, serverName string, options *FirewallRulesClientListByServerOptions) *runtime.Pager[FirewallRulesClientListByServerResponse]

NewListByServerPager - List all the firewall rules in a given PostgreSQL server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - FirewallRulesClientListByServerOptions contains the optional parameters for the FirewallRulesClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/FirewallRuleListByServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewFirewallRulesClient().NewListByServerPager("testrg", "testserver", 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.FirewallRuleListResult = armpostgresqlflexibleservers.FirewallRuleListResult{
	// 	Value: []*armpostgresqlflexibleservers.FirewallRule{
	// 		{
	// 			Name: to.Ptr("rule1"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/firewallRules"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/firewallRules/rule1"),
	// 			Properties: &armpostgresqlflexibleservers.FirewallRuleProperties{
	// 				EndIPAddress: to.Ptr("255.255.255.255"),
	// 				StartIPAddress: to.Ptr("0.0.0.0"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("rule2"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/firewallRules"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testserver/firewallRules/rule2"),
	// 			Properties: &armpostgresqlflexibleservers.FirewallRuleProperties{
	// 				EndIPAddress: to.Ptr("255.0.0.0"),
	// 				StartIPAddress: to.Ptr("1.0.0.0"),
	// 			},
	// 	}},
	// }
}

Output:

type FirewallRulesClientBeginCreateOrUpdateOptions 

type FirewallRulesClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

FirewallRulesClientBeginCreateOrUpdateOptions contains the optional parameters for the FirewallRulesClient.BeginCreateOrUpdate method.

type FirewallRulesClientBeginDeleteOptions 

type FirewallRulesClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

FirewallRulesClientBeginDeleteOptions contains the optional parameters for the FirewallRulesClient.BeginDelete method.

type FirewallRulesClientCreateOrUpdateResponse 

type FirewallRulesClientCreateOrUpdateResponse struct {
	// Represents a server firewall rule.
	FirewallRule
}

FirewallRulesClientCreateOrUpdateResponse contains the response from method FirewallRulesClient.BeginCreateOrUpdate.

type FirewallRulesClientDeleteResponse 

type FirewallRulesClientDeleteResponse struct {
}

FirewallRulesClientDeleteResponse contains the response from method FirewallRulesClient.BeginDelete.

type FirewallRulesClientGetOptions 

type FirewallRulesClientGetOptions struct {
}

FirewallRulesClientGetOptions contains the optional parameters for the FirewallRulesClient.Get method.

type FirewallRulesClientGetResponse 

type FirewallRulesClientGetResponse struct {
	// Represents a server firewall rule.
	FirewallRule
}

FirewallRulesClientGetResponse contains the response from method FirewallRulesClient.Get.

type FirewallRulesClientListByServerOptions 

type FirewallRulesClientListByServerOptions struct {
}

FirewallRulesClientListByServerOptions contains the optional parameters for the FirewallRulesClient.NewListByServerPager method.

type FirewallRulesClientListByServerResponse 

type FirewallRulesClientListByServerResponse struct {
	// A list of firewall rules.
	FirewallRuleListResult
}

FirewallRulesClientListByServerResponse contains the response from method FirewallRulesClient.NewListByServerPager.

type FlexibleServerCapability 

type FlexibleServerCapability struct {
	// Name of flexible servers capability
	Name *string

	// READ-ONLY; Gets a value indicating whether fast provisioning is supported. "Enabled" means fast provisioning is supported.
	// "Disabled" stands for fast provisioning is not supported.
	FastProvisioningSupported *FastProvisioningSupportedEnum

	// READ-ONLY; Determines if geo-backup is supported in this region. "Enabled" means geo-backup is supported. "Disabled" stands
	// for geo-back is not supported.
	GeoBackupSupported *GeoBackupSupportedEnum

	// READ-ONLY; A value indicating whether online resize is supported in this region for the given subscription. "Enabled" means
	// storage online resize is supported. "Disabled" means storage online resize is not
	// supported.
	OnlineResizeSupported *OnlineResizeSupportedEnum

	// READ-ONLY; The reason for the capability not being available.
	Reason *string

	// READ-ONLY; A value indicating whether this region is restricted. "Enabled" means region is restricted. "Disabled" stands
	// for region is not restricted.
	Restricted *RestrictedEnum

	// READ-ONLY; The status of the capability.
	Status *CapabilityStatus

	// READ-ONLY; A value indicating whether storage auto-grow is supported in this region. "Enabled" means storage auto-grow
	// is supported. "Disabled" stands for storage auto-grow is not supported.
	StorageAutoGrowthSupported *StorageAutoGrowthSupportedEnum

	// READ-ONLY; List of supported server editions for fast provisioning
	SupportedFastProvisioningEditions []*FastProvisioningEditionCapability

	// READ-ONLY; List of supported flexible server editions
	SupportedServerEditions []*FlexibleServerEditionCapability

	// READ-ONLY; The list of server versions supported for this capability.
	SupportedServerVersions []*ServerVersionCapability

	// READ-ONLY; A value indicating whether Zone Redundant HA and Geo-backup is supported in this region. "Enabled" means zone
	// redundant HA and geo-backup is supported. "Disabled" stands for zone redundant HA and
	// geo-backup is not supported.
	ZoneRedundantHaAndGeoBackupSupported *ZoneRedundantHaAndGeoBackupSupportedEnum

	// READ-ONLY; A value indicating whether Zone Redundant HA is supported in this region. "Enabled" means zone redundant HA
	// is supported. "Disabled" stands for zone redundant HA is not supported.
	ZoneRedundantHaSupported *ZoneRedundantHaSupportedEnum
}

FlexibleServerCapability - Capability for the PostgreSQL server

func (FlexibleServerCapability) MarshalJSON 

func (f FlexibleServerCapability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FlexibleServerCapability.

func (*FlexibleServerCapability) UnmarshalJSON 

func (f *FlexibleServerCapability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FlexibleServerCapability.

type FlexibleServerClient 

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

FlexibleServerClient contains the methods for the FlexibleServer group. Don't use this type directly, use NewFlexibleServerClient() instead.

func NewFlexibleServerClient 

func NewFlexibleServerClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*FlexibleServerClient, error)

NewFlexibleServerClient creates a new instance of FlexibleServerClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*FlexibleServerClient) BeginStartLtrBackup 

func (client *FlexibleServerClient) BeginStartLtrBackup(ctx context.Context, resourceGroupName string, serverName string, parameters LtrBackupRequest, options *FlexibleServerClientBeginStartLtrBackupOptions) (*runtime.Poller[FlexibleServerClientStartLtrBackupResponse], error)

BeginStartLtrBackup - Start the Long Term Retention Backup operation If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • parameters - Request body for operation
  • options - FlexibleServerClientBeginStartLtrBackupOptions contains the optional parameters for the FlexibleServerClient.BeginStartLtrBackup method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/LongTermRetentionBackup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewFlexibleServerClient().BeginStartLtrBackup(ctx, "rgLongTermRetention", "pgsqlltrtestserver", armpostgresqlflexibleservers.LtrBackupRequest{
	BackupSettings: &armpostgresqlflexibleservers.BackupSettings{
		BackupName: to.Ptr("backup1"),
	},
	TargetDetails: &armpostgresqlflexibleservers.BackupStoreDetails{
		SasURIList: []*string{
			to.Ptr("sasuri")},
	},
}, 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.LtrBackupResponse = armpostgresqlflexibleservers.LtrBackupResponse{
// 	Properties: &armpostgresqlflexibleservers.LtrBackupOperationResponseProperties{
// 		BackupMetadata: to.Ptr("backupmetadata"),
// 		DataTransferredInBytes: to.Ptr[int64](23),
// 		DatasourceSizeInBytes: to.Ptr[int64](23),
// 		EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-13T01:32:30.128Z"); return t}()),
// 		PercentComplete: to.Ptr[float64](100),
// 		StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-13T01:32:30.128Z"); return t}()),
// 		Status: to.Ptr(armpostgresqlflexibleservers.ExecutionStatusRunning),
// 	},
// }

Output:

func (*FlexibleServerClient) TriggerLtrPreBackup 

func (client *FlexibleServerClient) TriggerLtrPreBackup(ctx context.Context, resourceGroupName string, serverName string, parameters LtrPreBackupRequest, options *FlexibleServerClientTriggerLtrPreBackupOptions) (FlexibleServerClientTriggerLtrPreBackupResponse, error)

TriggerLtrPreBackup - PreBackup operation performs all the checks that are needed for the subsequent long term retention backup operation to succeed. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • parameters - Request body for operation
  • options - FlexibleServerClientTriggerLtrPreBackupOptions contains the optional parameters for the FlexibleServerClient.TriggerLtrPreBackup method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/LongTermRetentionPreBackup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewFlexibleServerClient().TriggerLtrPreBackup(ctx, "rgLongTermRetention", "pgsqlltrtestserver", armpostgresqlflexibleservers.LtrPreBackupRequest{
	BackupSettings: &armpostgresqlflexibleservers.BackupSettings{
		BackupName: to.Ptr("backup1"),
	},
}, 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.LtrPreBackupResponse = armpostgresqlflexibleservers.LtrPreBackupResponse{
// 	Properties: &armpostgresqlflexibleservers.LtrPreBackupResponseProperties{
// 		NumberOfContainers: to.Ptr[int32](1),
// 	},
// }

Output:

type FlexibleServerClientBeginStartLtrBackupOptions 

type FlexibleServerClientBeginStartLtrBackupOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

FlexibleServerClientBeginStartLtrBackupOptions contains the optional parameters for the FlexibleServerClient.BeginStartLtrBackup method.

type FlexibleServerClientStartLtrBackupResponse 

type FlexibleServerClientStartLtrBackupResponse struct {
	// Response for the LTR backup API call
	LtrBackupResponse
}

FlexibleServerClientStartLtrBackupResponse contains the response from method FlexibleServerClient.BeginStartLtrBackup.

type FlexibleServerClientTriggerLtrPreBackupOptions 

type FlexibleServerClientTriggerLtrPreBackupOptions struct {
}

FlexibleServerClientTriggerLtrPreBackupOptions contains the optional parameters for the FlexibleServerClient.TriggerLtrPreBackup method.

type FlexibleServerClientTriggerLtrPreBackupResponse 

type FlexibleServerClientTriggerLtrPreBackupResponse struct {
	// Response for the LTR pre-backup API call
	LtrPreBackupResponse

	// XMSRequestID contains the information returned from the x-ms-request-id header response.
	XMSRequestID *string
}

FlexibleServerClientTriggerLtrPreBackupResponse contains the response from method FlexibleServerClient.TriggerLtrPreBackup.

type FlexibleServerEditionCapability 

type FlexibleServerEditionCapability struct {
	// READ-ONLY; Default sku name for the server edition
	DefaultSKUName *string

	// READ-ONLY; Server edition name
	Name *string

	// READ-ONLY; The reason for the capability not being available.
	Reason *string

	// READ-ONLY; The status of the capability.
	Status *CapabilityStatus

	// READ-ONLY; List of supported server SKUs.
	SupportedServerSKUs []*ServerSKUCapability

	// READ-ONLY; The list of editions supported by this server edition.
	SupportedStorageEditions []*StorageEditionCapability
}

FlexibleServerEditionCapability - Flexible server edition capabilities.

func (FlexibleServerEditionCapability) MarshalJSON 

func (f FlexibleServerEditionCapability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FlexibleServerEditionCapability.

func (*FlexibleServerEditionCapability) UnmarshalJSON 

func (f *FlexibleServerEditionCapability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FlexibleServerEditionCapability.

type GeoBackupSupportedEnum 

type GeoBackupSupportedEnum string

GeoBackupSupportedEnum - Determines if geo-backup is supported in this region. "Enabled" means geo-backup is supported. "Disabled" stands for geo-back is not supported. 

const (
	GeoBackupSupportedEnumDisabled GeoBackupSupportedEnum = "Disabled"
	GeoBackupSupportedEnumEnabled  GeoBackupSupportedEnum = "Enabled"
)

func PossibleGeoBackupSupportedEnumValues 

func PossibleGeoBackupSupportedEnumValues() []GeoBackupSupportedEnum

PossibleGeoBackupSupportedEnumValues returns the possible values for the GeoBackupSupportedEnum const type.

type GeoRedundantBackupEnum 

type GeoRedundantBackupEnum string

GeoRedundantBackupEnum - A value indicating whether Geo-Redundant backup is enabled on the server. 

const (
	GeoRedundantBackupEnumDisabled GeoRedundantBackupEnum = "Disabled"
	GeoRedundantBackupEnumEnabled  GeoRedundantBackupEnum = "Enabled"
)

func PossibleGeoRedundantBackupEnumValues 

func PossibleGeoRedundantBackupEnumValues() []GeoRedundantBackupEnum

PossibleGeoRedundantBackupEnumValues returns the possible values for the GeoRedundantBackupEnum const type.

type GetPrivateDNSZoneSuffixClient 

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

GetPrivateDNSZoneSuffixClient contains the methods for the GetPrivateDNSZoneSuffix group. Don't use this type directly, use NewGetPrivateDNSZoneSuffixClient() instead.

func NewGetPrivateDNSZoneSuffixClient 

func NewGetPrivateDNSZoneSuffixClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*GetPrivateDNSZoneSuffixClient, error)

NewGetPrivateDNSZoneSuffixClient creates a new instance of GetPrivateDNSZoneSuffixClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*GetPrivateDNSZoneSuffixClient) Execute 

func (client *GetPrivateDNSZoneSuffixClient) Execute(ctx context.Context, options *GetPrivateDNSZoneSuffixClientExecuteOptions) (GetPrivateDNSZoneSuffixClientExecuteResponse, error)

Execute - Get private DNS zone suffix in the cloud If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • options - GetPrivateDNSZoneSuffixClientExecuteOptions contains the optional parameters for the GetPrivateDNSZoneSuffixClient.Execute method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/GetPrivateDnsZoneSuffix.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewGetPrivateDNSZoneSuffixClient().Execute(ctx, 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.Value = "postgres.database.azure.com"

Output:

type GetPrivateDNSZoneSuffixClientExecuteOptions 

type GetPrivateDNSZoneSuffixClientExecuteOptions struct {
}

GetPrivateDNSZoneSuffixClientExecuteOptions contains the optional parameters for the GetPrivateDNSZoneSuffixClient.Execute method.

type GetPrivateDNSZoneSuffixClientExecuteResponse 

type GetPrivateDNSZoneSuffixClientExecuteResponse struct {
	// Represents a resource name availability.
	Value *string
}

GetPrivateDNSZoneSuffixClientExecuteResponse contains the response from method GetPrivateDNSZoneSuffixClient.Execute.

type HaMode 

type HaMode string

HaMode - HA mode supported for a server. 

const (
	HaModeSameZone      HaMode = "SameZone"
	HaModeZoneRedundant HaMode = "ZoneRedundant"
)

func PossibleHaModeValues 

func PossibleHaModeValues() []HaMode

PossibleHaModeValues returns the possible values for the HaMode const type.

type HighAvailability 

type HighAvailability struct {
	// The HA mode for the server.
	Mode *HighAvailabilityMode

	// availability zone information of the standby.
	StandbyAvailabilityZone *string

	// READ-ONLY; A state of a HA server that is visible to user.
	State *ServerHAState
}

HighAvailability - High availability properties of a server

func (HighAvailability) MarshalJSON 

func (h HighAvailability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HighAvailability.

func (*HighAvailability) UnmarshalJSON 

func (h *HighAvailability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HighAvailability.

type HighAvailabilityMode 

type HighAvailabilityMode string

HighAvailabilityMode - The HA mode for the server. 

const (
	HighAvailabilityModeDisabled      HighAvailabilityMode = "Disabled"
	HighAvailabilityModeSameZone      HighAvailabilityMode = "SameZone"
	HighAvailabilityModeZoneRedundant HighAvailabilityMode = "ZoneRedundant"
)

func PossibleHighAvailabilityModeValues 

func PossibleHighAvailabilityModeValues() []HighAvailabilityMode

PossibleHighAvailabilityModeValues returns the possible values for the HighAvailabilityMode const type.

type IdentityType 

type IdentityType string

IdentityType - the types of identities associated with this resource; currently restricted to 'None and UserAssigned' 

const (
	IdentityTypeNone         IdentityType = "None"
	IdentityTypeUserAssigned IdentityType = "UserAssigned"
)

func PossibleIdentityTypeValues 

func PossibleIdentityTypeValues() []IdentityType

PossibleIdentityTypeValues returns the possible values for the IdentityType const type.

type KeyStatusEnum 

type KeyStatusEnum string

KeyStatusEnum - Primary encryption key status for Data encryption enabled server. 

const (
	KeyStatusEnumInvalid KeyStatusEnum = "Invalid"
	KeyStatusEnumValid   KeyStatusEnum = "Valid"
)

func PossibleKeyStatusEnumValues 

func PossibleKeyStatusEnumValues() []KeyStatusEnum

PossibleKeyStatusEnumValues returns the possible values for the KeyStatusEnum const type.

type LocationBasedCapabilitiesClient 

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

LocationBasedCapabilitiesClient contains the methods for the LocationBasedCapabilities group. Don't use this type directly, use NewLocationBasedCapabilitiesClient() instead.

func NewLocationBasedCapabilitiesClient 

func NewLocationBasedCapabilitiesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*LocationBasedCapabilitiesClient, error)

NewLocationBasedCapabilitiesClient creates a new instance of LocationBasedCapabilitiesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*LocationBasedCapabilitiesClient) NewExecutePager 

func (client *LocationBasedCapabilitiesClient) NewExecutePager(locationName string, options *LocationBasedCapabilitiesClientExecuteOptions) *runtime.Pager[LocationBasedCapabilitiesClientExecuteResponse]

NewExecutePager - Get capabilities at specified location in a given subscription.

Generated from API version 2023-12-01-preview

  • locationName - The name of the location.
  • options - LocationBasedCapabilitiesClientExecuteOptions contains the optional parameters for the LocationBasedCapabilitiesClient.NewExecutePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/CapabilitiesByLocation.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewLocationBasedCapabilitiesClient().NewExecutePager("westus", 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.CapabilitiesListResult = armpostgresqlflexibleservers.CapabilitiesListResult{
	// 	Value: []*armpostgresqlflexibleservers.FlexibleServerCapability{
	// 		{
	// 			Name: to.Ptr("FlexibleServerCapabilities"),
	// 			FastProvisioningSupported: to.Ptr(armpostgresqlflexibleservers.FastProvisioningSupportedEnumEnabled),
	// 			GeoBackupSupported: to.Ptr(armpostgresqlflexibleservers.GeoBackupSupportedEnumEnabled),
	// 			OnlineResizeSupported: to.Ptr(armpostgresqlflexibleservers.OnlineResizeSupportedEnumDisabled),
	// 			Restricted: to.Ptr(armpostgresqlflexibleservers.RestrictedEnumDisabled),
	// 			StorageAutoGrowthSupported: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowthSupportedEnumEnabled),
	// 			SupportedFastProvisioningEditions: []*armpostgresqlflexibleservers.FastProvisioningEditionCapability{
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("12"),
	// 					SupportedSKU: to.Ptr("standard_b1ms"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("12"),
	// 					SupportedSKU: to.Ptr("standard_b2s"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("12"),
	// 					SupportedSKU: to.Ptr("standard_d2s_v3"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("12"),
	// 					SupportedSKU: to.Ptr("standard_d2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("12"),
	// 					SupportedSKU: to.Ptr("standard_e2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](512),
	// 					SupportedTier: to.Ptr("MemoryOptimized"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("13"),
	// 					SupportedSKU: to.Ptr("standard_b1ms"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("13"),
	// 					SupportedSKU: to.Ptr("standard_b2s"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("13"),
	// 					SupportedSKU: to.Ptr("standard_d2s_v3"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("13"),
	// 					SupportedSKU: to.Ptr("standard_d2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("13"),
	// 					SupportedSKU: to.Ptr("standard_e2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](512),
	// 					SupportedTier: to.Ptr("MemoryOptimized"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](23),
	// 					SupportedServerVersions: to.Ptr("14"),
	// 					SupportedSKU: to.Ptr("standard_b1ms"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("14"),
	// 					SupportedSKU: to.Ptr("standard_b2s"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("14"),
	// 					SupportedSKU: to.Ptr("standard_d2s_v3"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("14"),
	// 					SupportedSKU: to.Ptr("standard_d2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("14"),
	// 					SupportedSKU: to.Ptr("standard_e2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](512),
	// 					SupportedTier: to.Ptr("MemoryOptimized"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("15"),
	// 					SupportedSKU: to.Ptr("standard_b1ms"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("15"),
	// 					SupportedSKU: to.Ptr("standard_b2s"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("15"),
	// 					SupportedSKU: to.Ptr("standard_d2s_v3"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("15"),
	// 					SupportedSKU: to.Ptr("standard_d2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("15"),
	// 					SupportedSKU: to.Ptr("standard_e2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](512),
	// 					SupportedTier: to.Ptr("MemoryOptimized"),
	// 			}},
	// 			SupportedServerEditions: []*armpostgresqlflexibleservers.FlexibleServerEditionCapability{
	// 				{
	// 					Name: to.Ptr("Burstable"),
	// 					DefaultSKUName: to.Ptr("Standard_B1ms"),
	// 					SupportedServerSKUs: []*armpostgresqlflexibleservers.ServerSKUCapability{
	// 						{
	// 							Name: to.Ptr("Standard_B1ms"),
	// 							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 								SupportedIops: to.Ptr[int32](640),
	// 								SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 								SupportedZones: []*string{
	// 									to.Ptr("1"),
	// 									to.Ptr("2"),
	// 									to.Ptr("3")},
	// 									VCores: to.Ptr[int32](1),
	// 								},
	// 								{
	// 									Name: to.Ptr("Standard_B2s"),
	// 									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 										SupportedIops: to.Ptr[int32](1280),
	// 										SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 										SupportedZones: []*string{
	// 											to.Ptr("1"),
	// 											to.Ptr("2"),
	// 											to.Ptr("3")},
	// 											VCores: to.Ptr[int32](2),
	// 										},
	// 										{
	// 											Name: to.Ptr("Standard_B2ms"),
	// 											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 												SupportedIops: to.Ptr[int32](1700),
	// 												SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 												SupportedZones: []*string{
	// 													to.Ptr("1"),
	// 													to.Ptr("2"),
	// 													to.Ptr("3")},
	// 													VCores: to.Ptr[int32](2),
	// 												},
	// 												{
	// 													Name: to.Ptr("Standard_B4ms"),
	// 													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 														SupportedIops: to.Ptr[int32](2400),
	// 														SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 														SupportedZones: []*string{
	// 															to.Ptr("1"),
	// 															to.Ptr("2"),
	// 															to.Ptr("3")},
	// 															VCores: to.Ptr[int32](4),
	// 														},
	// 														{
	// 															Name: to.Ptr("Standard_B8ms"),
	// 															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																SupportedIops: to.Ptr[int32](3100),
	// 																SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 																SupportedZones: []*string{
	// 																	to.Ptr("1"),
	// 																	to.Ptr("2"),
	// 																	to.Ptr("3")},
	// 																	VCores: to.Ptr[int32](8),
	// 																},
	// 																{
	// 																	Name: to.Ptr("Standard_B12ms"),
	// 																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																		SupportedIops: to.Ptr[int32](3800),
	// 																		SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 																		SupportedZones: []*string{
	// 																			to.Ptr("1"),
	// 																			to.Ptr("2"),
	// 																			to.Ptr("3")},
	// 																			VCores: to.Ptr[int32](12),
	// 																		},
	// 																		{
	// 																			Name: to.Ptr("Standard_B16ms"),
	// 																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																				SupportedIops: to.Ptr[int32](4300),
	// 																				SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 																				SupportedZones: []*string{
	// 																					to.Ptr("1"),
	// 																					to.Ptr("2"),
	// 																					to.Ptr("3")},
	// 																					VCores: to.Ptr[int32](16),
	// 																				},
	// 																				{
	// 																					Name: to.Ptr("Standard_B20ms"),
	// 																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																						SupportedIops: to.Ptr[int32](5000),
	// 																						SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 																						SupportedZones: []*string{
	// 																							to.Ptr("1"),
	// 																							to.Ptr("2"),
	// 																							to.Ptr("3")},
	// 																							VCores: to.Ptr[int32](20),
	// 																					}},
	// 																					SupportedStorageEditions: []*armpostgresqlflexibleservers.StorageEditionCapability{
	// 																						{
	// 																							Name: to.Ptr("ManagedDisk"),
	// 																							DefaultStorageSizeMb: to.Ptr[int64](32768),
	// 																							SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P4"),
	// 																									StorageSizeMb: to.Ptr[int64](32768),
	// 																									SupportedIops: to.Ptr[int32](120),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P4"),
	// 																											Iops: to.Ptr[int32](120),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P6"),
	// 																											Iops: to.Ptr[int32](240),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P10"),
	// 																											Iops: to.Ptr[int32](500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P15"),
	// 																											Iops: to.Ptr[int32](1100),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P20"),
	// 																											Iops: to.Ptr[int32](2300),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P6"),
	// 																									StorageSizeMb: to.Ptr[int64](65536),
	// 																									SupportedIops: to.Ptr[int32](240),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P6"),
	// 																											Iops: to.Ptr[int32](240),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P10"),
	// 																											Iops: to.Ptr[int32](500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P15"),
	// 																											Iops: to.Ptr[int32](1100),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P20"),
	// 																											Iops: to.Ptr[int32](2300),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P10"),
	// 																									StorageSizeMb: to.Ptr[int64](131072),
	// 																									SupportedIops: to.Ptr[int32](500),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P10"),
	// 																											Iops: to.Ptr[int32](500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P15"),
	// 																											Iops: to.Ptr[int32](1100),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P20"),
	// 																											Iops: to.Ptr[int32](2300),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P15"),
	// 																									StorageSizeMb: to.Ptr[int64](262144),
	// 																									SupportedIops: to.Ptr[int32](1100),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P15"),
	// 																											Iops: to.Ptr[int32](1100),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P20"),
	// 																											Iops: to.Ptr[int32](2300),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P20"),
	// 																									StorageSizeMb: to.Ptr[int64](524288),
	// 																									SupportedIops: to.Ptr[int32](2300),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P20"),
	// 																											Iops: to.Ptr[int32](2300),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P30"),
	// 																									StorageSizeMb: to.Ptr[int64](1048576),
	// 																									SupportedIops: to.Ptr[int32](5000),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P40"),
	// 																									StorageSizeMb: to.Ptr[int64](2097152),
	// 																									SupportedIops: to.Ptr[int32](7500),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P50"),
	// 																									StorageSizeMb: to.Ptr[int64](4194304),
	// 																									SupportedIops: to.Ptr[int32](7500),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P60"),
	// 																									StorageSizeMb: to.Ptr[int64](8388608),
	// 																									SupportedIops: to.Ptr[int32](16000),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P60"),
	// 																											Iops: to.Ptr[int32](16000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P70"),
	// 																											Iops: to.Ptr[int32](18000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P80"),
	// 																											Iops: to.Ptr[int32](20000),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P70"),
	// 																									StorageSizeMb: to.Ptr[int64](16777216),
	// 																									SupportedIops: to.Ptr[int32](18000),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P70"),
	// 																											Iops: to.Ptr[int32](18000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P80"),
	// 																											Iops: to.Ptr[int32](20000),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P80"),
	// 																									StorageSizeMb: to.Ptr[int64](33553408),
	// 																									SupportedIops: to.Ptr[int32](20000),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P80"),
	// 																											Iops: to.Ptr[int32](20000),
	// 																									}},
	// 																							}},
	// 																						},
	// 																						{
	// 																							Name: to.Ptr("ManagedDiskV2"),
	// 																							DefaultStorageSizeMb: to.Ptr[int64](65536),
	// 																							SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("None"),
	// 																									MaximumStorageSizeMb: to.Ptr[int64](67108864),
	// 																									StorageSizeMb: to.Ptr[int64](32768),
	// 																									SupportedIops: to.Ptr[int32](3000),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("None"),
	// 																											Iops: to.Ptr[int32](0),
	// 																									}},
	// 																									SupportedMaximumIops: to.Ptr[int32](80000),
	// 																									SupportedMaximumThroughput: to.Ptr[int32](750),
	// 																									SupportedThroughput: to.Ptr[int32](125),
	// 																							}},
	// 																					}},
	// 																				},
	// 																				{
	// 																					Name: to.Ptr("GeneralPurpose"),
	// 																					DefaultSKUName: to.Ptr("Standard_D2ds_v4"),
	// 																					SupportedServerSKUs: []*armpostgresqlflexibleservers.ServerSKUCapability{
	// 																						{
	// 																							Name: to.Ptr("Standard_D2s_v3"),
	// 																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																								SupportedIops: to.Ptr[int32](3200),
	// 																								SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																								SupportedZones: []*string{
	// 																									to.Ptr("1"),
	// 																									to.Ptr("2"),
	// 																									to.Ptr("3")},
	// 																									VCores: to.Ptr[int32](2),
	// 																								},
	// 																								{
	// 																									Name: to.Ptr("Standard_D4s_v3"),
	// 																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																										SupportedIops: to.Ptr[int32](6400),
	// 																										SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																										SupportedZones: []*string{
	// 																											to.Ptr("1"),
	// 																											to.Ptr("2"),
	// 																											to.Ptr("3")},
	// 																											VCores: to.Ptr[int32](4),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("Standard_D8s_v3"),
	// 																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																												SupportedIops: to.Ptr[int32](12800),
	// 																												SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																												SupportedZones: []*string{
	// 																													to.Ptr("1"),
	// 																													to.Ptr("2"),
	// 																													to.Ptr("3")},
	// 																													VCores: to.Ptr[int32](8),
	// 																												},
	// 																												{
	// 																													Name: to.Ptr("Standard_D16s_v3"),
	// 																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																														SupportedIops: to.Ptr[int32](20000),
	// 																														SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																														SupportedZones: []*string{
	// 																															to.Ptr("1"),
	// 																															to.Ptr("2"),
	// 																															to.Ptr("3")},
	// 																															VCores: to.Ptr[int32](16),
	// 																														},
	// 																														{
	// 																															Name: to.Ptr("Standard_D32s_v3"),
	// 																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																SupportedIops: to.Ptr[int32](20000),
	// 																																SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																SupportedZones: []*string{
	// 																																	to.Ptr("1"),
	// 																																	to.Ptr("2"),
	// 																																	to.Ptr("3")},
	// 																																	VCores: to.Ptr[int32](32),
	// 																																},
	// 																																{
	// 																																	Name: to.Ptr("Standard_D48s_v3"),
	// 																																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																		SupportedIops: to.Ptr[int32](20000),
	// 																																		SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																		SupportedZones: []*string{
	// 																																			to.Ptr("1"),
	// 																																			to.Ptr("2"),
	// 																																			to.Ptr("3")},
	// 																																			VCores: to.Ptr[int32](48),
	// 																																		},
	// 																																		{
	// 																																			Name: to.Ptr("Standard_D64s_v3"),
	// 																																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																				SupportedIops: to.Ptr[int32](20000),
	// 																																				SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																				SupportedZones: []*string{
	// 																																					to.Ptr("1"),
	// 																																					to.Ptr("2"),
	// 																																					to.Ptr("3")},
	// 																																					VCores: to.Ptr[int32](64),
	// 																																				},
	// 																																				{
	// 																																					Name: to.Ptr("Standard_D2ds_v4"),
	// 																																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																						SupportedIops: to.Ptr[int32](3200),
	// 																																						SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																						SupportedZones: []*string{
	// 																																							to.Ptr("1"),
	// 																																							to.Ptr("2"),
	// 																																							to.Ptr("3")},
	// 																																							VCores: to.Ptr[int32](2),
	// 																																						},
	// 																																						{
	// 																																							Name: to.Ptr("Standard_D4ds_v4"),
	// 																																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																								SupportedIops: to.Ptr[int32](6400),
	// 																																								SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																								SupportedZones: []*string{
	// 																																									to.Ptr("1"),
	// 																																									to.Ptr("2"),
	// 																																									to.Ptr("3")},
	// 																																									VCores: to.Ptr[int32](4),
	// 																																								},
	// 																																								{
	// 																																									Name: to.Ptr("Standard_D8ds_v4"),
	// 																																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																										SupportedIops: to.Ptr[int32](12800),
	// 																																										SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																										SupportedZones: []*string{
	// 																																											to.Ptr("1"),
	// 																																											to.Ptr("2"),
	// 																																											to.Ptr("3")},
	// 																																											VCores: to.Ptr[int32](8),
	// 																																										},
	// 																																										{
	// 																																											Name: to.Ptr("Standard_D16ds_v4"),
	// 																																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																												SupportedIops: to.Ptr[int32](20000),
	// 																																												SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																												SupportedZones: []*string{
	// 																																													to.Ptr("1"),
	// 																																													to.Ptr("2"),
	// 																																													to.Ptr("3")},
	// 																																													VCores: to.Ptr[int32](16),
	// 																																												},
	// 																																												{
	// 																																													Name: to.Ptr("Standard_D32ds_v4"),
	// 																																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																														SupportedIops: to.Ptr[int32](20000),
	// 																																														SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																														SupportedZones: []*string{
	// 																																															to.Ptr("1"),
	// 																																															to.Ptr("2"),
	// 																																															to.Ptr("3")},
	// 																																															VCores: to.Ptr[int32](32),
	// 																																														},
	// 																																														{
	// 																																															Name: to.Ptr("Standard_D48ds_v4"),
	// 																																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																SupportedIops: to.Ptr[int32](20000),
	// 																																																SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																SupportedZones: []*string{
	// 																																																	to.Ptr("1"),
	// 																																																	to.Ptr("2"),
	// 																																																	to.Ptr("3")},
	// 																																																	VCores: to.Ptr[int32](48),
	// 																																																},
	// 																																																{
	// 																																																	Name: to.Ptr("Standard_D64ds_v4"),
	// 																																																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																		SupportedIops: to.Ptr[int32](20000),
	// 																																																		SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																		SupportedZones: []*string{
	// 																																																			to.Ptr("1"),
	// 																																																			to.Ptr("2"),
	// 																																																			to.Ptr("3")},
	// 																																																			VCores: to.Ptr[int32](64),
	// 																																																		},
	// 																																																		{
	// 																																																			Name: to.Ptr("Standard_D2ads_v5"),
	// 																																																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																				SupportedIops: to.Ptr[int32](3200),
	// 																																																				SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																				SupportedZones: []*string{
	// 																																																					to.Ptr("1"),
	// 																																																					to.Ptr("2"),
	// 																																																					to.Ptr("3")},
	// 																																																					VCores: to.Ptr[int32](2),
	// 																																																				},
	// 																																																				{
	// 																																																					Name: to.Ptr("Standard_D4ads_v5"),
	// 																																																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																						SupportedIops: to.Ptr[int32](6400),
	// 																																																						SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																						SupportedZones: []*string{
	// 																																																							to.Ptr("1"),
	// 																																																							to.Ptr("2"),
	// 																																																							to.Ptr("3")},
	// 																																																							VCores: to.Ptr[int32](4),
	// 																																																						},
	// 																																																						{
	// 																																																							Name: to.Ptr("Standard_D8ads_v5"),
	// 																																																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																								SupportedIops: to.Ptr[int32](12800),
	// 																																																								SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																								SupportedZones: []*string{
	// 																																																									to.Ptr("1"),
	// 																																																									to.Ptr("2"),
	// 																																																									to.Ptr("3")},
	// 																																																									VCores: to.Ptr[int32](8),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Standard_D16ads_v5"),
	// 																																																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																										SupportedIops: to.Ptr[int32](20000),
	// 																																																										SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																										SupportedZones: []*string{
	// 																																																											to.Ptr("1"),
	// 																																																											to.Ptr("2"),
	// 																																																											to.Ptr("3")},
	// 																																																											VCores: to.Ptr[int32](16),
	// 																																																										},
	// 																																																										{
	// 																																																											Name: to.Ptr("Standard_D32ads_v5"),
	// 																																																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																												SupportedIops: to.Ptr[int32](20000),
	// 																																																												SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																												SupportedZones: []*string{
	// 																																																													to.Ptr("1"),
	// 																																																													to.Ptr("2"),
	// 																																																													to.Ptr("3")},
	// 																																																													VCores: to.Ptr[int32](32),
	// 																																																												},
	// 																																																												{
	// 																																																													Name: to.Ptr("Standard_D48ads_v5"),
	// 																																																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																														SupportedIops: to.Ptr[int32](20000),
	// 																																																														SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																														SupportedZones: []*string{
	// 																																																															to.Ptr("1"),
	// 																																																															to.Ptr("2"),
	// 																																																															to.Ptr("3")},
	// 																																																															VCores: to.Ptr[int32](48),
	// 																																																														},
	// 																																																														{
	// 																																																															Name: to.Ptr("Standard_D64ads_v5"),
	// 																																																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																SupportedIops: to.Ptr[int32](20000),
	// 																																																																SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																																SupportedZones: []*string{
	// 																																																																	to.Ptr("1"),
	// 																																																																	to.Ptr("2"),
	// 																																																																	to.Ptr("3")},
	// 																																																																	VCores: to.Ptr[int32](64),
	// 																																																																},
	// 																																																																{
	// 																																																																	Name: to.Ptr("Standard_D96ads_v5"),
	// 																																																																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																		SupportedIops: to.Ptr[int32](20000),
	// 																																																																		SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																																		SupportedZones: []*string{
	// 																																																																			to.Ptr("1"),
	// 																																																																			to.Ptr("2"),
	// 																																																																			to.Ptr("3")},
	// 																																																																			VCores: to.Ptr[int32](96),
	// 																																																																	}},
	// 																																																																	SupportedStorageEditions: []*armpostgresqlflexibleservers.StorageEditionCapability{
	// 																																																																		{
	// 																																																																			Name: to.Ptr("ManagedDisk"),
	// 																																																																			DefaultStorageSizeMb: to.Ptr[int64](65536),
	// 																																																																			SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P4"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](32768),
	// 																																																																					SupportedIops: to.Ptr[int32](120),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P4"),
	// 																																																																							Iops: to.Ptr[int32](120),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P6"),
	// 																																																																							Iops: to.Ptr[int32](240),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P10"),
	// 																																																																							Iops: to.Ptr[int32](500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P15"),
	// 																																																																							Iops: to.Ptr[int32](1100),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P20"),
	// 																																																																							Iops: to.Ptr[int32](2300),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P6"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](65536),
	// 																																																																					SupportedIops: to.Ptr[int32](240),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P6"),
	// 																																																																							Iops: to.Ptr[int32](240),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P10"),
	// 																																																																							Iops: to.Ptr[int32](500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P15"),
	// 																																																																							Iops: to.Ptr[int32](1100),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P20"),
	// 																																																																							Iops: to.Ptr[int32](2300),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P10"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](131072),
	// 																																																																					SupportedIops: to.Ptr[int32](500),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P10"),
	// 																																																																							Iops: to.Ptr[int32](500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P15"),
	// 																																																																							Iops: to.Ptr[int32](1100),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P20"),
	// 																																																																							Iops: to.Ptr[int32](2300),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P15"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](262144),
	// 																																																																					SupportedIops: to.Ptr[int32](1100),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P15"),
	// 																																																																							Iops: to.Ptr[int32](1100),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P20"),
	// 																																																																							Iops: to.Ptr[int32](2300),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P20"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](524288),
	// 																																																																					SupportedIops: to.Ptr[int32](2300),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P20"),
	// 																																																																							Iops: to.Ptr[int32](2300),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P30"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](1048576),
	// 																																																																					SupportedIops: to.Ptr[int32](5000),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P40"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](2097152),
	// 																																																																					SupportedIops: to.Ptr[int32](7500),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P50"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](4194304),
	// 																																																																					SupportedIops: to.Ptr[int32](7500),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P60"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](8388608),
	// 																																																																					SupportedIops: to.Ptr[int32](16000),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P60"),
	// 																																																																							Iops: to.Ptr[int32](16000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P70"),
	// 																																																																							Iops: to.Ptr[int32](18000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P80"),
	// 																																																																							Iops: to.Ptr[int32](20000),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P70"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](16777216),
	// 																																																																					SupportedIops: to.Ptr[int32](18000),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P70"),
	// 																																																																							Iops: to.Ptr[int32](18000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P80"),
	// 																																																																							Iops: to.Ptr[int32](20000),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P80"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](33553408),
	// 																																																																					SupportedIops: to.Ptr[int32](20000),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P80"),
	// 																																																																							Iops: to.Ptr[int32](20000),
	// 																																																																					}},
	// 																																																																			}},
	// 																																																																		},
	// 																																																																		{
	// 																																																																			Name: to.Ptr("ManagedDiskV2"),
	// 																																																																			DefaultStorageSizeMb: to.Ptr[int64](65536),
	// 																																																																			SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("None"),
	// 																																																																					MaximumStorageSizeMb: to.Ptr[int64](67108864),
	// 																																																																					StorageSizeMb: to.Ptr[int64](32768),
	// 																																																																					SupportedIops: to.Ptr[int32](3000),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("None"),
	// 																																																																							Iops: to.Ptr[int32](0),
	// 																																																																					}},
	// 																																																																					SupportedMaximumIops: to.Ptr[int32](80000),
	// 																																																																					SupportedMaximumThroughput: to.Ptr[int32](750),
	// 																																																																					SupportedThroughput: to.Ptr[int32](125),
	// 																																																																			}},
	// 																																																																	}},
	// 																																																																},
	// 																																																																{
	// 																																																																	Name: to.Ptr("MemoryOptimized"),
	// 																																																																	DefaultSKUName: to.Ptr("Standard_E2ds_v4"),
	// 																																																																	SupportedServerSKUs: []*armpostgresqlflexibleservers.ServerSKUCapability{
	// 																																																																		{
	// 																																																																			Name: to.Ptr("Standard_E2s_v3"),
	// 																																																																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																				SupportedIops: to.Ptr[int32](3200),
	// 																																																																				SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																				SupportedZones: []*string{
	// 																																																																					to.Ptr("1"),
	// 																																																																					to.Ptr("2"),
	// 																																																																					to.Ptr("3")},
	// 																																																																					VCores: to.Ptr[int32](2),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Standard_E4s_v3"),
	// 																																																																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																						SupportedIops: to.Ptr[int32](6400),
	// 																																																																						SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																						SupportedZones: []*string{
	// 																																																																							to.Ptr("1"),
	// 																																																																							to.Ptr("2"),
	// 																																																																							to.Ptr("3")},
	// 																																																																							VCores: to.Ptr[int32](4),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("Standard_E8s_v3"),
	// 																																																																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																								SupportedIops: to.Ptr[int32](12800),
	// 																																																																								SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																								SupportedZones: []*string{
	// 																																																																									to.Ptr("1"),
	// 																																																																									to.Ptr("2"),
	// 																																																																									to.Ptr("3")},
	// 																																																																									VCores: to.Ptr[int32](8),
	// 																																																																								},
	// 																																																																								{
	// 																																																																									Name: to.Ptr("Standard_E16s_v3"),
	// 																																																																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																										SupportedIops: to.Ptr[int32](20000),
	// 																																																																										SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																										SupportedZones: []*string{
	// 																																																																											to.Ptr("1"),
	// 																																																																											to.Ptr("2"),
	// 																																																																											to.Ptr("3")},
	// 																																																																											VCores: to.Ptr[int32](16),
	// 																																																																										},
	// 																																																																										{
	// 																																																																											Name: to.Ptr("Standard_E32s_v3"),
	// 																																																																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																												SupportedIops: to.Ptr[int32](20000),
	// 																																																																												SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																												SupportedZones: []*string{
	// 																																																																													to.Ptr("1"),
	// 																																																																													to.Ptr("2"),
	// 																																																																													to.Ptr("3")},
	// 																																																																													VCores: to.Ptr[int32](32),
	// 																																																																												},
	// 																																																																												{
	// 																																																																													Name: to.Ptr("Standard_E48s_v3"),
	// 																																																																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																														SupportedIops: to.Ptr[int32](20000),
	// 																																																																														SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																														SupportedZones: []*string{
	// 																																																																															to.Ptr("1"),
	// 																																																																															to.Ptr("2"),
	// 																																																																															to.Ptr("3")},
	// 																																																																															VCores: to.Ptr[int32](48),
	// 																																																																														},
	// 																																																																														{
	// 																																																																															Name: to.Ptr("Standard_E64s_v3"),
	// 																																																																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																SupportedIops: to.Ptr[int32](20000),
	// 																																																																																SupportedMemoryPerVcoreMb: to.Ptr[int64](6912),
	// 																																																																																SupportedZones: []*string{
	// 																																																																																	to.Ptr("1"),
	// 																																																																																	to.Ptr("2"),
	// 																																																																																	to.Ptr("3")},
	// 																																																																																	VCores: to.Ptr[int32](64),
	// 																																																																																},
	// 																																																																																{
	// 																																																																																	Name: to.Ptr("Standard_E2ds_v4"),
	// 																																																																																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																		SupportedIops: to.Ptr[int32](3200),
	// 																																																																																		SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																		SupportedZones: []*string{
	// 																																																																																			to.Ptr("1"),
	// 																																																																																			to.Ptr("2"),
	// 																																																																																			to.Ptr("3")},
	// 																																																																																			VCores: to.Ptr[int32](2),
	// 																																																																																		},
	// 																																																																																		{
	// 																																																																																			Name: to.Ptr("Standard_E4ds_v4"),
	// 																																																																																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																				SupportedIops: to.Ptr[int32](6400),
	// 																																																																																				SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																				SupportedZones: []*string{
	// 																																																																																					to.Ptr("1"),
	// 																																																																																					to.Ptr("2"),
	// 																																																																																					to.Ptr("3")},
	// 																																																																																					VCores: to.Ptr[int32](4),
	// 																																																																																				},
	// 																																																																																				{
	// 																																																																																					Name: to.Ptr("Standard_E8ds_v4"),
	// 																																																																																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																						SupportedIops: to.Ptr[int32](12800),
	// 																																																																																						SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																						SupportedZones: []*string{
	// 																																																																																							to.Ptr("1"),
	// 																																																																																							to.Ptr("2"),
	// 																																																																																							to.Ptr("3")},
	// 																																																																																							VCores: to.Ptr[int32](8),
	// 																																																																																						},
	// 																																																																																						{
	// 																																																																																							Name: to.Ptr("Standard_E16ds_v4"),
	// 																																																																																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																								SupportedIops: to.Ptr[int32](20000),
	// 																																																																																								SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																								SupportedZones: []*string{
	// 																																																																																									to.Ptr("1"),
	// 																																																																																									to.Ptr("2"),
	// 																																																																																									to.Ptr("3")},
	// 																																																																																									VCores: to.Ptr[int32](16),
	// 																																																																																								},
	// 																																																																																								{
	// 																																																																																									Name: to.Ptr("Standard_E20ds_v4"),
	// 																																																																																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																										SupportedIops: to.Ptr[int32](20000),
	// 																																																																																										SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																										SupportedZones: []*string{
	// 																																																																																											to.Ptr("1"),
	// 																																																																																											to.Ptr("2"),
	// 																																																																																											to.Ptr("3")},
	// 																																																																																											VCores: to.Ptr[int32](20),
	// 																																																																																										},
	// 																																																																																										{
	// 																																																																																											Name: to.Ptr("Standard_E32ds_v4"),
	// 																																																																																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																												SupportedIops: to.Ptr[int32](20000),
	// 																																																																																												SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																												SupportedZones: []*string{
	// 																																																																																													to.Ptr("1"),
	// 																																																																																													to.Ptr("2"),
	// 																																																																																													to.Ptr("3")},
	// 																																																																																													VCores: to.Ptr[int32](32),
	// 																																																																																												},
	// 																																																																																												{
	// 																																																																																													Name: to.Ptr("Standard_E48ds_v4"),
	// 																																																																																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																														SupportedIops: to.Ptr[int32](20000),
	// 																																																																																														SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																														SupportedZones: []*string{
	// 																																																																																															to.Ptr("1"),
	// 																																																																																															to.Ptr("2"),
	// 																																																																																															to.Ptr("3")},
	// 																																																																																															VCores: to.Ptr[int32](48),
	// 																																																																																														},
	// 																																																																																														{
	// 																																																																																															Name: to.Ptr("Standard_E64ds_v4"),
	// 																																																																																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																SupportedMemoryPerVcoreMb: to.Ptr[int64](6912),
	// 																																																																																																SupportedZones: []*string{
	// 																																																																																																	to.Ptr("1"),
	// 																																																																																																	to.Ptr("2"),
	// 																																																																																																	to.Ptr("3")},
	// 																																																																																																	VCores: to.Ptr[int32](64),
	// 																																																																																																},
	// 																																																																																																{
	// 																																																																																																	Name: to.Ptr("Standard_E2ads_v5"),
	// 																																																																																																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																		SupportedIops: to.Ptr[int32](3200),
	// 																																																																																																		SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																		SupportedZones: []*string{
	// 																																																																																																			to.Ptr("1"),
	// 																																																																																																			to.Ptr("2"),
	// 																																																																																																			to.Ptr("3")},
	// 																																																																																																			VCores: to.Ptr[int32](2),
	// 																																																																																																		},
	// 																																																																																																		{
	// 																																																																																																			Name: to.Ptr("Standard_E4ads_v5"),
	// 																																																																																																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																				SupportedIops: to.Ptr[int32](6400),
	// 																																																																																																				SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																				SupportedZones: []*string{
	// 																																																																																																					to.Ptr("1"),
	// 																																																																																																					to.Ptr("2"),
	// 																																																																																																					to.Ptr("3")},
	// 																																																																																																					VCores: to.Ptr[int32](4),
	// 																																																																																																				},
	// 																																																																																																				{
	// 																																																																																																					Name: to.Ptr("Standard_E8ads_v5"),
	// 																																																																																																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																						SupportedIops: to.Ptr[int32](12800),
	// 																																																																																																						SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																						SupportedZones: []*string{
	// 																																																																																																							to.Ptr("1"),
	// 																																																																																																							to.Ptr("2"),
	// 																																																																																																							to.Ptr("3")},
	// 																																																																																																							VCores: to.Ptr[int32](8),
	// 																																																																																																						},
	// 																																																																																																						{
	// 																																																																																																							Name: to.Ptr("Standard_E16ads_v5"),
	// 																																																																																																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																								SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																								SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																								SupportedZones: []*string{
	// 																																																																																																									to.Ptr("1"),
	// 																																																																																																									to.Ptr("2"),
	// 																																																																																																									to.Ptr("3")},
	// 																																																																																																									VCores: to.Ptr[int32](16),
	// 																																																																																																								},
	// 																																																																																																								{
	// 																																																																																																									Name: to.Ptr("Standard_E32ads_v5"),
	// 																																																																																																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																										SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																										SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																										SupportedZones: []*string{
	// 																																																																																																											to.Ptr("1"),
	// 																																																																																																											to.Ptr("2"),
	// 																																																																																																											to.Ptr("3")},
	// 																																																																																																											VCores: to.Ptr[int32](32),
	// 																																																																																																										},
	// 																																																																																																										{
	// 																																																																																																											Name: to.Ptr("Standard_E48ads_v5"),
	// 																																																																																																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																												SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																												SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																												SupportedZones: []*string{
	// 																																																																																																													to.Ptr("1"),
	// 																																																																																																													to.Ptr("2"),
	// 																																																																																																													to.Ptr("3")},
	// 																																																																																																													VCores: to.Ptr[int32](48),
	// 																																																																																																												},
	// 																																																																																																												{
	// 																																																																																																													Name: to.Ptr("Standard_E64ads_v5"),
	// 																																																																																																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																														SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																														SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																														SupportedZones: []*string{
	// 																																																																																																															to.Ptr("1"),
	// 																																																																																																															to.Ptr("2"),
	// 																																																																																																															to.Ptr("3")},
	// 																																																																																																															VCores: to.Ptr[int32](64),
	// 																																																																																																														},
	// 																																																																																																														{
	// 																																																																																																															Name: to.Ptr("Standard_E96ads_v5"),
	// 																																																																																																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																																SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																																SupportedMemoryPerVcoreMb: to.Ptr[int64](7168),
	// 																																																																																																																SupportedZones: []*string{
	// 																																																																																																																	to.Ptr("1"),
	// 																																																																																																																	to.Ptr("2"),
	// 																																																																																																																	to.Ptr("3")},
	// 																																																																																																																	VCores: to.Ptr[int32](96),
	// 																																																																																																															}},
	// 																																																																																																															SupportedStorageEditions: []*armpostgresqlflexibleservers.StorageEditionCapability{
	// 																																																																																																																{
	// 																																																																																																																	Name: to.Ptr("ManagedDisk"),
	// 																																																																																																																	DefaultStorageSizeMb: to.Ptr[int64](131072),
	// 																																																																																																																	SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P4"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](32768),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](120),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P4"),
	// 																																																																																																																					Iops: to.Ptr[int32](120),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P6"),
	// 																																																																																																																					Iops: to.Ptr[int32](240),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P10"),
	// 																																																																																																																					Iops: to.Ptr[int32](500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P15"),
	// 																																																																																																																					Iops: to.Ptr[int32](1100),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P20"),
	// 																																																																																																																					Iops: to.Ptr[int32](2300),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P6"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](65536),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](240),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P6"),
	// 																																																																																																																					Iops: to.Ptr[int32](240),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P10"),
	// 																																																																																																																					Iops: to.Ptr[int32](500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P15"),
	// 																																																																																																																					Iops: to.Ptr[int32](1100),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P20"),
	// 																																																																																																																					Iops: to.Ptr[int32](2300),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P10"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](131072),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](500),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P10"),
	// 																																																																																																																					Iops: to.Ptr[int32](500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P15"),
	// 																																																																																																																					Iops: to.Ptr[int32](1100),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P20"),
	// 																																																																																																																					Iops: to.Ptr[int32](2300),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P15"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](262144),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](1100),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P15"),
	// 																																																																																																																					Iops: to.Ptr[int32](1100),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P20"),
	// 																																																																																																																					Iops: to.Ptr[int32](2300),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P20"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](524288),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](2300),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P20"),
	// 																																																																																																																					Iops: to.Ptr[int32](2300),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P30"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](1048576),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](5000),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P40"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](2097152),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](7500),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P50"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](4194304),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](7500),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P60"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](8388608),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](16000),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P60"),
	// 																																																																																																																					Iops: to.Ptr[int32](16000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P70"),
	// 																																																																																																																					Iops: to.Ptr[int32](18000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P80"),
	// 																																																																																																																					Iops: to.Ptr[int32](20000),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P70"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](16777216),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](18000),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P70"),
	// 																																																																																																																					Iops: to.Ptr[int32](18000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P80"),
	// 																																																																																																																					Iops: to.Ptr[int32](20000),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P80"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](33553408),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P80"),
	// 																																																																																																																					Iops: to.Ptr[int32](20000),
	// 																																																																																																																			}},
	// 																																																																																																																	}},
	// 																																																																																																																},
	// 																																																																																																																{
	// 																																																																																																																	Name: to.Ptr("ManagedDiskV2"),
	// 																																																																																																																	DefaultStorageSizeMb: to.Ptr[int64](65536),
	// 																																																																																																																	SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("None"),
	// 																																																																																																																			MaximumStorageSizeMb: to.Ptr[int64](67108864),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](32768),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](3000),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("None"),
	// 																																																																																																																					Iops: to.Ptr[int32](0),
	// 																																																																																																																			}},
	// 																																																																																																																			SupportedMaximumIops: to.Ptr[int32](80000),
	// 																																																																																																																			SupportedMaximumThroughput: to.Ptr[int32](750),
	// 																																																																																																																			SupportedThroughput: to.Ptr[int32](125),
	// 																																																																																																																	}},
	// 																																																																																																															}},
	// 																																																																																																													}},
	// 																																																																																																													SupportedServerVersions: []*armpostgresqlflexibleservers.ServerVersionCapability{
	// 																																																																																																														{
	// 																																																																																																															Name: to.Ptr("11"),
	// 																																																																																																															SupportedVersionsToUpgrade: []*string{
	// 																																																																																																																to.Ptr("12"),
	// 																																																																																																																to.Ptr("13"),
	// 																																																																																																																to.Ptr("14"),
	// 																																																																																																																to.Ptr("15")},
	// 																																																																																																															},
	// 																																																																																																															{
	// 																																																																																																																Name: to.Ptr("12"),
	// 																																																																																																																SupportedVersionsToUpgrade: []*string{
	// 																																																																																																																	to.Ptr("13"),
	// 																																																																																																																	to.Ptr("14"),
	// 																																																																																																																	to.Ptr("15")},
	// 																																																																																																																},
	// 																																																																																																																{
	// 																																																																																																																	Name: to.Ptr("13"),
	// 																																																																																																																	SupportedVersionsToUpgrade: []*string{
	// 																																																																																																																		to.Ptr("14"),
	// 																																																																																																																		to.Ptr("15")},
	// 																																																																																																																	},
	// 																																																																																																																	{
	// 																																																																																																																		Name: to.Ptr("14"),
	// 																																																																																																																		SupportedVersionsToUpgrade: []*string{
	// 																																																																																																																			to.Ptr("15")},
	// 																																																																																																																	}},
	// 																																																																																																																	ZoneRedundantHaAndGeoBackupSupported: to.Ptr(armpostgresqlflexibleservers.ZoneRedundantHaAndGeoBackupSupportedEnumEnabled),
	// 																																																																																																																	ZoneRedundantHaSupported: to.Ptr(armpostgresqlflexibleservers.ZoneRedundantHaSupportedEnumEnabled),
	// 																																																																																																															}},
	// 																																																																																																														}
}

Output:

type LocationBasedCapabilitiesClientExecuteOptions 

type LocationBasedCapabilitiesClientExecuteOptions struct {
}

LocationBasedCapabilitiesClientExecuteOptions contains the optional parameters for the LocationBasedCapabilitiesClient.NewExecutePager method.

type LocationBasedCapabilitiesClientExecuteResponse 

type LocationBasedCapabilitiesClientExecuteResponse struct {
	// Capability for the PostgreSQL server
	CapabilitiesListResult
}

LocationBasedCapabilitiesClientExecuteResponse contains the response from method LocationBasedCapabilitiesClient.NewExecutePager.

type LogFile 

type LogFile struct {
	// The properties of a logFile.
	Properties *LogFileProperties

	// 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
}

LogFile - Represents a logFile.

func (LogFile) MarshalJSON 

func (l LogFile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LogFile.

func (*LogFile) UnmarshalJSON 

func (l *LogFile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LogFile.

type LogFileListResult 

type LogFileListResult struct {
	// The link used to get the next page of operations.
	NextLink *string

	// The list of logFiles in a server
	Value []*LogFile
}

LogFileListResult - A List of logFiles.

func (LogFileListResult) MarshalJSON 

func (l LogFileListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LogFileListResult.

func (*LogFileListResult) UnmarshalJSON 

func (l *LogFileListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LogFileListResult.

type LogFileProperties 

type LogFileProperties struct {
	// Creation timestamp of the log file.
	CreatedTime *time.Time

	// Last modified timestamp of the log file.
	LastModifiedTime *time.Time

	// The size in kb of the logFile.
	SizeInKb *int64

	// Type of the log file.
	Type *string

	// The url to download the log file from.
	URL *string
}

LogFileProperties - The properties of a logFile.

func (LogFileProperties) MarshalJSON 

func (l LogFileProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LogFileProperties.

func (*LogFileProperties) UnmarshalJSON 

func (l *LogFileProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LogFileProperties.

type LogFilesClient 

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

LogFilesClient contains the methods for the LogFiles group. Don't use this type directly, use NewLogFilesClient() instead.

func NewLogFilesClient 

func NewLogFilesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*LogFilesClient, error)

NewLogFilesClient creates a new instance of LogFilesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*LogFilesClient) NewListByServerPager 

func (client *LogFilesClient) NewListByServerPager(resourceGroupName string, serverName string, options *LogFilesClientListByServerOptions) *runtime.Pager[LogFilesClientListByServerResponse]

NewListByServerPager - List all the server log files in a given server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - LogFilesClientListByServerOptions contains the optional parameters for the LogFilesClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/LogFilesListByServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewLogFilesClient().NewListByServerPager("testrg", "postgresqltestsvc1", 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.LogFileListResult = armpostgresqlflexibleservers.LogFileListResult{
	// 	Value: []*armpostgresqlflexibleservers.LogFile{
	// 		{
	// 			Name: to.Ptr("postgresql-slow-postgresqltestsvc1-2018022823.log"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/logFiles"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/postgresqltestsvc1/logFiles/postgresql-slow-postgresqltestsvc1-2018022823.log"),
	// 			Properties: &armpostgresqlflexibleservers.LogFileProperties{
	// 				Type: to.Ptr("slowlog"),
	// 				CreatedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "1-01-01T00:00:00.000Z"); return t}()),
	// 				LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-03-01T06:09:20.000Z"); return t}()),
	// 				SizeInKb: to.Ptr[int64](1),
	// 				URL: to.Ptr("https://wasd2prodwus1afse42.file.core.windows.net/833c99b2f36c47349e5554b903fe0440/serverlogs/postgresql-slow-postgresqltestsvc1-2018022823.log?sv=2015-04-05&sr=f&se=2018-03-01T07%3A12%3A13Z&sp=r"),
	// 			},
	// 	}},
	// }
}

Output:

type LogFilesClientListByServerOptions 

type LogFilesClientListByServerOptions struct {
}

LogFilesClientListByServerOptions contains the optional parameters for the LogFilesClient.NewListByServerPager method.

type LogFilesClientListByServerResponse 

type LogFilesClientListByServerResponse struct {
	// A List of logFiles.
	LogFileListResult
}

LogFilesClientListByServerResponse contains the response from method LogFilesClient.NewListByServerPager.

type LogicalReplicationOnSourceDbEnum 

type LogicalReplicationOnSourceDbEnum string

LogicalReplicationOnSourceDbEnum - Indicates whether to setup LogicalReplicationOnSourceDb, if needed 

const (
	LogicalReplicationOnSourceDbEnumFalse LogicalReplicationOnSourceDbEnum = "False"
	LogicalReplicationOnSourceDbEnumTrue  LogicalReplicationOnSourceDbEnum = "True"
)

func PossibleLogicalReplicationOnSourceDbEnumValues 

func PossibleLogicalReplicationOnSourceDbEnumValues() []LogicalReplicationOnSourceDbEnum

PossibleLogicalReplicationOnSourceDbEnumValues returns the possible values for the LogicalReplicationOnSourceDbEnum const type.

type LtrBackupOperationResponseProperties 

type LtrBackupOperationResponseProperties struct {
	// REQUIRED; Start time of the operation.
	StartTime *time.Time

	// REQUIRED; Service-set extensible enum indicating the status of operation
	Status *ExecutionStatus

	// Metadata to be stored in RP. Store everything that will be required to perform a successful restore using this Recovery
	// point. e.g. Versions, DataFormat etc
	BackupMetadata *string

	// Name of Backup operation
	BackupName *string

	// Data transferred in bytes
	DataTransferredInBytes *int64

	// Size of datasource in bytes
	DatasourceSizeInBytes *int64

	// End time of the operation.
	EndTime *time.Time

	// PercentageCompleted
	PercentComplete *float64

	// READ-ONLY; The error code.
	ErrorCode *string

	// READ-ONLY; The error message.
	ErrorMessage *string
}

LtrBackupOperationResponseProperties - Response for the backup request.

func (LtrBackupOperationResponseProperties) MarshalJSON 

func (l LtrBackupOperationResponseProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LtrBackupOperationResponseProperties.

func (*LtrBackupOperationResponseProperties) UnmarshalJSON 

func (l *LtrBackupOperationResponseProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LtrBackupOperationResponseProperties.

type LtrBackupOperationsClient 

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

LtrBackupOperationsClient contains the methods for the LtrBackupOperations group. Don't use this type directly, use NewLtrBackupOperationsClient() instead.

func NewLtrBackupOperationsClient 

func NewLtrBackupOperationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*LtrBackupOperationsClient, error)

NewLtrBackupOperationsClient creates a new instance of LtrBackupOperationsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*LtrBackupOperationsClient) Get 

func (client *LtrBackupOperationsClient) Get(ctx context.Context, resourceGroupName string, serverName string, backupName string, options *LtrBackupOperationsClientGetOptions) (LtrBackupOperationsClientGetResponse, error)

Get - Gets the result of the give long term retention backup operation for the flexible server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • backupName - The name of the backup.
  • options - LtrBackupOperationsClientGetOptions contains the optional parameters for the LtrBackupOperationsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/LongTermRetentionOperationGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLtrBackupOperationsClient().Get(ctx, "rgLongTermRetention", "pgsqlltrtestserver", "backup1", 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.LtrServerBackupOperation = armpostgresqlflexibleservers.LtrServerBackupOperation{
// 	Name: to.Ptr("backup1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/ltrbackupOperations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/rgLongTermRetention/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgsqlltrtestserver"),
// 	Properties: &armpostgresqlflexibleservers.LtrBackupOperationResponseProperties{
// 		BackupMetadata: to.Ptr("backupMetadata"),
// 		BackupName: to.Ptr("backup1"),
// 		DataTransferredInBytes: to.Ptr[int64](9),
// 		DatasourceSizeInBytes: to.Ptr[int64](21),
// 		EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-13T01:32:30.128Z"); return t}()),
// 		PercentComplete: to.Ptr[float64](4),
// 		StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-13T01:32:30.128Z"); return t}()),
// 		Status: to.Ptr(armpostgresqlflexibleservers.ExecutionStatusRunning),
// 	},
// }

Output:

func (*LtrBackupOperationsClient) NewListByServerPager 

func (client *LtrBackupOperationsClient) NewListByServerPager(resourceGroupName string, serverName string, options *LtrBackupOperationsClientListByServerOptions) *runtime.Pager[LtrBackupOperationsClientListByServerResponse]

NewListByServerPager - Gets the result of the give long term retention backup operations for the flexible server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - LtrBackupOperationsClientListByServerOptions contains the optional parameters for the LtrBackupOperationsClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/LongTermRetentionOperationListByServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewLtrBackupOperationsClient().NewListByServerPager("rgLongTermRetention", "pgsqlltrtestserver", 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.LtrServerBackupOperationList = armpostgresqlflexibleservers.LtrServerBackupOperationList{
	// 	Value: []*armpostgresqlflexibleservers.LtrServerBackupOperation{
	// 		{
	// 			Name: to.Ptr("backup1"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/ltrbackupOperations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/rgLongTermRetention/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgsqlltrtestserver"),
	// 			Properties: &armpostgresqlflexibleservers.LtrBackupOperationResponseProperties{
	// 				BackupMetadata: to.Ptr("backupMetadata"),
	// 				BackupName: to.Ptr("backup1"),
	// 				DataTransferredInBytes: to.Ptr[int64](9),
	// 				DatasourceSizeInBytes: to.Ptr[int64](21),
	// 				EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-13T01:32:30.128Z"); return t}()),
	// 				PercentComplete: to.Ptr[float64](4),
	// 				StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-13T01:32:30.128Z"); return t}()),
	// 				Status: to.Ptr(armpostgresqlflexibleservers.ExecutionStatusRunning),
	// 			},
	// 	}},
	// }
}

Output:

type LtrBackupOperationsClientGetOptions 

type LtrBackupOperationsClientGetOptions struct {
}

LtrBackupOperationsClientGetOptions contains the optional parameters for the LtrBackupOperationsClient.Get method.

type LtrBackupOperationsClientGetResponse 

type LtrBackupOperationsClientGetResponse struct {
	// Response for the LTR backup Operation API call
	LtrServerBackupOperation
}

LtrBackupOperationsClientGetResponse contains the response from method LtrBackupOperationsClient.Get.

type LtrBackupOperationsClientListByServerOptions 

type LtrBackupOperationsClientListByServerOptions struct {
}

LtrBackupOperationsClientListByServerOptions contains the optional parameters for the LtrBackupOperationsClient.NewListByServerPager method.

type LtrBackupOperationsClientListByServerResponse 

type LtrBackupOperationsClientListByServerResponse struct {
	// A list of long term retention backup operations for server.
	LtrServerBackupOperationList
}

LtrBackupOperationsClientListByServerResponse contains the response from method LtrBackupOperationsClient.NewListByServerPager.

type LtrBackupRequest 

type LtrBackupRequest struct {
	// REQUIRED; Backup Settings
	BackupSettings *BackupSettings

	// REQUIRED; Backup store detail for target server
	TargetDetails *BackupStoreDetails
}

LtrBackupRequest - The request that is made for a long term retention backup.

func (LtrBackupRequest) MarshalJSON 

func (l LtrBackupRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LtrBackupRequest.

func (*LtrBackupRequest) UnmarshalJSON 

func (l *LtrBackupRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LtrBackupRequest.

type LtrBackupResponse 

type LtrBackupResponse struct {
	// Long Term Retention Backup Operation Resource Properties
	Properties *LtrBackupOperationResponseProperties
}

LtrBackupResponse - Response for the LTR backup API call

func (LtrBackupResponse) MarshalJSON 

func (l LtrBackupResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LtrBackupResponse.

func (*LtrBackupResponse) UnmarshalJSON 

func (l *LtrBackupResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LtrBackupResponse.

type LtrPreBackupRequest 

type LtrPreBackupRequest struct {
	// REQUIRED; Backup Settings
	BackupSettings *BackupSettings
}

LtrPreBackupRequest - A request that is made for pre-backup.

func (LtrPreBackupRequest) MarshalJSON 

func (l LtrPreBackupRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LtrPreBackupRequest.

func (*LtrPreBackupRequest) UnmarshalJSON 

func (l *LtrPreBackupRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LtrPreBackupRequest.

type LtrPreBackupResponse 

type LtrPreBackupResponse struct {
	// REQUIRED; Additional Properties for the pre backup response
	Properties *LtrPreBackupResponseProperties
}

LtrPreBackupResponse - Response for the LTR pre-backup API call

func (LtrPreBackupResponse) MarshalJSON 

func (l LtrPreBackupResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LtrPreBackupResponse.

func (*LtrPreBackupResponse) UnmarshalJSON 

func (l *LtrPreBackupResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LtrPreBackupResponse.

type LtrPreBackupResponseProperties 

type LtrPreBackupResponseProperties struct {
	// REQUIRED; Number of storage containers the plugin will use during backup. More than one containers may be used for size
	// limitations, parallelism, or redundancy etc.
	NumberOfContainers *int32
}

LtrPreBackupResponseProperties - Response for the pre-backup request.

func (LtrPreBackupResponseProperties) MarshalJSON 

func (l LtrPreBackupResponseProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LtrPreBackupResponseProperties.

func (*LtrPreBackupResponseProperties) UnmarshalJSON 

func (l *LtrPreBackupResponseProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LtrPreBackupResponseProperties.

type LtrServerBackupOperation 

type LtrServerBackupOperation struct {
	// Long Term Retention Backup Operation Resource Properties
	Properties *LtrBackupOperationResponseProperties

	// 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
}

LtrServerBackupOperation - Response for the LTR backup Operation API call

func (LtrServerBackupOperation) MarshalJSON 

func (l LtrServerBackupOperation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LtrServerBackupOperation.

func (*LtrServerBackupOperation) UnmarshalJSON 

func (l *LtrServerBackupOperation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LtrServerBackupOperation.

type LtrServerBackupOperationList 

type LtrServerBackupOperationList struct {
	// The link used to get the next page of operations.
	NextLink *string

	// The list of long term retention server backup operations
	Value []*LtrServerBackupOperation
}

LtrServerBackupOperationList - A list of long term retention backup operations for server.

func (LtrServerBackupOperationList) MarshalJSON 

func (l LtrServerBackupOperationList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LtrServerBackupOperationList.

func (*LtrServerBackupOperationList) UnmarshalJSON 

func (l *LtrServerBackupOperationList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LtrServerBackupOperationList.

type MaintenanceWindow 

type MaintenanceWindow struct {
	// indicates whether custom window is enabled or disabled
	CustomWindow *string

	// day of week for maintenance window
	DayOfWeek *int32

	// start hour for maintenance window
	StartHour *int32

	// start minute for maintenance window
	StartMinute *int32
}

MaintenanceWindow - Maintenance window properties of a server.

func (MaintenanceWindow) MarshalJSON 

func (m MaintenanceWindow) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceWindow.

func (*MaintenanceWindow) UnmarshalJSON 

func (m *MaintenanceWindow) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceWindow.

type MigrateRolesEnum 

type MigrateRolesEnum string

MigrateRolesEnum - To migrate roles and permissions we need to send this flag as True 

const (
	MigrateRolesEnumFalse MigrateRolesEnum = "False"
	MigrateRolesEnumTrue  MigrateRolesEnum = "True"
)

func PossibleMigrateRolesEnumValues 

func PossibleMigrateRolesEnumValues() []MigrateRolesEnum

PossibleMigrateRolesEnumValues returns the possible values for the MigrateRolesEnum const type.

type MigrationDbState 

type MigrationDbState string

MigrationDbState - Migration db state of an individual database 

const (
	MigrationDbStateCanceled                 MigrationDbState = "Canceled"
	MigrationDbStateCanceling                MigrationDbState = "Canceling"
	MigrationDbStateFailed                   MigrationDbState = "Failed"
	MigrationDbStateInProgress               MigrationDbState = "InProgress"
	MigrationDbStateSucceeded                MigrationDbState = "Succeeded"
	MigrationDbStateWaitingForCutoverTrigger MigrationDbState = "WaitingForCutoverTrigger"
)

func PossibleMigrationDbStateValues 

func PossibleMigrationDbStateValues() []MigrationDbState

PossibleMigrationDbStateValues returns the possible values for the MigrationDbState const type.

type MigrationListFilter 

type MigrationListFilter string
const (
	MigrationListFilterActive MigrationListFilter = "Active"
	MigrationListFilterAll    MigrationListFilter = "All"
)

func PossibleMigrationListFilterValues 

func PossibleMigrationListFilterValues() []MigrationListFilter

PossibleMigrationListFilterValues returns the possible values for the MigrationListFilter const type.

type MigrationMode 

type MigrationMode string

MigrationMode - There are two types of migration modes Online and Offline 

const (
	MigrationModeOffline MigrationMode = "Offline"
	MigrationModeOnline  MigrationMode = "Online"
)

func PossibleMigrationModeValues 

func PossibleMigrationModeValues() []MigrationMode

PossibleMigrationModeValues returns the possible values for the MigrationMode const type.

type MigrationNameAvailabilityReason 

type MigrationNameAvailabilityReason string

MigrationNameAvailabilityReason - Migration name availability reason. 

const (
	MigrationNameAvailabilityReasonAlreadyExists MigrationNameAvailabilityReason = "AlreadyExists"
	MigrationNameAvailabilityReasonInvalid       MigrationNameAvailabilityReason = "Invalid"
)

func PossibleMigrationNameAvailabilityReasonValues 

func PossibleMigrationNameAvailabilityReasonValues() []MigrationNameAvailabilityReason

PossibleMigrationNameAvailabilityReasonValues returns the possible values for the MigrationNameAvailabilityReason const type.

type MigrationNameAvailabilityResource 

type MigrationNameAvailabilityResource struct {
	// REQUIRED; The resource name to verify.
	Name *string

	// REQUIRED; The type of the resource.
	Type *string

	// READ-ONLY; Migration name availability message.
	Message *string

	// READ-ONLY; Indicates whether the resource name is available.
	NameAvailable *bool

	// READ-ONLY; Migration name availability reason
	Reason *MigrationNameAvailabilityReason
}

MigrationNameAvailabilityResource - Represents a migration name's availability.

func (MigrationNameAvailabilityResource) MarshalJSON 

func (m MigrationNameAvailabilityResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationNameAvailabilityResource.

func (*MigrationNameAvailabilityResource) UnmarshalJSON 

func (m *MigrationNameAvailabilityResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationNameAvailabilityResource.

type MigrationOption 

type MigrationOption string

MigrationOption - Supported types of migration request include Validate, Migrate and ValidateAndMigrate 

const (
	MigrationOptionMigrate            MigrationOption = "Migrate"
	MigrationOptionValidate           MigrationOption = "Validate"
	MigrationOptionValidateAndMigrate MigrationOption = "ValidateAndMigrate"
)

func PossibleMigrationOptionValues 

func PossibleMigrationOptionValues() []MigrationOption

PossibleMigrationOptionValues returns the possible values for the MigrationOption const type.

type MigrationResource 

type MigrationResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// Migration resource properties.
	Properties *MigrationResourceProperties

	// 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
}

MigrationResource - Represents a migration resource.

func (MigrationResource) MarshalJSON 

func (m MigrationResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationResource.

func (*MigrationResource) UnmarshalJSON 

func (m *MigrationResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationResource.

type MigrationResourceForPatch 

type MigrationResourceForPatch struct {
	// Migration resource properties.
	Properties *MigrationResourcePropertiesForPatch

	// Application-specific metadata in the form of key-value pairs.
	Tags map[string]*string
}

MigrationResourceForPatch - Represents a migration resource for patch.

func (MigrationResourceForPatch) MarshalJSON 

func (m MigrationResourceForPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationResourceForPatch.

func (*MigrationResourceForPatch) UnmarshalJSON 

func (m *MigrationResourceForPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationResourceForPatch.

type MigrationResourceListResult 

type MigrationResourceListResult struct {
	// READ-ONLY; The link used to get the next page of migrations.
	NextLink *string

	// READ-ONLY; A list of migration resources.
	Value []*MigrationResource
}

MigrationResourceListResult - A list of migration resources.

func (MigrationResourceListResult) MarshalJSON 

func (m MigrationResourceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationResourceListResult.

func (*MigrationResourceListResult) UnmarshalJSON 

func (m *MigrationResourceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationResourceListResult.

type MigrationResourceProperties 

type MigrationResourceProperties struct {
	// To trigger cancel for entire migration we need to send this flag as True
	Cancel *CancelEnum

	// When you want to trigger cancel for specific databases send cancel flag as True and database names in this array
	DbsToCancelMigrationOn []*string

	// Number of databases to migrate
	DbsToMigrate []*string

	// When you want to trigger cutover for specific databases send triggerCutover flag as True and database names in this array
	DbsToTriggerCutoverOn []*string

	// To migrate roles and permissions we need to send this flag as True
	MigrateRoles *MigrateRolesEnum

	// ResourceId of the private endpoint migration instance
	MigrationInstanceResourceID *string

	// There are two types of migration modes Online and Offline
	MigrationMode *MigrationMode

	// This indicates the supported Migration option for the migration
	MigrationOption *MigrationOption

	// End time in UTC for migration window
	MigrationWindowEndTimeInUTC *time.Time

	// Start time in UTC for migration window
	MigrationWindowStartTimeInUTC *time.Time

	// Indicates whether the databases on the target server can be overwritten, if already present. If set to False, the migration
	// workflow will wait for a confirmation, if it detects that the database
	// already exists.
	OverwriteDbsInTarget *OverwriteDbsInTargetEnum

	// SSL modes for migration. Default SSL mode for PostgreSQLSingleServer is VerifyFull and Prefer for other source types
	SSLMode *SSLMode

	// Migration secret parameters
	SecretParameters *MigrationSecretParameters

	// Indicates whether to setup LogicalReplicationOnSourceDb, if needed
	SetupLogicalReplicationOnSourceDbIfNeeded *LogicalReplicationOnSourceDbEnum

	// Source server fully qualified domain name or ip. It is a optional value, if customer provide it, dms will always use it
	// for connection
	SourceDbServerFullyQualifiedDomainName *string

	// ResourceId of the source database server in case the sourceType is PostgreSQLSingleServer. For other source types this
	// should be ipaddress:port@username or hostname:port@username
	SourceDbServerResourceID *string

	// migration source server type : OnPremises, AWS, GCP, AzureVM, PostgreSQLSingleServer, AWSRDS, AWSAURORA, AWSEC2, GCPCloudSQL,
	// GCPAlloyDB, GCPCompute, or EDB
	SourceType *SourceType

	// Indicates whether the data migration should start right away
	StartDataMigration *StartDataMigrationEnum

	// Target server fully qualified domain name or ip. It is a optional value, if customer provide it, dms will always use it
	// for connection
	TargetDbServerFullyQualifiedDomainName *string

	// To trigger cutover for entire migration we need to send this flag as True
	TriggerCutover *TriggerCutoverEnum

	// READ-ONLY; Current status of migration
	CurrentStatus *MigrationStatus

	// READ-ONLY; ID for migration, a GUID.
	MigrationID *string

	// READ-ONLY; Metadata of the source database server
	SourceDbServerMetadata *DbServerMetadata

	// READ-ONLY; Metadata of the target database server
	TargetDbServerMetadata *DbServerMetadata

	// READ-ONLY; ResourceId of the source database server
	TargetDbServerResourceID *string
}

MigrationResourceProperties - Migration resource properties.

func (MigrationResourceProperties) MarshalJSON 

func (m MigrationResourceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationResourceProperties.

func (*MigrationResourceProperties) UnmarshalJSON 

func (m *MigrationResourceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationResourceProperties.

type MigrationResourcePropertiesForPatch 

type MigrationResourcePropertiesForPatch struct {
	// To trigger cancel for entire migration we need to send this flag as True
	Cancel *CancelEnum

	// When you want to trigger cancel for specific databases send cancel flag as True and database names in this array
	DbsToCancelMigrationOn []*string

	// Number of databases to migrate
	DbsToMigrate []*string

	// When you want to trigger cutover for specific databases send triggerCutover flag as True and database names in this array
	DbsToTriggerCutoverOn []*string

	// To migrate roles and permissions we need to send this flag as True
	MigrateRoles *MigrateRolesEnum

	// There are two types of migration modes Online and Offline
	MigrationMode *MigrationMode

	// Start time in UTC for migration window
	MigrationWindowStartTimeInUTC *time.Time

	// Indicates whether the databases on the target server can be overwritten, if already present. If set to False, the migration
	// workflow will wait for a confirmation, if it detects that the database
	// already exists.
	OverwriteDbsInTarget *OverwriteDbsInTargetEnum

	// Migration secret parameters
	SecretParameters *MigrationSecretParameters

	// Indicates whether to setup LogicalReplicationOnSourceDb, if needed
	SetupLogicalReplicationOnSourceDbIfNeeded *LogicalReplicationOnSourceDbEnum

	// Source server fully qualified domain name or ip. It is a optional value, if customer provide it, dms will always use it
	// for connection
	SourceDbServerFullyQualifiedDomainName *string

	// ResourceId of the source database server
	SourceDbServerResourceID *string

	// Indicates whether the data migration should start right away
	StartDataMigration *StartDataMigrationEnum

	// Target server fully qualified domain name or ip. It is a optional value, if customer provide it, dms will always use it
	// for connection
	TargetDbServerFullyQualifiedDomainName *string

	// To trigger cutover for entire migration we need to send this flag as True
	TriggerCutover *TriggerCutoverEnum
}

MigrationResourcePropertiesForPatch - Migration resource properties for patch.

func (MigrationResourcePropertiesForPatch) MarshalJSON 

func (m MigrationResourcePropertiesForPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationResourcePropertiesForPatch.

func (*MigrationResourcePropertiesForPatch) UnmarshalJSON 

func (m *MigrationResourcePropertiesForPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationResourcePropertiesForPatch.

type MigrationSecretParameters 

type MigrationSecretParameters struct {
	// REQUIRED; Admin credentials for source and target servers
	AdminCredentials *AdminCredentials

	// Gets or sets the username for the source server. This user need not be an admin.
	SourceServerUsername *string

	// Gets or sets the username for the target server. This user need not be an admin.
	TargetServerUsername *string
}

MigrationSecretParameters - Migration secret parameters.

func (MigrationSecretParameters) MarshalJSON 

func (m MigrationSecretParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationSecretParameters.

func (*MigrationSecretParameters) UnmarshalJSON 

func (m *MigrationSecretParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationSecretParameters.

type MigrationState 

type MigrationState string

MigrationState - Migration state. 

const (
	MigrationStateCanceled             MigrationState = "Canceled"
	MigrationStateCleaningUp           MigrationState = "CleaningUp"
	MigrationStateFailed               MigrationState = "Failed"
	MigrationStateInProgress           MigrationState = "InProgress"
	MigrationStateSucceeded            MigrationState = "Succeeded"
	MigrationStateValidationFailed     MigrationState = "ValidationFailed"
	MigrationStateWaitingForUserAction MigrationState = "WaitingForUserAction"
)

func PossibleMigrationStateValues 

func PossibleMigrationStateValues() []MigrationState

PossibleMigrationStateValues returns the possible values for the MigrationState const type.

type MigrationStatus 

type MigrationStatus struct {
	// READ-ONLY; Current Migration sub state details.
	CurrentSubStateDetails *MigrationSubStateDetails

	// READ-ONLY; Error message, if any, for the migration state
	Error *string

	// READ-ONLY; State of migration
	State *MigrationState
}

MigrationStatus - Migration status.

func (MigrationStatus) MarshalJSON 

func (m MigrationStatus) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationStatus.

func (*MigrationStatus) UnmarshalJSON 

func (m *MigrationStatus) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationStatus.

type MigrationSubState 

type MigrationSubState string

MigrationSubState - Migration sub state. 

const (
	MigrationSubStateCancelingRequestedDBMigrations                     MigrationSubState = "CancelingRequestedDBMigrations"
	MigrationSubStateCompleted                                          MigrationSubState = "Completed"
	MigrationSubStateCompletingMigration                                MigrationSubState = "CompletingMigration"
	MigrationSubStateMigratingData                                      MigrationSubState = "MigratingData"
	MigrationSubStatePerformingPreRequisiteSteps                        MigrationSubState = "PerformingPreRequisiteSteps"
	MigrationSubStateValidationInProgress                               MigrationSubState = "ValidationInProgress"
	MigrationSubStateWaitingForCutoverTrigger                           MigrationSubState = "WaitingForCutoverTrigger"
	MigrationSubStateWaitingForDBsToMigrateSpecification                MigrationSubState = "WaitingForDBsToMigrateSpecification"
	MigrationSubStateWaitingForDataMigrationScheduling                  MigrationSubState = "WaitingForDataMigrationScheduling"
	MigrationSubStateWaitingForDataMigrationWindow                      MigrationSubState = "WaitingForDataMigrationWindow"
	MigrationSubStateWaitingForLogicalReplicationSetupRequestOnSourceDB MigrationSubState = "WaitingForLogicalReplicationSetupRequestOnSourceDB"
	MigrationSubStateWaitingForTargetDBOverwriteConfirmation            MigrationSubState = "WaitingForTargetDBOverwriteConfirmation"
)

func PossibleMigrationSubStateValues 

func PossibleMigrationSubStateValues() []MigrationSubState

PossibleMigrationSubStateValues returns the possible values for the MigrationSubState const type.

type MigrationSubStateDetails 

type MigrationSubStateDetails struct {
	// Dictionary of
	DbDetails map[string]*DbMigrationStatus

	// Details for the validation for migration
	ValidationDetails *ValidationDetails

	// READ-ONLY; Migration sub state.
	CurrentSubState *MigrationSubState
}

MigrationSubStateDetails - Migration sub state details.

func (MigrationSubStateDetails) MarshalJSON 

func (m MigrationSubStateDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MigrationSubStateDetails.

func (*MigrationSubStateDetails) UnmarshalJSON 

func (m *MigrationSubStateDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MigrationSubStateDetails.

type MigrationsClient 

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

MigrationsClient contains the methods for the Migrations group. Don't use this type directly, use NewMigrationsClient() instead.

func NewMigrationsClient 

func NewMigrationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*MigrationsClient, error)

NewMigrationsClient creates a new instance of MigrationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*MigrationsClient) Create 

func (client *MigrationsClient) Create(ctx context.Context, subscriptionID string, resourceGroupName string, targetDbServerName string, migrationName string, parameters MigrationResource, options *MigrationsClientCreateOptions) (MigrationsClientCreateResponse, error)

Create - Creates a new migration. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • subscriptionID - The subscription ID of the target database server.
  • resourceGroupName - The resource group name of the target database server.
  • targetDbServerName - The name of the target database server.
  • migrationName - The name of the migration.
  • parameters - The required parameters for creating a migration.
  • options - MigrationsClientCreateOptions contains the optional parameters for the MigrationsClient.Create method.
Example (CreateMigrationWithOtherSourceTypesForValidateAndMigrate)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_Create_Other_SourceTypes_Validate_Migrate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Create(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigration", armpostgresqlflexibleservers.MigrationResource{
	Location: to.Ptr("westus"),
	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
		DbsToMigrate: []*string{
			to.Ptr("db1"),
			to.Ptr("db2"),
			to.Ptr("db3"),
			to.Ptr("db4")},
		MigrationMode:        to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
		MigrationOption:      to.Ptr(armpostgresqlflexibleservers.MigrationOptionValidateAndMigrate),
		OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
		SecretParameters: &armpostgresqlflexibleservers.MigrationSecretParameters{
			AdminCredentials: &armpostgresqlflexibleservers.AdminCredentials{
				SourceServerPassword: to.Ptr("xxxxxxxx"),
				TargetServerPassword: to.Ptr("xxxxxxxx"),
			},
		},
		SourceDbServerResourceID: to.Ptr("testsource:5432@pguser"),
		SourceType:               to.Ptr(armpostgresqlflexibleservers.SourceTypeOnPremises),
		SSLMode:                  to.Ptr(armpostgresqlflexibleservers.SSLModePrefer),
	},
}, 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigration"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigration"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"key1624": to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStateValidationInProgress),
// 			},
// 			Error: to.Ptr(""),
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateInProgress),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("db1"),
// 			to.Ptr("db2"),
// 			to.Ptr("db3"),
// 			to.Ptr("db4")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("d3ceacbb-a5fd-43dc-a9db-6022b5154856"),
// 			MigrationOption: to.Ptr(armpostgresqlflexibleservers.MigrationOptionValidateAndMigrate),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-06T16:05:58.895Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumFalse),
// 			SourceDbServerResourceID: to.Ptr("testsource:5432@pguser"),
// 			SourceType: to.Ptr(armpostgresqlflexibleservers.SourceTypeOnPremises),
// 			SSLMode: to.Ptr(armpostgresqlflexibleservers.SSLModePrefer),
// 			StartDataMigration: to.Ptr(armpostgresqlflexibleservers.StartDataMigrationEnumFalse),
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumFalse),
// 		},
// 	}

Output:
Example (CreatePreMigrationValidation)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_Create_Validate_Only.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Create(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigration", armpostgresqlflexibleservers.MigrationResource{
	Location: to.Ptr("westus"),
	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
		DbsToMigrate: []*string{
			to.Ptr("db1"),
			to.Ptr("db2"),
			to.Ptr("db3"),
			to.Ptr("db4")},
		MigrationMode:        to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
		MigrationOption:      to.Ptr(armpostgresqlflexibleservers.MigrationOptionValidate),
		OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
		SecretParameters: &armpostgresqlflexibleservers.MigrationSecretParameters{
			AdminCredentials: &armpostgresqlflexibleservers.AdminCredentials{
				SourceServerPassword: to.Ptr("xxxxxxxx"),
				TargetServerPassword: to.Ptr("xxxxxxxx"),
			},
		},
		SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
	},
}, 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigration"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigration"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"key1624": to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStateValidationInProgress),
// 			},
// 			Error: to.Ptr(""),
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateInProgress),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("db1"),
// 			to.Ptr("db2"),
// 			to.Ptr("db3"),
// 			to.Ptr("db4")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("d3ceacbb-a5fd-43dc-a9db-6022b5154856"),
// 			MigrationOption: to.Ptr(armpostgresqlflexibleservers.MigrationOptionValidate),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-06T16:05:58.895Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumFalse),
// 			SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
// 			StartDataMigration: to.Ptr(armpostgresqlflexibleservers.StartDataMigrationEnumFalse),
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumFalse),
// 		},
// 	}

Output:
Example (MigrationsCreate)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_Create.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Create(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigration", armpostgresqlflexibleservers.MigrationResource{
	Location: to.Ptr("westus"),
	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
		DbsToMigrate: []*string{
			to.Ptr("db1"),
			to.Ptr("db2"),
			to.Ptr("db3"),
			to.Ptr("db4")},
		MigrationInstanceResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testsourcemigration"),
		MigrationMode:               to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
		OverwriteDbsInTarget:        to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
		SecretParameters: &armpostgresqlflexibleservers.MigrationSecretParameters{
			AdminCredentials: &armpostgresqlflexibleservers.AdminCredentials{
				SourceServerPassword: to.Ptr("xxxxxxxx"),
				TargetServerPassword: to.Ptr("xxxxxxxx"),
			},
		},
		SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
	},
}, 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigration"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigration"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"key1624": to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStatePerformingPreRequisiteSteps),
// 			},
// 			Error: to.Ptr(""),
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateInProgress),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("db1"),
// 			to.Ptr("db2"),
// 			to.Ptr("db3"),
// 			to.Ptr("db4")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("d3ceacbb-a5fd-43dc-a9db-6022b5154856"),
// 			MigrationInstanceResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testsourcemigration"),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-06T16:05:58.895Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumFalse),
// 			SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
// 			StartDataMigration: to.Ptr(armpostgresqlflexibleservers.StartDataMigrationEnumFalse),
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumFalse),
// 		},
// 	}

Output:
Example (MigrationsCreateByPassingUserNames)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_Create_With_Other_Users.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Create(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigration", armpostgresqlflexibleservers.MigrationResource{
	Location: to.Ptr("westus"),
	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
		DbsToMigrate: []*string{
			to.Ptr("db1"),
			to.Ptr("db2"),
			to.Ptr("db3"),
			to.Ptr("db4")},
		MigrationMode: to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
		SecretParameters: &armpostgresqlflexibleservers.MigrationSecretParameters{
			AdminCredentials: &armpostgresqlflexibleservers.AdminCredentials{
				SourceServerPassword: to.Ptr("xxxxxxxx"),
				TargetServerPassword: to.Ptr("xxxxxxxx"),
			},
			SourceServerUsername: to.Ptr("newadmin@testsource"),
			TargetServerUsername: to.Ptr("targetadmin"),
		},
		SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
	},
}, 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigration"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigration"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"key1624": to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStatePerformingPreRequisiteSteps),
// 			},
// 			Error: to.Ptr(""),
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateInProgress),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("db1"),
// 			to.Ptr("db2"),
// 			to.Ptr("db3"),
// 			to.Ptr("db4")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("d3ceacbb-a5fd-43dc-a9db-6022b5154856"),
// 			MigrationMode: to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-06T16:05:58.895Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumFalse),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumFalse),
// 			SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
// 			StartDataMigration: to.Ptr(armpostgresqlflexibleservers.StartDataMigrationEnumFalse),
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumFalse),
// 		},
// 	}

Output:
Example (MigrationsCreateWithPrivateEndpoint)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_Create_With_PrivateEndpoint_Servers.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Create(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigration", armpostgresqlflexibleservers.MigrationResource{
	Location: to.Ptr("westus"),
	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
		DbsToMigrate: []*string{
			to.Ptr("db1"),
			to.Ptr("db2"),
			to.Ptr("db3"),
			to.Ptr("db4")},
		MigrationInstanceResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testsourcemigration"),
		MigrationMode:               to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
		OverwriteDbsInTarget:        to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
		SecretParameters: &armpostgresqlflexibleservers.MigrationSecretParameters{
			AdminCredentials: &armpostgresqlflexibleservers.AdminCredentials{
				SourceServerPassword: to.Ptr("xxxxxxxx"),
				TargetServerPassword: to.Ptr("xxxxxxxx"),
			},
		},
		SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
	},
}, 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigration"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigration"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"key1624": to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStatePerformingPreRequisiteSteps),
// 			},
// 			Error: to.Ptr(""),
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateInProgress),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("db1"),
// 			to.Ptr("db2"),
// 			to.Ptr("db3"),
// 			to.Ptr("db4")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("d3ceacbb-a5fd-43dc-a9db-6022b5154856"),
// 			MigrationInstanceResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testsourcemigration"),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-06T16:05:58.895Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumFalse),
// 			SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
// 			StartDataMigration: to.Ptr(armpostgresqlflexibleservers.StartDataMigrationEnumFalse),
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumFalse),
// 		},
// 	}

Output:
Example (MigrationsCreateWithRoles)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_Create_With_Roles.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Create(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigration", armpostgresqlflexibleservers.MigrationResource{
	Location: to.Ptr("westus"),
	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
		DbsToMigrate: []*string{
			to.Ptr("db1"),
			to.Ptr("db2"),
			to.Ptr("db3"),
			to.Ptr("db4")},
		MigrateRoles:         to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumTrue),
		MigrationMode:        to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
		OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
		SecretParameters: &armpostgresqlflexibleservers.MigrationSecretParameters{
			AdminCredentials: &armpostgresqlflexibleservers.AdminCredentials{
				SourceServerPassword: to.Ptr("xxxxxxxx"),
				TargetServerPassword: to.Ptr("xxxxxxxx"),
			},
		},
		SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
	},
}, 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigration"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigration"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"key1624": to.Ptr("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStatePerformingPreRequisiteSteps),
// 			},
// 			Error: to.Ptr(""),
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateInProgress),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("db1"),
// 			to.Ptr("db2"),
// 			to.Ptr("db3"),
// 			to.Ptr("db4")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumTrue),
// 			MigrationID: to.Ptr("d3ceacbb-a5fd-43dc-a9db-6022b5154856"),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-06T16:05:58.895Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumFalse),
// 			SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
// 			StartDataMigration: to.Ptr(armpostgresqlflexibleservers.StartDataMigrationEnumFalse),
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumFalse),
// 		},
// 	}

Output:

func (*MigrationsClient) Delete 

func (client *MigrationsClient) Delete(ctx context.Context, subscriptionID string, resourceGroupName string, targetDbServerName string, migrationName string, options *MigrationsClientDeleteOptions) (MigrationsClientDeleteResponse, error)

Delete - Deletes a migration. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • subscriptionID - The subscription ID of the target database server.
  • resourceGroupName - The resource group name of the target database server.
  • targetDbServerName - The name of the target database server.
  • migrationName - The name of the migration.
  • options - MigrationsClientDeleteOptions contains the optional parameters for the MigrationsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
_, err = clientFactory.NewMigrationsClient().Delete(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigration", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}

Output:

func (*MigrationsClient) Get 

func (client *MigrationsClient) Get(ctx context.Context, subscriptionID string, resourceGroupName string, targetDbServerName string, migrationName string, options *MigrationsClientGetOptions) (MigrationsClientGetResponse, error)

Get - Gets details of a migration. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • subscriptionID - The subscription ID of the target database server.
  • resourceGroupName - The resource group name of the target database server.
  • targetDbServerName - The name of the target database server.
  • migrationName - The name of the migration.
  • options - MigrationsClientGetOptions contains the optional parameters for the MigrationsClient.Get method.
Example (MigrationsGet)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Get(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigration", 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigration"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigration"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStatePerformingPreRequisiteSteps),
// 			},
// 			Error: to.Ptr(""),
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateInProgress),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("db1"),
// 			to.Ptr("db2"),
// 			to.Ptr("db3"),
// 			to.Ptr("db4")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("d3ceacbb-a5fd-43dc-a9db-6022b5154856"),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-06T16:05:58.895Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumFalse),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumFalse),
// 			SourceDbServerMetadata: &armpostgresqlflexibleservers.DbServerMetadata{
// 				Location: to.Ptr("westus"),
// 				SKU: &armpostgresqlflexibleservers.ServerSKU{
// 					Name: to.Ptr("B_Gen5_2"),
// 					Tier: to.Ptr(armpostgresqlflexibleservers.SKUTier("Basic")),
// 				},
// 				StorageMb: to.Ptr[int32](1024),
// 				Version: to.Ptr("10"),
// 			},
// 			SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
// 			StartDataMigration: to.Ptr(armpostgresqlflexibleservers.StartDataMigrationEnumFalse),
// 			TargetDbServerMetadata: &armpostgresqlflexibleservers.DbServerMetadata{
// 				Location: to.Ptr("westus"),
// 				SKU: &armpostgresqlflexibleservers.ServerSKU{
// 					Name: to.Ptr("Standard_D4s_v3"),
// 					Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 				},
// 				StorageMb: to.Ptr[int32](2048),
// 				Version: to.Ptr("11"),
// 			},
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumFalse),
// 		},
// 	}

Output:
Example (MigrationsGetMigrationWithSuccessfulValidationAndMigration)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_GetMigrationWithSuccessfulValidationAndMigration.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Get(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigrationwithsuccessfulvalidationandmigration", 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigrationwithsuccessfulvalidationandmigration"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigrationwithsuccessfulvalidationandmigration"),
// 	Location: to.Ptr("eastus"),
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStateCompleted),
// 				DbDetails: map[string]*armpostgresqlflexibleservers.DbMigrationStatus{
// 					"testdb3": &armpostgresqlflexibleservers.DbMigrationStatus{
// 						AppliedChanges: to.Ptr[int32](0),
// 						CdcDeleteCounter: to.Ptr[int32](0),
// 						CdcInsertCounter: to.Ptr[int32](0),
// 						CdcUpdateCounter: to.Ptr[int32](0),
// 						DatabaseName: to.Ptr("testdb3"),
// 						EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-12T05:55:49.681Z"); return t}()),
// 						FullLoadCompletedTables: to.Ptr[int32](10),
// 						FullLoadErroredTables: to.Ptr[int32](0),
// 						FullLoadLoadingTables: to.Ptr[int32](0),
// 						FullLoadQueuedTables: to.Ptr[int32](0),
// 						IncomingChanges: to.Ptr[int32](0),
// 						Latency: to.Ptr[int32](0),
// 						MigrationState: to.Ptr(armpostgresqlflexibleservers.MigrationDbStateSucceeded),
// 						StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-12T05:55:28.995Z"); return t}()),
// 					},
// 				},
// 				ValidationDetails: &armpostgresqlflexibleservers.ValidationDetails{
// 					DbLevelValidationDetails: []*armpostgresqlflexibleservers.DbLevelValidationStatus{
// 						{
// 							DatabaseName: to.Ptr("testdb3"),
// 							EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-12T05:54:29.894Z"); return t}()),
// 							StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-12T05:54:29.553Z"); return t}()),
// 							Summary: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 								{
// 									Type: to.Ptr("SchemaValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("ExtensionsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("CollationsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 							}},
// 					}},
// 					ServerLevelValidationDetails: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 						{
// 							Type: to.Ptr("AuthenticationAndConnectivityValidation"),
// 							State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 						},
// 						{
// 							Type: to.Ptr("SourceVersionValidation"),
// 							State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 						},
// 						{
// 							Type: to.Ptr("ServerParametersValidation"),
// 							State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 					}},
// 					Status: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 					ValidationEndTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-12T05:55:00.499Z"); return t}()),
// 					ValidationStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-12T05:54:28.077Z"); return t}()),
// 				},
// 			},
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateSucceeded),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("testdb3")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("f2354e72-2828-4a19-ad20-b4cd9e2673c1"),
// 			MigrationMode: to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
// 			MigrationOption: to.Ptr(armpostgresqlflexibleservers.MigrationOptionValidateAndMigrate),
// 			MigrationWindowEndTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-12T05:57:30.736Z"); return t}()),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-12T05:54:15.999Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumTrue),
// 			SourceDbServerResourceID: to.Ptr("20.228.214.65:5432@postgres"),
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumTrue),
// 		},
// 	}

Output:
Example (MigrationsGetMigrationWithSuccessfulValidationButMigrationFailure)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_GetMigrationWithSuccessfulValidationButMigrationFailure.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Get(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigrationwithsuccessfulvalidationbutmigrationfailure", 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigrationwithsuccessfulvalidationbutmigrationfailure"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigrationwithsuccessfulvalidationbutmigrationfailure"),
// 	Location: to.Ptr("eastus2"),
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStateCompleted),
// 				DbDetails: map[string]*armpostgresqlflexibleservers.DbMigrationStatus{
// 					"testdb6": &armpostgresqlflexibleservers.DbMigrationStatus{
// 						AppliedChanges: to.Ptr[int32](0),
// 						CdcDeleteCounter: to.Ptr[int32](0),
// 						CdcInsertCounter: to.Ptr[int32](0),
// 						CdcUpdateCounter: to.Ptr[int32](0),
// 						DatabaseName: to.Ptr("testdb6"),
// 						EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-21T13:09:53.252Z"); return t}()),
// 						FullLoadCompletedTables: to.Ptr[int32](0),
// 						FullLoadErroredTables: to.Ptr[int32](0),
// 						FullLoadLoadingTables: to.Ptr[int32](0),
// 						FullLoadQueuedTables: to.Ptr[int32](0),
// 						IncomingChanges: to.Ptr[int32](0),
// 						Latency: to.Ptr[int32](0),
// 						Message: to.Ptr("Collation/Encoding not Supported Error:  User defined Collations are present in the source database. Please drop them before retrying the migration."),
// 						MigrationState: to.Ptr(armpostgresqlflexibleservers.MigrationDbStateFailed),
// 						StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-21T13:09:52.922Z"); return t}()),
// 					},
// 				},
// 				ValidationDetails: &armpostgresqlflexibleservers.ValidationDetails{
// 					DbLevelValidationDetails: []*armpostgresqlflexibleservers.DbLevelValidationStatus{
// 						{
// 							DatabaseName: to.Ptr("address_standardizer"),
// 							EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-21T13:04:24.565Z"); return t}()),
// 							StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-21T13:04:24.565Z"); return t}()),
// 							Summary: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 								{
// 									Type: to.Ptr("ExtensionsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 							}},
// 					}},
// 					ServerLevelValidationDetails: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 						{
// 							Type: to.Ptr("AuthenticationAndConnectivityValidation"),
// 							State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 					}},
// 					Status: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 					ValidationEndTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-21T13:04:24.565Z"); return t}()),
// 					ValidationStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-21T13:04:21.623Z"); return t}()),
// 				},
// 			},
// 			Error: to.Ptr("testdb6: Collation/Encoding not Supported Error:  User defined Collations are present in the source database. Please drop them before retrying the migration. "),
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateFailed),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("testdb6")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("da52db29-cfeb-4670-a1ad-683edb14c621"),
// 			MigrationMode: to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
// 			MigrationOption: to.Ptr(armpostgresqlflexibleservers.MigrationOptionValidateAndMigrate),
// 			MigrationWindowEndTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-21T13:04:24.565Z"); return t}()),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-21T13:04:24.565Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumTrue),
// 			SourceDbServerMetadata: &armpostgresqlflexibleservers.DbServerMetadata{
// 				Location: to.Ptr("eastus2"),
// 				SKU: &armpostgresqlflexibleservers.ServerSKU{
// 				},
// 				StorageMb: to.Ptr[int32](102400),
// 			},
// 			SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/source-rg/providers/Microsoft.DBforPostgreSQL/servers/testsource"),
// 			TargetDbServerMetadata: &armpostgresqlflexibleservers.DbServerMetadata{
// 				Location: to.Ptr("East US 2"),
// 				SKU: &armpostgresqlflexibleservers.ServerSKU{
// 					Name: to.Ptr("Standard_D2ds_v4"),
// 					Tier: to.Ptr(armpostgresqlflexibleservers.SKUTier("Standard_D2ds_v4")),
// 				},
// 				StorageMb: to.Ptr[int32](131072),
// 			},
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testtarget"),
// 		},
// 	}

Output:
Example (MigrationsGetMigrationWithSuccessfulValidationOnly)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_GetMigrationWithSuccessfulValidationOnly.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Get(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigrationwithsuccessfulvalidationonly", 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigrationwithsuccessfulvalidationonly"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigrationwithsuccessfulvalidationonly"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStateCompleted),
// 				DbDetails: map[string]*armpostgresqlflexibleservers.DbMigrationStatus{
// 				},
// 				ValidationDetails: &armpostgresqlflexibleservers.ValidationDetails{
// 					DbLevelValidationDetails: []*armpostgresqlflexibleservers.DbLevelValidationStatus{
// 						{
// 							DatabaseName: to.Ptr("UnknownCollationTest"),
// 							EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-16T05:29:39.248Z"); return t}()),
// 							StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-16T05:29:38.904Z"); return t}()),
// 							Summary: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 								{
// 									Type: to.Ptr("SchemaValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("ExtensionsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("CollationsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 							}},
// 					}},
// 					ServerLevelValidationDetails: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 						{
// 							Type: to.Ptr("AuthenticationAndConnectivityValidation"),
// 							State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 						},
// 						{
// 							Type: to.Ptr("SourceVersionValidation"),
// 							State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 						},
// 						{
// 							Type: to.Ptr("ServerParametersValidation"),
// 							State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 					}},
// 					Status: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 					ValidationEndTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-16T05:29:39.666Z"); return t}()),
// 					ValidationStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-16T05:29:35.634Z"); return t}()),
// 				},
// 			},
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateSucceeded),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("UnknownCollationTest")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("77840327-7be8-44b8-adc0-af0ccccfeb36"),
// 			MigrationMode: to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
// 			MigrationOption: to.Ptr(armpostgresqlflexibleservers.MigrationOptionValidate),
// 			MigrationWindowEndTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-16T05:30:05.885Z"); return t}()),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-16T05:28:58.775Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumTrue),
// 			SourceDbServerResourceID: to.Ptr("20.228.214.65:5432@postgres"),
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumTrue),
// 		},
// 	}

Output:
Example (MigrationsGetMigrationWithValidationFailures)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_GetMigrationWithValidationFailures.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Get(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigrationwithvalidationfailure", 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigrationwithvalidationfailure"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testtarget/migrations/testmigrationwithvalidationfailure"),
// 	Location: to.Ptr("East US"),
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStateCompleted),
// 				DbDetails: map[string]*armpostgresqlflexibleservers.DbMigrationStatus{
// 				},
// 				ValidationDetails: &armpostgresqlflexibleservers.ValidationDetails{
// 					DbLevelValidationDetails: []*armpostgresqlflexibleservers.DbLevelValidationStatus{
// 						{
// 							DatabaseName: to.Ptr("c.utf-8"),
// 							EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:02.810Z"); return t}()),
// 							StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:01.830Z"); return t}()),
// 							Summary: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 								{
// 									Type: to.Ptr("SchemaValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("ExtensionsValidation"),
// 									Messages: []*armpostgresqlflexibleservers.ValidationMessage{
// 										{
// 											Message: to.Ptr("Unsupported Extension. Single to Flex migration tool does not support migration of databases having postgres_fdw extension. Consider performing the migration through other migration tools such as pg_dump/pg_restore (https://aka.ms/migrate-using-pgdump-restore)"),
// 											State: to.Ptr(armpostgresqlflexibleservers.ValidationStateFailed),
// 									}},
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateFailed),
// 								},
// 								{
// 									Type: to.Ptr("CollationsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 							}},
// 						},
// 						{
// 							DatabaseName: to.Ptr("postgres"),
// 							EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:02.810Z"); return t}()),
// 							StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:01.830Z"); return t}()),
// 							Summary: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 								{
// 									Type: to.Ptr("SchemaValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("ExtensionsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("CollationsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 							}},
// 						},
// 						{
// 							DatabaseName: to.Ptr("readme_to_recover"),
// 							EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:02.810Z"); return t}()),
// 							StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:01.830Z"); return t}()),
// 							Summary: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 								{
// 									Type: to.Ptr("SchemaValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("ExtensionsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("CollationsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 							}},
// 						},
// 						{
// 							DatabaseName: to.Ptr("testdb1"),
// 							EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:02.810Z"); return t}()),
// 							StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:01.830Z"); return t}()),
// 							Summary: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 								{
// 									Type: to.Ptr("SchemaValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("ExtensionsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 							}},
// 						},
// 						{
// 							DatabaseName: to.Ptr("testdb2"),
// 							EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:02.810Z"); return t}()),
// 							StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:01.830Z"); return t}()),
// 							Summary: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 								{
// 									Type: to.Ptr("SchemaValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("ExtensionsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 							}},
// 						},
// 						{
// 							DatabaseName: to.Ptr("testSchema"),
// 							EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:02.810Z"); return t}()),
// 							StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:01.830Z"); return t}()),
// 							Summary: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 								{
// 									Type: to.Ptr("SchemaValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("ExtensionsValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 							}},
// 						},
// 						{
// 							DatabaseName: to.Ptr("UnknownCollationTest"),
// 							EndedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:02.810Z"); return t}()),
// 							StartedOn: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:01.830Z"); return t}()),
// 							Summary: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 								{
// 									Type: to.Ptr("SchemaValidation"),
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 								},
// 								{
// 									Type: to.Ptr("ExtensionsValidation"),
// 									Messages: []*armpostgresqlflexibleservers.ValidationMessage{
// 										{
// 											Message: to.Ptr("Unsupported Extension. Single to Flex migration tool does not support migration of databases having postgres_fdw extension. Consider performing the migration through other migration tools such as pg_dump/pg_restore (https://aka.ms/migrate-using-pgdump-restore)"),
// 											State: to.Ptr(armpostgresqlflexibleservers.ValidationStateFailed),
// 									}},
// 									State: to.Ptr(armpostgresqlflexibleservers.ValidationStateFailed),
// 							}},
// 					}},
// 					ServerLevelValidationDetails: []*armpostgresqlflexibleservers.ValidationSummaryItem{
// 						{
// 							Type: to.Ptr("AuthenticationAndConnectivityValidation"),
// 							State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 						},
// 						{
// 							Type: to.Ptr("SourceVersionValidation"),
// 							State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 						},
// 						{
// 							Type: to.Ptr("ServerParametersValidation"),
// 							State: to.Ptr(armpostgresqlflexibleservers.ValidationStateSucceeded),
// 					}},
// 					Status: to.Ptr(armpostgresqlflexibleservers.ValidationStateFailed),
// 					ValidationEndTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:20:33.136Z"); return t}()),
// 					ValidationStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:19:59.917Z"); return t}()),
// 				},
// 			},
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateValidationFailed),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("c.utf-8"),
// 			to.Ptr("postgres"),
// 			to.Ptr("readme_to_recover"),
// 			to.Ptr("testdb1"),
// 			to.Ptr("testdb2"),
// 			to.Ptr("testSchema"),
// 			to.Ptr("UnknownCollationTest")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("a3e2d3cc-b139-4201-9431-e4f3003140fd"),
// 			MigrationMode: to.Ptr(armpostgresqlflexibleservers.MigrationModeOffline),
// 			MigrationOption: to.Ptr(armpostgresqlflexibleservers.MigrationOptionValidate),
// 			MigrationWindowEndTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:21:00.043Z"); return t}()),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-10-17T19:19:47.448Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumTrue),
// 			SourceDbServerResourceID: to.Ptr("20.228.214.65:5432@postgres"),
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumTrue),
// 		},
// 	}

Output:

func (*MigrationsClient) NewListByTargetServerPager 

func (client *MigrationsClient) NewListByTargetServerPager(subscriptionID string, resourceGroupName string, targetDbServerName string, options *MigrationsClientListByTargetServerOptions) *runtime.Pager[MigrationsClientListByTargetServerResponse]

NewListByTargetServerPager - List all the migrations on a given target server.

Generated from API version 2023-12-01-preview

  • subscriptionID - The subscription ID of the target database server.
  • resourceGroupName - The resource group name of the target database server.
  • targetDbServerName - The name of the target database server.
  • options - MigrationsClientListByTargetServerOptions contains the optional parameters for the MigrationsClient.NewListByTargetServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_ListByTargetServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMigrationsClient().NewListByTargetServerPager("ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", &armpostgresqlflexibleservers.MigrationsClientListByTargetServerOptions{MigrationListFilter: to.Ptr(armpostgresqlflexibleservers.MigrationListFilterAll)})
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.MigrationResourceListResult = armpostgresqlflexibleservers.MigrationResourceListResult{
	// 	Value: []*armpostgresqlflexibleservers.MigrationResource{
	// 		{
	// 			Name: to.Ptr("testmigration"),
	// 			Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigration"),
	// 			Location: to.Ptr("westus"),
	// 			Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
	// 				CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
	// 					CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
	// 						CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStatePerformingPreRequisiteSteps),
	// 					},
	// 					Error: to.Ptr(""),
	// 					State: to.Ptr(armpostgresqlflexibleservers.MigrationStateInProgress),
	// 				},
	// 				DbsToMigrate: []*string{
	// 					to.Ptr("db1"),
	// 					to.Ptr("db2"),
	// 					to.Ptr("db3"),
	// 					to.Ptr("db4")},
	// 					MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
	// 					MigrationID: to.Ptr("d3ceacbb-a5fd-43dc-a9db-6022b5154856"),
	// 					MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-06T16:05:58.895Z"); return t}()),
	// 					OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumFalse),
	// 					SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumFalse),
	// 					SourceDbServerMetadata: &armpostgresqlflexibleservers.DbServerMetadata{
	// 						Location: to.Ptr("westus"),
	// 						SKU: &armpostgresqlflexibleservers.ServerSKU{
	// 							Name: to.Ptr("B_Gen5_2"),
	// 							Tier: to.Ptr(armpostgresqlflexibleservers.SKUTier("Basic")),
	// 						},
	// 						StorageMb: to.Ptr[int32](1024),
	// 						Version: to.Ptr("10"),
	// 					},
	// 					SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
	// 					StartDataMigration: to.Ptr(armpostgresqlflexibleservers.StartDataMigrationEnumFalse),
	// 					TargetDbServerMetadata: &armpostgresqlflexibleservers.DbServerMetadata{
	// 						Location: to.Ptr("westus"),
	// 						SKU: &armpostgresqlflexibleservers.ServerSKU{
	// 							Name: to.Ptr("Standard_D4s_v3"),
	// 							Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	// 						},
	// 						StorageMb: to.Ptr[int32](2048),
	// 						Version: to.Ptr("11"),
	// 					},
	// 					TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
	// 					TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumFalse),
	// 				},
	// 		}},
	// 	}
}

Output:

func (*MigrationsClient) Update 

func (client *MigrationsClient) Update(ctx context.Context, subscriptionID string, resourceGroupName string, targetDbServerName string, migrationName string, parameters MigrationResourceForPatch, options *MigrationsClientUpdateOptions) (MigrationsClientUpdateResponse, error)

Update - Updates an existing migration. The request body can contain one to many of the mutable properties present in the migration definition. Certain property updates initiate migration state transitions. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • subscriptionID - The subscription ID of the target database server.
  • resourceGroupName - The resource group name of the target database server.
  • targetDbServerName - The name of the target database server.
  • migrationName - The name of the migration.
  • parameters - The required parameters for updating a migration.
  • options - MigrationsClientUpdateOptions contains the optional parameters for the MigrationsClient.Update method.
Example (CancelMigration)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_Cancel.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Update(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigration", armpostgresqlflexibleservers.MigrationResourceForPatch{
	Properties: &armpostgresqlflexibleservers.MigrationResourcePropertiesForPatch{
		Cancel: to.Ptr(armpostgresqlflexibleservers.CancelEnumTrue),
	},
}, 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigration"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigration"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStateCompleted),
// 			},
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateCanceled),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("postgres")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("d3ceacbb-a5fd-43dc-a9db-6022b5154856"),
// 			MigrationMode: to.Ptr(armpostgresqlflexibleservers.MigrationModeOnline),
// 			MigrationWindowEndTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-15T07:23:56.326Z"); return t}()),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-15T07:22:57.700Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumTrue),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumTrue),
// 			SourceDbServerMetadata: &armpostgresqlflexibleservers.DbServerMetadata{
// 				Location: to.Ptr("eastasia"),
// 				SKU: &armpostgresqlflexibleservers.ServerSKU{
// 					Name: to.Ptr("B_Gen5_2"),
// 					Tier: to.Ptr(armpostgresqlflexibleservers.SKUTier("Basic")),
// 				},
// 			},
// 			SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
// 			TargetDbServerMetadata: &armpostgresqlflexibleservers.DbServerMetadata{
// 				Location: to.Ptr("East Asia"),
// 				SKU: &armpostgresqlflexibleservers.ServerSKU{
// 					Name: to.Ptr("Standard_D2ds_v4"),
// 					Tier: to.Ptr(armpostgresqlflexibleservers.SKUTier("Standard_D2ds_v4")),
// 				},
// 			},
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 		},
// 	}

Output:
Example (MigrationsUpdate)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/Migrations_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMigrationsClient().Update(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", "testmigration", armpostgresqlflexibleservers.MigrationResourceForPatch{
	Properties: &armpostgresqlflexibleservers.MigrationResourcePropertiesForPatch{
		SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumTrue),
	},
}, 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.MigrationResource = armpostgresqlflexibleservers.MigrationResource{
// 	Name: to.Ptr("testmigration"),
// 	Type: to.Ptr("Microsoft.DBForPostgreSql/flexibleServers/migrations"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget/migrations/testmigration"),
// 	Location: to.Ptr("westus"),
// 	Properties: &armpostgresqlflexibleservers.MigrationResourceProperties{
// 		CurrentStatus: &armpostgresqlflexibleservers.MigrationStatus{
// 			CurrentSubStateDetails: &armpostgresqlflexibleservers.MigrationSubStateDetails{
// 				CurrentSubState: to.Ptr(armpostgresqlflexibleservers.MigrationSubStatePerformingPreRequisiteSteps),
// 			},
// 			Error: to.Ptr(""),
// 			State: to.Ptr(armpostgresqlflexibleservers.MigrationStateInProgress),
// 		},
// 		DbsToMigrate: []*string{
// 			to.Ptr("db1"),
// 			to.Ptr("db2"),
// 			to.Ptr("db3"),
// 			to.Ptr("db4")},
// 			MigrateRoles: to.Ptr(armpostgresqlflexibleservers.MigrateRolesEnumFalse),
// 			MigrationID: to.Ptr("d3ceacbb-a5fd-43dc-a9db-6022b5154856"),
// 			MigrationWindowStartTimeInUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-06T16:05:58.895Z"); return t}()),
// 			OverwriteDbsInTarget: to.Ptr(armpostgresqlflexibleservers.OverwriteDbsInTargetEnumFalse),
// 			SetupLogicalReplicationOnSourceDbIfNeeded: to.Ptr(armpostgresqlflexibleservers.LogicalReplicationOnSourceDbEnumTrue),
// 			SourceDbServerMetadata: &armpostgresqlflexibleservers.DbServerMetadata{
// 				Location: to.Ptr("westus"),
// 				SKU: &armpostgresqlflexibleservers.ServerSKU{
// 					Name: to.Ptr("B_Gen5_2"),
// 					Tier: to.Ptr(armpostgresqlflexibleservers.SKUTier("Basic")),
// 				},
// 				StorageMb: to.Ptr[int32](1024),
// 				Version: to.Ptr("10"),
// 			},
// 			SourceDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/servers/testsource"),
// 			StartDataMigration: to.Ptr(armpostgresqlflexibleservers.StartDataMigrationEnumFalse),
// 			TargetDbServerMetadata: &armpostgresqlflexibleservers.DbServerMetadata{
// 				Location: to.Ptr("westus"),
// 				SKU: &armpostgresqlflexibleservers.ServerSKU{
// 					Name: to.Ptr("Standard_D4s_v3"),
// 					Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 				},
// 				StorageMb: to.Ptr[int32](2048),
// 				Version: to.Ptr("11"),
// 			},
// 			TargetDbServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBForPostgreSql/flexibleServers/testtarget"),
// 			TriggerCutover: to.Ptr(armpostgresqlflexibleservers.TriggerCutoverEnumFalse),
// 		},
// 	}

Output:

type MigrationsClientCreateOptions 

type MigrationsClientCreateOptions struct {
}

MigrationsClientCreateOptions contains the optional parameters for the MigrationsClient.Create method.

type MigrationsClientCreateResponse 

type MigrationsClientCreateResponse struct {
	// Represents a migration resource.
	MigrationResource
}

MigrationsClientCreateResponse contains the response from method MigrationsClient.Create.

type MigrationsClientDeleteOptions 

type MigrationsClientDeleteOptions struct {
}

MigrationsClientDeleteOptions contains the optional parameters for the MigrationsClient.Delete method.

type MigrationsClientDeleteResponse 

type MigrationsClientDeleteResponse struct {
}

MigrationsClientDeleteResponse contains the response from method MigrationsClient.Delete.

type MigrationsClientGetOptions 

type MigrationsClientGetOptions struct {
}

MigrationsClientGetOptions contains the optional parameters for the MigrationsClient.Get method.

type MigrationsClientGetResponse 

type MigrationsClientGetResponse struct {
	// Represents a migration resource.
	MigrationResource
}

MigrationsClientGetResponse contains the response from method MigrationsClient.Get.

type MigrationsClientListByTargetServerOptions 

type MigrationsClientListByTargetServerOptions struct {
	// Migration list filter. Retrieves either active migrations or all migrations.
	MigrationListFilter *MigrationListFilter
}

MigrationsClientListByTargetServerOptions contains the optional parameters for the MigrationsClient.NewListByTargetServerPager method.

type MigrationsClientListByTargetServerResponse 

type MigrationsClientListByTargetServerResponse struct {
	// A list of migration resources.
	MigrationResourceListResult
}

MigrationsClientListByTargetServerResponse contains the response from method MigrationsClient.NewListByTargetServerPager.

type MigrationsClientUpdateOptions 

type MigrationsClientUpdateOptions struct {
}

MigrationsClientUpdateOptions contains the optional parameters for the MigrationsClient.Update method.

type MigrationsClientUpdateResponse 

type MigrationsClientUpdateResponse struct {
	// Represents a migration resource.
	MigrationResource
}

MigrationsClientUpdateResponse contains the response from method MigrationsClient.Update.

type NameAvailability 

type NameAvailability struct {
	// Detailed reason why the given name is available.
	Message *string

	// Indicates if the resource name is available.
	NameAvailable *bool

	// The reason why the given name is not available.
	Reason *CheckNameAvailabilityReason

	// READ-ONLY; name of the PostgreSQL server.
	Name *string

	// READ-ONLY; type of the server
	Type *string
}

NameAvailability - Represents a resource name availability.

func (NameAvailability) MarshalJSON 

func (n NameAvailability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NameAvailability.

func (*NameAvailability) UnmarshalJSON 

func (n *NameAvailability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NameAvailability.

type NameProperty 

type NameProperty struct {
	// Localized name
	LocalizedValue *string

	// Name value
	Value *string
}

NameProperty - Name property for quota usage

func (NameProperty) MarshalJSON 

func (n NameProperty) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NameProperty.

func (*NameProperty) UnmarshalJSON 

func (n *NameProperty) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NameProperty.

type Network 

type Network struct {
	// Delegated subnet arm resource id. This is required to be passed during create, in case we want the server to be VNET injected,
	// i.e. Private access server. During update, pass this only if we want to
	// update the value for Private DNS zone.
	DelegatedSubnetResourceID *string

	// Private dns zone arm resource id. This is required to be passed during create, in case we want the server to be VNET injected,
	// i.e. Private access server. During update, pass this only if we want to
	// update the value for Private DNS zone.
	PrivateDNSZoneArmResourceID *string

	// public network access is enabled or not
	PublicNetworkAccess *ServerPublicNetworkAccessState
}

Network properties of a server.

func (Network) MarshalJSON 

func (n Network) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Network.

func (*Network) UnmarshalJSON 

func (n *Network) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Network.

type OnlineResizeSupportedEnum 

type OnlineResizeSupportedEnum string

OnlineResizeSupportedEnum - A value indicating whether online resize is supported in this region for the given subscription. "Enabled" means storage online resize is supported. "Disabled" means storage online resize is not supported. 

const (
	OnlineResizeSupportedEnumDisabled OnlineResizeSupportedEnum = "Disabled"
	OnlineResizeSupportedEnumEnabled  OnlineResizeSupportedEnum = "Enabled"
)

func PossibleOnlineResizeSupportedEnumValues 

func PossibleOnlineResizeSupportedEnumValues() []OnlineResizeSupportedEnum

PossibleOnlineResizeSupportedEnumValues returns the possible values for the OnlineResizeSupportedEnum const type.

type Operation 

type Operation struct {
	// Indicates whether the operation is a data action
	IsDataAction *bool

	// READ-ONLY; The localized display information for this particular operation or action.
	Display *OperationDisplay

	// READ-ONLY; The name of the operation being performed on this particular object.
	Name *string

	// READ-ONLY; The intended executor of the operation.
	Origin *OperationOrigin

	// READ-ONLY; Additional descriptions for the operation.
	Properties map[string]any
}

Operation - REST API operation definition.

func (Operation) MarshalJSON 

func (o Operation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

func (o *Operation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; Operation description.
	Description *string

	// READ-ONLY; Localized friendly name for the operation.
	Operation *string

	// READ-ONLY; Operation resource provider name.
	Provider *string

	// READ-ONLY; Resource on which the operation is performed.
	Resource *string
}

OperationDisplay - Display metadata associated with the operation.

func (OperationDisplay) MarshalJSON 

func (o OperationDisplay) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

func (o *OperationDisplay) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// URL client should use to fetch the next page (per server side paging). It's null for now, added for future use.
	NextLink *string

	// Collection of available operation details
	Value []*Operation
}

OperationListResult - A list of resource provider operations.

func (OperationListResult) MarshalJSON 

func (o OperationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

func (o *OperationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationOrigin 

type OperationOrigin string

OperationOrigin - The intended executor of the operation. 

const (
	OperationOriginNotSpecified OperationOrigin = "NotSpecified"
	OperationOriginSystem       OperationOrigin = "system"
	OperationOriginUser         OperationOrigin = "user"
)

func PossibleOperationOriginValues 

func PossibleOperationOriginValues() []OperationOrigin

PossibleOperationOriginValues returns the possible values for the OperationOrigin const type.

type OperationsClient 

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

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OperationsClient) List 

func (client *OperationsClient) List(ctx context.Context, options *OperationsClientListOptions) (OperationsClientListResponse, error)

List - Lists all of the available REST API operations. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • options - OperationsClientListOptions contains the optional parameters for the OperationsClient.List method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/OperationList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewOperationsClient().List(ctx, 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.OperationListResult = armpostgresqlflexibleservers.OperationListResult{
// 	Value: []*armpostgresqlflexibleservers.Operation{
// 		{
// 			Name: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/read"),
// 			Display: &armpostgresqlflexibleservers.OperationDisplay{
// 				Description: to.Ptr("Return the list of servers or gets the properties for the specified server."),
// 				Operation: to.Ptr("List/Get PostgreSQL Servers"),
// 				Provider: to.Ptr("Microsoft DB for PostgreSQL"),
// 				Resource: to.Ptr("PostgreSQL Server"),
// 			},
// 		},
// 		{
// 			Name: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/write"),
// 			Display: &armpostgresqlflexibleservers.OperationDisplay{
// 				Description: to.Ptr("Creates a server with the specified parameters or update the properties or tags for the specified server."),
// 				Operation: to.Ptr("Create/Update PostgreSQL Server"),
// 				Provider: to.Ptr("Microsoft DB for PostgreSQL"),
// 				Resource: to.Ptr("PostgreSQL Server"),
// 			},
// 		},
// 		{
// 			Name: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/delete"),
// 			Display: &armpostgresqlflexibleservers.OperationDisplay{
// 				Description: to.Ptr("Deletes an existing server."),
// 				Operation: to.Ptr("Delete PostgreSQL Server"),
// 				Provider: to.Ptr("Microsoft DB for PostgreSQL"),
// 				Resource: to.Ptr("PostgreSQL Server"),
// 			},
// 		},
// 		{
// 			Name: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/read"),
// 			Display: &armpostgresqlflexibleservers.OperationDisplay{
// 				Description: to.Ptr("Return the list of firewall rules for a server or gets the properties for the specified firewall rule."),
// 				Operation: to.Ptr("List/Get Firewall Rules"),
// 				Provider: to.Ptr("Microsoft DB for PostgreSQL"),
// 				Resource: to.Ptr("Firewall Rules"),
// 			},
// 		},
// 		{
// 			Name: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/write"),
// 			Display: &armpostgresqlflexibleservers.OperationDisplay{
// 				Description: to.Ptr("Creates a firewall rule with the specified parameters or update an existing rule."),
// 				Operation: to.Ptr("Create/Update Firewall Rule"),
// 				Provider: to.Ptr("Microsoft DB for PostgreSQL"),
// 				Resource: to.Ptr("Firewall Rules"),
// 			},
// 		},
// 		{
// 			Name: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/firewallRules/delete"),
// 			Display: &armpostgresqlflexibleservers.OperationDisplay{
// 				Description: to.Ptr("Deletes an existing firewall rule."),
// 				Operation: to.Ptr("Delete Firewall Rule"),
// 				Provider: to.Ptr("Microsoft DB for PostgreSQL"),
// 				Resource: to.Ptr("Firewall Rules"),
// 			},
// 		},
// 		{
// 			Name: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/providers/Microsoft.Insights/metricDefinitions/read"),
// 			Display: &armpostgresqlflexibleservers.OperationDisplay{
// 				Description: to.Ptr("Return types of metrics that are available for databases"),
// 				Operation: to.Ptr("Get database metric definitions"),
// 				Provider: to.Ptr("Microsoft DB for PostgreSQL"),
// 				Resource: to.Ptr("Database Metric Definition"),
// 			},
// 			Properties: map[string]any{
// 				"serviceSpecification": map[string]any{
// 					"metricSpecifications":[]any{
// 						map[string]any{
// 							"name": "cpu_percent",
// 							"aggregationType": "Average",
// 							"displayDescription": "CPU percent",
// 							"displayName": "CPU percent",
// 							"fillGapWithZero": true,
// 							"unit": "Percent",
// 						},
// 						map[string]any{
// 							"name": "compute_limit",
// 							"aggregationType": "Average",
// 							"displayDescription": "Compute Unit limit",
// 							"displayName": "Compute Unit limit",
// 							"unit": "Count",
// 						},
// 						map[string]any{
// 							"name": "compute_consumption_percent",
// 							"aggregationType": "Average",
// 							"displayDescription": "Compute Unit percentage",
// 							"displayName": "Compute Unit percentage",
// 							"fillGapWithZero": true,
// 							"unit": "Percent",
// 						},
// 						map[string]any{
// 							"name": "memory_percent",
// 							"aggregationType": "Average",
// 							"displayDescription": "Memory percent",
// 							"displayName": "Memory percent",
// 							"fillGapWithZero": true,
// 							"unit": "Percent",
// 						},
// 						map[string]any{
// 							"name": "io_consumption_percent",
// 							"aggregationType": "Average",
// 							"displayDescription": "IO percent",
// 							"displayName": "IO percent",
// 							"fillGapWithZero": true,
// 							"unit": "Percent",
// 						},
// 						map[string]any{
// 							"name": "storage_percent",
// 							"aggregationType": "Average",
// 							"displayDescription": "Storage percentage",
// 							"displayName": "Storage percentage",
// 							"unit": "Percent",
// 						},
// 						map[string]any{
// 							"name": "storage_used",
// 							"aggregationType": "Average",
// 							"displayDescription": "Storage used",
// 							"displayName": "Storage used",
// 							"unit": "Bytes",
// 						},
// 						map[string]any{
// 							"name": "storage_limit",
// 							"aggregationType": "Average",
// 							"displayDescription": "Storage limit",
// 							"displayName": "Storage limit",
// 							"unit": "Bytes",
// 						},
// 						map[string]any{
// 							"name": "active_connections",
// 							"aggregationType": "Average",
// 							"displayDescription": "Total active connections",
// 							"displayName": "Total active connections",
// 							"fillGapWithZero": true,
// 							"unit": "Count",
// 						},
// 						map[string]any{
// 							"name": "connections_failed",
// 							"aggregationType": "Average",
// 							"displayDescription": "Total failed connections",
// 							"displayName": "Total failed connections",
// 							"fillGapWithZero": true,
// 							"unit": "Count",
// 						},
// 					},
// 				},
// 			},
// 		},
// 		{
// 			Name: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/providers/Microsoft.Insights/diagnosticSettings/read"),
// 			Display: &armpostgresqlflexibleservers.OperationDisplay{
// 				Description: to.Ptr("Gets the disagnostic setting for the resource"),
// 				Operation: to.Ptr("Read diagnostic setting"),
// 				Provider: to.Ptr("Microsoft DB for PostgreSQL"),
// 				Resource: to.Ptr("Database Metric Definition"),
// 			},
// 		},
// 		{
// 			Name: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/providers/Microsoft.Insights/diagnosticSettings/write"),
// 			Display: &armpostgresqlflexibleservers.OperationDisplay{
// 				Description: to.Ptr("Creates or updates the diagnostic setting for the resource"),
// 				Operation: to.Ptr("Write diagnostic setting"),
// 				Provider: to.Ptr("Microsoft DB for PostgreSQL"),
// 				Resource: to.Ptr("Database Metric Definition"),
// 			},
// 	}},
// }

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.List method.

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// A list of resource provider operations.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.List.

type Origin 

type Origin string

Origin - Backup type. 

const (
	OriginFull Origin = "Full"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type OverwriteDbsInTargetEnum 

type OverwriteDbsInTargetEnum string

OverwriteDbsInTargetEnum - Indicates whether the databases on the target server can be overwritten, if already present. If set to False, the migration workflow will wait for a confirmation, if it detects that the database already exists. 

const (
	OverwriteDbsInTargetEnumFalse OverwriteDbsInTargetEnum = "False"
	OverwriteDbsInTargetEnumTrue  OverwriteDbsInTargetEnum = "True"
)

func PossibleOverwriteDbsInTargetEnumValues 

func PossibleOverwriteDbsInTargetEnumValues() []OverwriteDbsInTargetEnum

PossibleOverwriteDbsInTargetEnumValues returns the possible values for the OverwriteDbsInTargetEnum const type.

type PasswordAuthEnum 

type PasswordAuthEnum string

PasswordAuthEnum - If Enabled, Password authentication is enabled. 

const (
	PasswordAuthEnumDisabled PasswordAuthEnum = "Disabled"
	PasswordAuthEnumEnabled  PasswordAuthEnum = "Enabled"
)

func PossiblePasswordAuthEnumValues 

func PossiblePasswordAuthEnumValues() []PasswordAuthEnum

PossiblePasswordAuthEnumValues returns the possible values for the PasswordAuthEnum const type.

type PostgreSQLManagementClient 

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

PostgreSQLManagementClient contains the methods for the PostgreSQLManagementClient group. Don't use this type directly, use NewPostgreSQLManagementClient() instead.

func NewPostgreSQLManagementClient 

func NewPostgreSQLManagementClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*PostgreSQLManagementClient, error)

NewPostgreSQLManagementClient creates a new instance of PostgreSQLManagementClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PostgreSQLManagementClient) CheckMigrationNameAvailability 

func (client *PostgreSQLManagementClient) CheckMigrationNameAvailability(ctx context.Context, subscriptionID string, resourceGroupName string, targetDbServerName string, parameters MigrationNameAvailabilityResource, options *PostgreSQLManagementClientCheckMigrationNameAvailabilityOptions) (PostgreSQLManagementClientCheckMigrationNameAvailabilityResponse, error)

CheckMigrationNameAvailability - This method checks whether a proposed migration name is valid and available. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • subscriptionID - The subscription ID of the target database server.
  • resourceGroupName - The resource group name of the target database server.
  • targetDbServerName - The name of the target database server.
  • parameters - The required parameters for checking if a migration name is available.
  • options - PostgreSQLManagementClientCheckMigrationNameAvailabilityOptions contains the optional parameters for the PostgreSQLManagementClient.CheckMigrationNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/CheckMigrationNameAvailability.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPostgreSQLManagementClient().CheckMigrationNameAvailability(ctx, "ffffffff-ffff-ffff-ffff-ffffffffffff", "testrg", "testtarget", armpostgresqlflexibleservers.MigrationNameAvailabilityResource{
	Name: to.Ptr("name1"),
	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/migrations"),
}, 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.MigrationNameAvailabilityResource = armpostgresqlflexibleservers.MigrationNameAvailabilityResource{
// 	Name: to.Ptr("name1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/migrations"),
// 	NameAvailable: to.Ptr(true),
// }

Output:

type PostgreSQLManagementClientCheckMigrationNameAvailabilityOptions 

type PostgreSQLManagementClientCheckMigrationNameAvailabilityOptions struct {
}

PostgreSQLManagementClientCheckMigrationNameAvailabilityOptions contains the optional parameters for the PostgreSQLManagementClient.CheckMigrationNameAvailability method.

type PostgreSQLManagementClientCheckMigrationNameAvailabilityResponse 

type PostgreSQLManagementClientCheckMigrationNameAvailabilityResponse struct {
	// Represents a migration name's availability.
	MigrationNameAvailabilityResource
}

PostgreSQLManagementClientCheckMigrationNameAvailabilityResponse contains the response from method PostgreSQLManagementClient.CheckMigrationNameAvailability.

type PrincipalType 

type PrincipalType string

PrincipalType - The principal type used to represent the type of Active Directory Administrator. 

const (
	PrincipalTypeGroup            PrincipalType = "Group"
	PrincipalTypeServicePrincipal PrincipalType = "ServicePrincipal"
	PrincipalTypeUnknown          PrincipalType = "Unknown"
	PrincipalTypeUser             PrincipalType = "User"
)

func PossiblePrincipalTypeValues 

func PossiblePrincipalTypeValues() []PrincipalType

PossiblePrincipalTypeValues returns the possible values for the PrincipalType const type.

type PrivateEndpoint 

type PrivateEndpoint struct {
	// READ-ONLY; The ARM identifier for private endpoint.
	ID *string
}

PrivateEndpoint - The private endpoint resource.

func (PrivateEndpoint) MarshalJSON 

func (p PrivateEndpoint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateEndpoint.

func (*PrivateEndpoint) UnmarshalJSON 

func (p *PrivateEndpoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpoint.

type PrivateEndpointConnection 

type PrivateEndpointConnection struct {
	// Resource properties.
	Properties *PrivateEndpointConnectionProperties

	// 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
}

PrivateEndpointConnection - The private endpoint connection resource.

func (PrivateEndpointConnection) MarshalJSON 

func (p PrivateEndpointConnection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnection.

func (*PrivateEndpointConnection) UnmarshalJSON 

func (p *PrivateEndpointConnection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnection.

type PrivateEndpointConnectionClient 

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

PrivateEndpointConnectionClient contains the methods for the PrivateEndpointConnection group. Don't use this type directly, use NewPrivateEndpointConnectionClient() instead.

func NewPrivateEndpointConnectionClient 

func NewPrivateEndpointConnectionClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateEndpointConnectionClient, error)

NewPrivateEndpointConnectionClient creates a new instance of PrivateEndpointConnectionClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PrivateEndpointConnectionClient) BeginDelete 

func (client *PrivateEndpointConnectionClient) BeginDelete(ctx context.Context, resourceGroupName string, serverName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionClientBeginDeleteOptions) (*runtime.Poller[PrivateEndpointConnectionClientDeleteResponse], error)

BeginDelete - Deletes a private endpoint connection with a given name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • privateEndpointConnectionName - The name of the private endpoint connection.
  • options - PrivateEndpointConnectionClientBeginDeleteOptions contains the optional parameters for the PrivateEndpointConnectionClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/PrivateEndpointConnectionDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPrivateEndpointConnectionClient().BeginDelete(ctx, "Default", "test-svr", "private-endpoint-connection-name.1fa229cd-bf3f-47f0-8c49-afb36723997e", 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)
}

Output:

func (*PrivateEndpointConnectionClient) BeginUpdate 

func (client *PrivateEndpointConnectionClient) BeginUpdate(ctx context.Context, resourceGroupName string, serverName string, privateEndpointConnectionName string, parameters PrivateEndpointConnection, options *PrivateEndpointConnectionClientBeginUpdateOptions) (*runtime.Poller[PrivateEndpointConnectionClientUpdateResponse], error)

BeginUpdate - Approve or reject a private endpoint connection with a given name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • privateEndpointConnectionName - The name of the private endpoint connection.
  • parameters - The required parameters for updating private endpoint connection.
  • options - PrivateEndpointConnectionClientBeginUpdateOptions contains the optional parameters for the PrivateEndpointConnectionClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/PrivateEndpointConnectionUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPrivateEndpointConnectionClient().BeginUpdate(ctx, "Default", "test-svr", "private-endpoint-connection-name.1fa229cd-bf3f-47f0-8c49-afb36723997e", armpostgresqlflexibleservers.PrivateEndpointConnection{
	Properties: &armpostgresqlflexibleservers.PrivateEndpointConnectionProperties{
		PrivateLinkServiceConnectionState: &armpostgresqlflexibleservers.PrivateLinkServiceConnectionState{
			Description: to.Ptr("Approved by johndoe@contoso.com"),
			Status:      to.Ptr(armpostgresqlflexibleservers.PrivateEndpointServiceConnectionStatusApproved),
		},
	},
}, 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.PrivateEndpointConnection = armpostgresqlflexibleservers.PrivateEndpointConnection{
// 	Name: to.Ptr("private-endpoint-connection-name.1fa229cd-bf3f-47f0-8c49-afb36723997e"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/privateEndpointConnections"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/Default/providers/Microsoft.DBforPostgreSQL/flexibleServers/test-svr/privateEndpointConnections/private-endpoint-connection-name.1fa229cd-bf3f-47f0-8c49-afb36723997e"),
// 	Properties: &armpostgresqlflexibleservers.PrivateEndpointConnectionProperties{
// 		GroupIDs: []*string{
// 			to.Ptr("postgresqlServer")},
// 			PrivateEndpoint: &armpostgresqlflexibleservers.PrivateEndpoint{
// 				ID: to.Ptr("/subscriptions/55555555-6666-7777-8888-999999999999/resourceGroups/Default-Network/providers/Microsoft.Network/privateEndpoints/private-endpoint-name"),
// 			},
// 			PrivateLinkServiceConnectionState: &armpostgresqlflexibleservers.PrivateLinkServiceConnectionState{
// 				Description: to.Ptr("Approved by johndoe@contoso.com"),
// 				ActionsRequired: to.Ptr("None"),
// 				Status: to.Ptr(armpostgresqlflexibleservers.PrivateEndpointServiceConnectionStatusApproved),
// 			},
// 			ProvisioningState: to.Ptr(armpostgresqlflexibleservers.PrivateEndpointConnectionProvisioningStateSucceeded),
// 		},
// 	}

Output:

type PrivateEndpointConnectionClientBeginDeleteOptions 

type PrivateEndpointConnectionClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

PrivateEndpointConnectionClientBeginDeleteOptions contains the optional parameters for the PrivateEndpointConnectionClient.BeginDelete method.

type PrivateEndpointConnectionClientBeginUpdateOptions 

type PrivateEndpointConnectionClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

PrivateEndpointConnectionClientBeginUpdateOptions contains the optional parameters for the PrivateEndpointConnectionClient.BeginUpdate method.

type PrivateEndpointConnectionClientDeleteResponse 

type PrivateEndpointConnectionClientDeleteResponse struct {
}

PrivateEndpointConnectionClientDeleteResponse contains the response from method PrivateEndpointConnectionClient.BeginDelete.

type PrivateEndpointConnectionClientUpdateResponse 

type PrivateEndpointConnectionClientUpdateResponse struct {
	// The private endpoint connection resource.
	PrivateEndpointConnection
}

PrivateEndpointConnectionClientUpdateResponse contains the response from method PrivateEndpointConnectionClient.BeginUpdate.

type PrivateEndpointConnectionListResult 

type PrivateEndpointConnectionListResult struct {
	// READ-ONLY; The URL to get the next set of results.
	NextLink *string

	// READ-ONLY; Array of results.
	Value []*PrivateEndpointConnection
}

PrivateEndpointConnectionListResult - A list of private endpoint connections.

func (PrivateEndpointConnectionListResult) MarshalJSON 

func (p PrivateEndpointConnectionListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionListResult.

func (*PrivateEndpointConnectionListResult) UnmarshalJSON 

func (p *PrivateEndpointConnectionListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionListResult.

type PrivateEndpointConnectionProperties 

type PrivateEndpointConnectionProperties struct {
	// REQUIRED; A collection of information about the state of the connection between service consumer and provider.
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState

	// The private endpoint resource.
	PrivateEndpoint *PrivateEndpoint

	// READ-ONLY; The group ids for the private endpoint resource.
	GroupIDs []*string

	// READ-ONLY; The provisioning state of the private endpoint connection resource.
	ProvisioningState *PrivateEndpointConnectionProvisioningState
}

PrivateEndpointConnectionProperties - Properties of the private endpoint connection.

func (PrivateEndpointConnectionProperties) MarshalJSON 

func (p PrivateEndpointConnectionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionProperties.

func (*PrivateEndpointConnectionProperties) UnmarshalJSON 

func (p *PrivateEndpointConnectionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionProperties.

type PrivateEndpointConnectionProvisioningState 

type PrivateEndpointConnectionProvisioningState string

PrivateEndpointConnectionProvisioningState - The current provisioning state. 

const (
	PrivateEndpointConnectionProvisioningStateCreating  PrivateEndpointConnectionProvisioningState = "Creating"
	PrivateEndpointConnectionProvisioningStateDeleting  PrivateEndpointConnectionProvisioningState = "Deleting"
	PrivateEndpointConnectionProvisioningStateFailed    PrivateEndpointConnectionProvisioningState = "Failed"
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
)

func PossiblePrivateEndpointConnectionProvisioningStateValues 

func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState

PossiblePrivateEndpointConnectionProvisioningStateValues returns the possible values for the PrivateEndpointConnectionProvisioningState const type.

type PrivateEndpointConnectionsClient 

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

PrivateEndpointConnectionsClient contains the methods for the PrivateEndpointConnections group. Don't use this type directly, use NewPrivateEndpointConnectionsClient() instead.

func NewPrivateEndpointConnectionsClient 

func NewPrivateEndpointConnectionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateEndpointConnectionsClient, error)

NewPrivateEndpointConnectionsClient creates a new instance of PrivateEndpointConnectionsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PrivateEndpointConnectionsClient) Get 

func (client *PrivateEndpointConnectionsClient) Get(ctx context.Context, resourceGroupName string, serverName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientGetOptions) (PrivateEndpointConnectionsClientGetResponse, error)

Get - Gets a private endpoint connection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • privateEndpointConnectionName - The name of the private endpoint connection.
  • options - PrivateEndpointConnectionsClientGetOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/PrivateEndpointConnectionGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPrivateEndpointConnectionsClient().Get(ctx, "Default", "test-svr", "private-endpoint-connection-name.1fa229cd-bf3f-47f0-8c49-afb36723997e", 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.PrivateEndpointConnection = armpostgresqlflexibleservers.PrivateEndpointConnection{
// 	Name: to.Ptr("private-endpoint-connection-name.1fa229cd-bf3f-47f0-8c49-afb36723997e"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/privateEndpointConnections"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/Default/providers/Microsoft.DBforPostgreSQL/flexibleServers/test-svr/privateEndpointConnections/private-endpoint-connection-name.1fa229cd-bf3f-47f0-8c49-afb36723997e"),
// 	Properties: &armpostgresqlflexibleservers.PrivateEndpointConnectionProperties{
// 		GroupIDs: []*string{
// 			to.Ptr("postgresqlServer")},
// 			PrivateEndpoint: &armpostgresqlflexibleservers.PrivateEndpoint{
// 				ID: to.Ptr("/subscriptions/55555555-6666-7777-8888-999999999999/resourceGroups/Default-Network/providers/Microsoft.Network/privateEndpoints/private-endpoint-name"),
// 			},
// 			PrivateLinkServiceConnectionState: &armpostgresqlflexibleservers.PrivateLinkServiceConnectionState{
// 				Description: to.Ptr("Auto-approved"),
// 				ActionsRequired: to.Ptr("None"),
// 				Status: to.Ptr(armpostgresqlflexibleservers.PrivateEndpointServiceConnectionStatusApproved),
// 			},
// 			ProvisioningState: to.Ptr(armpostgresqlflexibleservers.PrivateEndpointConnectionProvisioningStateSucceeded),
// 		},
// 	}

Output:

func (*PrivateEndpointConnectionsClient) NewListByServerPager 

func (client *PrivateEndpointConnectionsClient) NewListByServerPager(resourceGroupName string, serverName string, options *PrivateEndpointConnectionsClientListByServerOptions) *runtime.Pager[PrivateEndpointConnectionsClientListByServerResponse]

NewListByServerPager - Gets all private endpoint connections on a server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - PrivateEndpointConnectionsClientListByServerOptions contains the optional parameters for the PrivateEndpointConnectionsClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/PrivateEndpointConnectionList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewPrivateEndpointConnectionsClient().NewListByServerPager("Default", "test-svr", 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.PrivateEndpointConnectionListResult = armpostgresqlflexibleservers.PrivateEndpointConnectionListResult{
	// 	Value: []*armpostgresqlflexibleservers.PrivateEndpointConnection{
	// 		{
	// 			Name: to.Ptr("private-endpoint-connection-name.1fa229cd-bf3f-47f0-8c49-afb36723997e"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/privateEndpointConnections"),
	// 			ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/Default/providers/Microsoft.DBforPostgreSQL/flexibleServers/test-svr/privateEndpointConnections/private-endpoint-connection-name.1fa229cd-bf3f-47f0-8c49-afb36723997e"),
	// 			Properties: &armpostgresqlflexibleservers.PrivateEndpointConnectionProperties{
	// 				GroupIDs: []*string{
	// 					to.Ptr("postgresqlServer")},
	// 					PrivateEndpoint: &armpostgresqlflexibleservers.PrivateEndpoint{
	// 						ID: to.Ptr("/subscriptions/55555555-6666-7777-8888-999999999999/resourceGroups/Default-Network/providers/Microsoft.Network/privateEndpoints/private-endpoint-name"),
	// 					},
	// 					PrivateLinkServiceConnectionState: &armpostgresqlflexibleservers.PrivateLinkServiceConnectionState{
	// 						Description: to.Ptr("Auto-approved"),
	// 						ActionsRequired: to.Ptr("None"),
	// 						Status: to.Ptr(armpostgresqlflexibleservers.PrivateEndpointServiceConnectionStatusApproved),
	// 					},
	// 					ProvisioningState: to.Ptr(armpostgresqlflexibleservers.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 				},
	// 			},
	// 			{
	// 				Name: to.Ptr("private-endpoint-connection-name-2.1fa229cd-bf3f-47f0-8c49-afb36723997e"),
	// 				Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/privateEndpointConnections"),
	// 				ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/Default/providers/Microsoft.DBforPostgreSQL/flexibleServers/test-svr/privateEndpointConnections/private-endpoint-connection-name-2.1fa229cd-bf3f-47f0-8c49-afb36723997e"),
	// 				Properties: &armpostgresqlflexibleservers.PrivateEndpointConnectionProperties{
	// 					GroupIDs: []*string{
	// 						to.Ptr("postgresqlServer")},
	// 						PrivateEndpoint: &armpostgresqlflexibleservers.PrivateEndpoint{
	// 							ID: to.Ptr("/subscriptions/55555555-6666-7777-8888-999999999999/resourceGroups/Default-Network/providers/Microsoft.Network/privateEndpoints/private-endpoint-name-2"),
	// 						},
	// 						PrivateLinkServiceConnectionState: &armpostgresqlflexibleservers.PrivateLinkServiceConnectionState{
	// 							Description: to.Ptr("Auto-approved"),
	// 							ActionsRequired: to.Ptr("None"),
	// 							Status: to.Ptr(armpostgresqlflexibleservers.PrivateEndpointServiceConnectionStatusApproved),
	// 						},
	// 						ProvisioningState: to.Ptr(armpostgresqlflexibleservers.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 					},
	// 			}},
	// 		}
}

Output:

type PrivateEndpointConnectionsClientGetOptions 

type PrivateEndpointConnectionsClientGetOptions struct {
}

PrivateEndpointConnectionsClientGetOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Get method.

type PrivateEndpointConnectionsClientGetResponse 

type PrivateEndpointConnectionsClientGetResponse struct {
	// The private endpoint connection resource.
	PrivateEndpointConnection
}

PrivateEndpointConnectionsClientGetResponse contains the response from method PrivateEndpointConnectionsClient.Get.

type PrivateEndpointConnectionsClientListByServerOptions 

type PrivateEndpointConnectionsClientListByServerOptions struct {
}

PrivateEndpointConnectionsClientListByServerOptions contains the optional parameters for the PrivateEndpointConnectionsClient.NewListByServerPager method.

type PrivateEndpointConnectionsClientListByServerResponse 

type PrivateEndpointConnectionsClientListByServerResponse struct {
	// A list of private endpoint connections.
	PrivateEndpointConnectionListResult
}

PrivateEndpointConnectionsClientListByServerResponse contains the response from method PrivateEndpointConnectionsClient.NewListByServerPager.

type PrivateEndpointServiceConnectionStatus 

type PrivateEndpointServiceConnectionStatus string

PrivateEndpointServiceConnectionStatus - The private endpoint connection status. 

const (
	PrivateEndpointServiceConnectionStatusApproved PrivateEndpointServiceConnectionStatus = "Approved"
	PrivateEndpointServiceConnectionStatusPending  PrivateEndpointServiceConnectionStatus = "Pending"
	PrivateEndpointServiceConnectionStatusRejected PrivateEndpointServiceConnectionStatus = "Rejected"
)

func PossiblePrivateEndpointServiceConnectionStatusValues 

func PossiblePrivateEndpointServiceConnectionStatusValues() []PrivateEndpointServiceConnectionStatus

PossiblePrivateEndpointServiceConnectionStatusValues returns the possible values for the PrivateEndpointServiceConnectionStatus const type.

type PrivateLinkResource 

type PrivateLinkResource struct {
	// Resource properties.
	Properties *PrivateLinkResourceProperties

	// 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
}

PrivateLinkResource - A private link resource.

func (PrivateLinkResource) MarshalJSON 

func (p PrivateLinkResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResource.

func (*PrivateLinkResource) UnmarshalJSON 

func (p *PrivateLinkResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResource.

type PrivateLinkResourceListResult 

type PrivateLinkResourceListResult struct {
	// READ-ONLY; Link to retrieve next page of results.
	NextLink *string

	// READ-ONLY; Array of results.
	Value []*PrivateLinkResource
}

PrivateLinkResourceListResult - A list of private link resources

func (PrivateLinkResourceListResult) MarshalJSON 

func (p PrivateLinkResourceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceListResult.

func (*PrivateLinkResourceListResult) UnmarshalJSON 

func (p *PrivateLinkResourceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourceListResult.

type PrivateLinkResourceProperties 

type PrivateLinkResourceProperties struct {
	// The private link resource private link DNS zone name.
	RequiredZoneNames []*string

	// READ-ONLY; The private link resource group id.
	GroupID *string

	// READ-ONLY; The private link resource required member names.
	RequiredMembers []*string
}

PrivateLinkResourceProperties - Properties of a private link resource.

func (PrivateLinkResourceProperties) MarshalJSON 

func (p PrivateLinkResourceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceProperties.

func (*PrivateLinkResourceProperties) UnmarshalJSON 

func (p *PrivateLinkResourceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourceProperties.

type PrivateLinkResourcesClient 

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

PrivateLinkResourcesClient contains the methods for the PrivateLinkResources group. Don't use this type directly, use NewPrivateLinkResourcesClient() instead.

func NewPrivateLinkResourcesClient 

func NewPrivateLinkResourcesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateLinkResourcesClient, error)

NewPrivateLinkResourcesClient creates a new instance of PrivateLinkResourcesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PrivateLinkResourcesClient) Get 

func (client *PrivateLinkResourcesClient) Get(ctx context.Context, resourceGroupName string, serverName string, groupName string, options *PrivateLinkResourcesClientGetOptions) (PrivateLinkResourcesClientGetResponse, error)

Get - Gets a private link resource for PostgreSQL server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • groupName - The name of the private link resource.
  • options - PrivateLinkResourcesClientGetOptions contains the optional parameters for the PrivateLinkResourcesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/PrivateLinkResourcesGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPrivateLinkResourcesClient().Get(ctx, "Default", "test-svr", "plr", 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.PrivateLinkResource = armpostgresqlflexibleservers.PrivateLinkResource{
// 	Name: to.Ptr("plr"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/privateLinkResources"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/Default/providers/Microsoft.DBforPostgreSQL/flexibleServers/test-svr/privateLinkResources/plr"),
// 	Properties: &armpostgresqlflexibleservers.PrivateLinkResourceProperties{
// 		GroupID: to.Ptr("postgresqlServer"),
// 		RequiredMembers: []*string{
// 			to.Ptr("postgresqlServer")},
// 			RequiredZoneNames: []*string{
// 				to.Ptr("privatelink.meru.com")},
// 			},
// 		}

Output:

func (*PrivateLinkResourcesClient) NewListByServerPager 

func (client *PrivateLinkResourcesClient) NewListByServerPager(resourceGroupName string, serverName string, options *PrivateLinkResourcesClientListByServerOptions) *runtime.Pager[PrivateLinkResourcesClientListByServerResponse]

NewListByServerPager - Gets the private link resources for PostgreSQL server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - PrivateLinkResourcesClientListByServerOptions contains the optional parameters for the PrivateLinkResourcesClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/PrivateLinkResourcesList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewPrivateLinkResourcesClient().NewListByServerPager("Default", "test-svr", 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.PrivateLinkResourceListResult = armpostgresqlflexibleservers.PrivateLinkResourceListResult{
	// 	Value: []*armpostgresqlflexibleservers.PrivateLinkResource{
	// 		{
	// 			Name: to.Ptr("plr"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/privateLinkResources"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/Default/providers/Microsoft.DBforPostgreSQL/flexibleServers/test-svr/privateLinkResources/plr"),
	// 			Properties: &armpostgresqlflexibleservers.PrivateLinkResourceProperties{
	// 				GroupID: to.Ptr("postgresqlServer"),
	// 				RequiredMembers: []*string{
	// 					to.Ptr("postgresqlServer")},
	// 					RequiredZoneNames: []*string{
	// 						to.Ptr("privatelink.meru.com")},
	// 					},
	// 			}},
	// 		}
}

Output:

type PrivateLinkResourcesClientGetOptions 

type PrivateLinkResourcesClientGetOptions struct {
}

PrivateLinkResourcesClientGetOptions contains the optional parameters for the PrivateLinkResourcesClient.Get method.

type PrivateLinkResourcesClientGetResponse 

type PrivateLinkResourcesClientGetResponse struct {
	// A private link resource.
	PrivateLinkResource
}

PrivateLinkResourcesClientGetResponse contains the response from method PrivateLinkResourcesClient.Get.

type PrivateLinkResourcesClientListByServerOptions 

type PrivateLinkResourcesClientListByServerOptions struct {
}

PrivateLinkResourcesClientListByServerOptions contains the optional parameters for the PrivateLinkResourcesClient.NewListByServerPager method.

type PrivateLinkResourcesClientListByServerResponse 

type PrivateLinkResourcesClientListByServerResponse struct {
	// A list of private link resources
	PrivateLinkResourceListResult
}

PrivateLinkResourcesClientListByServerResponse contains the response from method PrivateLinkResourcesClient.NewListByServerPager.

type PrivateLinkServiceConnectionState 

type PrivateLinkServiceConnectionState struct {
	// A message indicating if changes on the service provider require any updates on the consumer.
	ActionsRequired *string

	// The reason for approval/rejection of the connection.
	Description *string

	// Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
	Status *PrivateEndpointServiceConnectionStatus
}

PrivateLinkServiceConnectionState - A collection of information about the state of the connection between service consumer and provider.

func (PrivateLinkServiceConnectionState) MarshalJSON 

func (p PrivateLinkServiceConnectionState) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateLinkServiceConnectionState.

func (*PrivateLinkServiceConnectionState) UnmarshalJSON 

func (p *PrivateLinkServiceConnectionState) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkServiceConnectionState.

type QuotaUsage 

type QuotaUsage struct {
	// Current Quota usage value
	CurrentValue *int64

	// Fully qualified ARM resource Id
	ID *string

	// Quota limit
	Limit *int64

	// Name of quota usage for flexible servers
	Name *NameProperty

	// Quota unit
	Unit *string
}

QuotaUsage - Quota usage for flexible servers

func (QuotaUsage) MarshalJSON 

func (q QuotaUsage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type QuotaUsage.

func (*QuotaUsage) UnmarshalJSON 

func (q *QuotaUsage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type QuotaUsage.

type QuotaUsagesClient 

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

QuotaUsagesClient contains the methods for the QuotaUsages group. Don't use this type directly, use NewQuotaUsagesClient() instead.

func NewQuotaUsagesClient 

func NewQuotaUsagesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*QuotaUsagesClient, error)

NewQuotaUsagesClient creates a new instance of QuotaUsagesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*QuotaUsagesClient) NewListPager 

func (client *QuotaUsagesClient) NewListPager(locationName string, options *QuotaUsagesClientListOptions) *runtime.Pager[QuotaUsagesClientListResponse]

NewListPager - Get quota usages at specified location in a given subscription.

Generated from API version 2023-12-01-preview

  • locationName - The name of the location.
  • options - QuotaUsagesClientListOptions contains the optional parameters for the QuotaUsagesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/QuotaUsagesForFlexibleServers.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewQuotaUsagesClient().NewListPager("westus", 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.QuotaUsagesListResult = armpostgresqlflexibleservers.QuotaUsagesListResult{
	// 	Value: []*armpostgresqlflexibleservers.QuotaUsage{
	// 		{
	// 			Name: &armpostgresqlflexibleservers.NameProperty{
	// 				LocalizedValue: to.Ptr("standardBSFamily"),
	// 				Value: to.Ptr("standardBSFamily"),
	// 			},
	// 			CurrentValue: to.Ptr[int64](0),
	// 			ID: to.Ptr(""),
	// 			Limit: to.Ptr[int64](10000),
	// 			Unit: to.Ptr("Count"),
	// 		},
	// 		{
	// 			Name: &armpostgresqlflexibleservers.NameProperty{
	// 				LocalizedValue: to.Ptr("standardDDSv4Family"),
	// 				Value: to.Ptr("standardDDSv4Family"),
	// 			},
	// 			CurrentValue: to.Ptr[int64](0),
	// 			ID: to.Ptr(""),
	// 			Limit: to.Ptr[int64](100),
	// 			Unit: to.Ptr("Count"),
	// 	}},
	// }
}

Output:

type QuotaUsagesClientListOptions 

type QuotaUsagesClientListOptions struct {
}

QuotaUsagesClientListOptions contains the optional parameters for the QuotaUsagesClient.NewListPager method.

type QuotaUsagesClientListResponse 

type QuotaUsagesClientListResponse struct {
	// Capability for the PostgreSQL server
	QuotaUsagesListResult
}

QuotaUsagesClientListResponse contains the response from method QuotaUsagesClient.NewListPager.

type QuotaUsagesListResult 

type QuotaUsagesListResult struct {
	// READ-ONLY; Link to retrieve next page of results.
	NextLink *string

	// READ-ONLY; A list of quota usages.
	Value []*QuotaUsage
}

QuotaUsagesListResult - Capability for the PostgreSQL server

func (QuotaUsagesListResult) MarshalJSON 

func (q QuotaUsagesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type QuotaUsagesListResult.

func (*QuotaUsagesListResult) UnmarshalJSON 

func (q *QuotaUsagesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type QuotaUsagesListResult.

type ReadReplicaPromoteMode 

type ReadReplicaPromoteMode string

ReadReplicaPromoteMode - Sets the promote mode for a replica server. This is a write only property. 

const (
	ReadReplicaPromoteModeStandalone ReadReplicaPromoteMode = "standalone"
	ReadReplicaPromoteModeSwitchover ReadReplicaPromoteMode = "switchover"
)

func PossibleReadReplicaPromoteModeValues 

func PossibleReadReplicaPromoteModeValues() []ReadReplicaPromoteMode

PossibleReadReplicaPromoteModeValues returns the possible values for the ReadReplicaPromoteMode const type.

type Replica 

type Replica struct {
	// Sets the promote mode for a replica server. This is a write only property.
	PromoteMode *ReadReplicaPromoteMode

	// Sets the promote options for a replica server. This is a write only property.
	PromoteOption *ReplicationPromoteOption

	// Used to indicate role of the server in replication set.
	Role *ReplicationRole

	// READ-ONLY; Replicas allowed for a server.
	Capacity *int32

	// READ-ONLY; Gets the replication state of a replica server. This property is returned only for replicas api call. Supported
	// values are Active, Catchup, Provisioning, Updating, Broken, Reconfiguring
	ReplicationState *ReplicationState
}

Replica properties of a server

func (Replica) MarshalJSON 

func (r Replica) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Replica.

func (*Replica) UnmarshalJSON 

func (r *Replica) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Replica.

type ReplicasClient 

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

ReplicasClient contains the methods for the Replicas group. Don't use this type directly, use NewReplicasClient() instead.

func NewReplicasClient 

func NewReplicasClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ReplicasClient, error)

NewReplicasClient creates a new instance of ReplicasClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ReplicasClient) NewListByServerPager 

func (client *ReplicasClient) NewListByServerPager(resourceGroupName string, serverName string, options *ReplicasClientListByServerOptions) *runtime.Pager[ReplicasClientListByServerResponse]

NewListByServerPager - List all the replicas for a given server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - ReplicasClientListByServerOptions contains the optional parameters for the ReplicasClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ReplicasListByServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewReplicasClient().NewListByServerPager("testrg", "sourcepgservername", 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.ServerListResult = armpostgresqlflexibleservers.ServerListResult{
	// 	Value: []*armpostgresqlflexibleservers.Server{
	// 		{
	// 			Name: to.Ptr("pgtestsvc5rep"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc5rep"),
	// 			Location: to.Ptr("westus"),
	// 			Tags: map[string]*string{
	// 				"ElasticServer": to.Ptr("1"),
	// 			},
	// 			Properties: &armpostgresqlflexibleservers.ServerProperties{
	// 				AdministratorLogin: to.Ptr("cloudsa"),
	// 				AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
	// 					ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
	// 					PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
	// 				},
	// 				AvailabilityZone: to.Ptr("2"),
	// 				Backup: &armpostgresqlflexibleservers.Backup{
	// 					BackupRetentionDays: to.Ptr[int32](7),
	// 					EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-27T00:28:17.727Z"); return t}()),
	// 					GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
	// 				},
	// 				DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
	// 					Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
	// 				},
	// 				FullyQualifiedDomainName: to.Ptr("pgtestsvc5rep.postgres.database.azure.com"),
	// 				HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
	// 					Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeDisabled),
	// 					State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateNotEnabled),
	// 				},
	// 				MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
	// 					CustomWindow: to.Ptr("Disabled"),
	// 					DayOfWeek: to.Ptr[int32](0),
	// 					StartHour: to.Ptr[int32](0),
	// 					StartMinute: to.Ptr[int32](0),
	// 				},
	// 				MinorVersion: to.Ptr("6"),
	// 				Network: &armpostgresqlflexibleservers.Network{
	// 					PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateEnabled),
	// 				},
	// 				Replica: &armpostgresqlflexibleservers.Replica{
	// 					Capacity: to.Ptr[int32](0),
	// 					ReplicationState: to.Ptr(armpostgresqlflexibleservers.ReplicationStateActive),
	// 					Role: to.Ptr(armpostgresqlflexibleservers.ReplicationRoleAsyncReplica),
	// 				},
	// 				ReplicaCapacity: to.Ptr[int32](0),
	// 				ReplicationRole: to.Ptr(armpostgresqlflexibleservers.ReplicationRoleAsyncReplica),
	// 				State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
	// 				Storage: &armpostgresqlflexibleservers.Storage{
	// 					AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
	// 					Iops: to.Ptr[int32](2300),
	// 					StorageSizeGB: to.Ptr[int32](512),
	// 					Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
	// 				},
	// 				Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
	// 			},
	// 			SKU: &armpostgresqlflexibleservers.SKU{
	// 				Name: to.Ptr("Standard_D4s_v3"),
	// 				Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	// 			},
	// 	}},
	// }
}

Output:

type ReplicasClientListByServerOptions 

type ReplicasClientListByServerOptions struct {
}

ReplicasClientListByServerOptions contains the optional parameters for the ReplicasClient.NewListByServerPager method.

type ReplicasClientListByServerResponse 

type ReplicasClientListByServerResponse struct {
	// A list of servers.
	ServerListResult
}

ReplicasClientListByServerResponse contains the response from method ReplicasClient.NewListByServerPager.

type ReplicationPromoteOption 

type ReplicationPromoteOption string

ReplicationPromoteOption - Sets the promote options for a replica server. This is a write only property. 

const (
	ReplicationPromoteOptionForced  ReplicationPromoteOption = "forced"
	ReplicationPromoteOptionPlanned ReplicationPromoteOption = "planned"
)

func PossibleReplicationPromoteOptionValues 

func PossibleReplicationPromoteOptionValues() []ReplicationPromoteOption

PossibleReplicationPromoteOptionValues returns the possible values for the ReplicationPromoteOption const type.

type ReplicationRole 

type ReplicationRole string

ReplicationRole - Used to indicate role of the server in replication set. 

const (
	ReplicationRoleAsyncReplica    ReplicationRole = "AsyncReplica"
	ReplicationRoleGeoAsyncReplica ReplicationRole = "GeoAsyncReplica"
	ReplicationRoleNone            ReplicationRole = "None"
	ReplicationRolePrimary         ReplicationRole = "Primary"
)

func PossibleReplicationRoleValues 

func PossibleReplicationRoleValues() []ReplicationRole

PossibleReplicationRoleValues returns the possible values for the ReplicationRole const type.

type ReplicationState 

type ReplicationState string

ReplicationState - Gets the replication state of a replica server. This property is returned only for replicas api call. Supported values are Active, Catchup, Provisioning, Updating, Broken, Reconfiguring 

const (
	ReplicationStateActive        ReplicationState = "Active"
	ReplicationStateBroken        ReplicationState = "Broken"
	ReplicationStateCatchup       ReplicationState = "Catchup"
	ReplicationStateProvisioning  ReplicationState = "Provisioning"
	ReplicationStateReconfiguring ReplicationState = "Reconfiguring"
	ReplicationStateUpdating      ReplicationState = "Updating"
)

func PossibleReplicationStateValues 

func PossibleReplicationStateValues() []ReplicationState

PossibleReplicationStateValues returns the possible values for the ReplicationState const type.

type RestartParameter 

type RestartParameter struct {
	// Failover mode.
	FailoverMode *FailoverMode

	// Indicates whether to restart the server with failover.
	RestartWithFailover *bool
}

RestartParameter - Represents server restart parameters.

func (RestartParameter) MarshalJSON 

func (r RestartParameter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RestartParameter.

func (*RestartParameter) UnmarshalJSON 

func (r *RestartParameter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RestartParameter.

type RestrictedEnum 

type RestrictedEnum string

RestrictedEnum - A value indicating whether this region is restricted. "Enabled" means region is restricted. "Disabled" stands for region is not restricted. 

const (
	RestrictedEnumDisabled RestrictedEnum = "Disabled"
	RestrictedEnumEnabled  RestrictedEnum = "Enabled"
)

func PossibleRestrictedEnumValues 

func PossibleRestrictedEnumValues() []RestrictedEnum

PossibleRestrictedEnumValues returns the possible values for the RestrictedEnum const type.

type SKU 

type SKU struct {
	// REQUIRED; The name of the sku, typically, tier + family + cores, e.g. StandardD4sv3.
	Name *string

	// REQUIRED; The tier of the particular SKU, e.g. Burstable.
	Tier *SKUTier
}

SKU - Sku information related properties of a server.

func (SKU) MarshalJSON 

func (s SKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SKU.

func (*SKU) UnmarshalJSON 

func (s *SKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SKU.

type SKUTier 

type SKUTier string

SKUTier - The tier of the particular SKU, e.g. Burstable. 

const (
	SKUTierBurstable       SKUTier = "Burstable"
	SKUTierGeneralPurpose  SKUTier = "GeneralPurpose"
	SKUTierMemoryOptimized SKUTier = "MemoryOptimized"
)

func PossibleSKUTierValues 

func PossibleSKUTierValues() []SKUTier

PossibleSKUTierValues returns the possible values for the SKUTier const type.

type SSLMode 

type SSLMode string

SSLMode - Supported SSL modes for migration. VerifyFull is the recommended SSL mode for Single server migration. Prefer, Require are recommended SSL modes for other source types 

const (
	SSLModePrefer     SSLMode = "Prefer"
	SSLModeRequire    SSLMode = "Require"
	SSLModeVerifyCA   SSLMode = "VerifyCA"
	SSLModeVerifyFull SSLMode = "VerifyFull"
)

func PossibleSSLModeValues 

func PossibleSSLModeValues() []SSLMode

PossibleSSLModeValues returns the possible values for the SSLMode const type.

type Server 

type Server struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// Describes the identity of the application.
	Identity *UserAssignedIdentity

	// Properties of the server.
	Properties *ServerProperties

	// The SKU (pricing tier) of the server.
	SKU *SKU

	// 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
}

Server - Represents a server.

func (Server) MarshalJSON 

func (s Server) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Server.

func (*Server) UnmarshalJSON 

func (s *Server) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Server.

type ServerBackup 

type ServerBackup struct {
	// The properties of a server backup.
	Properties *ServerBackupProperties

	// 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
}

ServerBackup - Server backup properties

func (ServerBackup) MarshalJSON 

func (s ServerBackup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerBackup.

func (*ServerBackup) UnmarshalJSON 

func (s *ServerBackup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerBackup.

type ServerBackupListResult 

type ServerBackupListResult struct {
	// The link used to get the next page of operations.
	NextLink *string

	// The list of backups of a server.
	Value []*ServerBackup
}

ServerBackupListResult - A list of server backups.

func (ServerBackupListResult) MarshalJSON 

func (s ServerBackupListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerBackupListResult.

func (*ServerBackupListResult) UnmarshalJSON 

func (s *ServerBackupListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerBackupListResult.

type ServerBackupProperties 

type ServerBackupProperties struct {
	// Backup type.
	BackupType *Origin

	// Backup completed time (ISO8601 format).
	CompletedTime *time.Time

	// Backup source
	Source *string
}

ServerBackupProperties - The properties of a server backup.

func (ServerBackupProperties) MarshalJSON 

func (s ServerBackupProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerBackupProperties.

func (*ServerBackupProperties) UnmarshalJSON 

func (s *ServerBackupProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerBackupProperties.

type ServerCapabilitiesClient 

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

ServerCapabilitiesClient contains the methods for the ServerCapabilities group. Don't use this type directly, use NewServerCapabilitiesClient() instead.

func NewServerCapabilitiesClient 

func NewServerCapabilitiesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ServerCapabilitiesClient, error)

NewServerCapabilitiesClient creates a new instance of ServerCapabilitiesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ServerCapabilitiesClient) NewListPager 

func (client *ServerCapabilitiesClient) NewListPager(resourceGroupName string, serverName string, options *ServerCapabilitiesClientListOptions) *runtime.Pager[ServerCapabilitiesClientListResponse]

NewListPager - Get capabilities for a flexible server.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - ServerCapabilitiesClientListOptions contains the optional parameters for the ServerCapabilitiesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerCapabilities.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewServerCapabilitiesClient().NewListPager("testrg", "pgtestsvc4", 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.CapabilitiesListResult = armpostgresqlflexibleservers.CapabilitiesListResult{
	// 	Value: []*armpostgresqlflexibleservers.FlexibleServerCapability{
	// 		{
	// 			Name: to.Ptr("FlexibleServerCapabilities"),
	// 			FastProvisioningSupported: to.Ptr(armpostgresqlflexibleservers.FastProvisioningSupportedEnumEnabled),
	// 			GeoBackupSupported: to.Ptr(armpostgresqlflexibleservers.GeoBackupSupportedEnumEnabled),
	// 			OnlineResizeSupported: to.Ptr(armpostgresqlflexibleservers.OnlineResizeSupportedEnumDisabled),
	// 			Restricted: to.Ptr(armpostgresqlflexibleservers.RestrictedEnumDisabled),
	// 			StorageAutoGrowthSupported: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowthSupportedEnumEnabled),
	// 			SupportedFastProvisioningEditions: []*armpostgresqlflexibleservers.FastProvisioningEditionCapability{
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("12"),
	// 					SupportedSKU: to.Ptr("standard_b1ms"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("12"),
	// 					SupportedSKU: to.Ptr("standard_b2s"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("12"),
	// 					SupportedSKU: to.Ptr("standard_d2s_v3"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("12"),
	// 					SupportedSKU: to.Ptr("standard_d2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("12"),
	// 					SupportedSKU: to.Ptr("standard_e2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](512),
	// 					SupportedTier: to.Ptr("MemoryOptimized"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("13"),
	// 					SupportedSKU: to.Ptr("standard_b1ms"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("13"),
	// 					SupportedSKU: to.Ptr("standard_b2s"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("13"),
	// 					SupportedSKU: to.Ptr("standard_d2s_v3"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("13"),
	// 					SupportedSKU: to.Ptr("standard_d2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("13"),
	// 					SupportedSKU: to.Ptr("standard_e2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](512),
	// 					SupportedTier: to.Ptr("MemoryOptimized"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](23),
	// 					SupportedServerVersions: to.Ptr("14"),
	// 					SupportedSKU: to.Ptr("standard_b1ms"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("14"),
	// 					SupportedSKU: to.Ptr("standard_b2s"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("14"),
	// 					SupportedSKU: to.Ptr("standard_d2s_v3"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("14"),
	// 					SupportedSKU: to.Ptr("standard_d2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("14"),
	// 					SupportedSKU: to.Ptr("standard_e2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](512),
	// 					SupportedTier: to.Ptr("MemoryOptimized"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("15"),
	// 					SupportedSKU: to.Ptr("standard_b1ms"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("15"),
	// 					SupportedSKU: to.Ptr("standard_b2s"),
	// 					SupportedStorageGb: to.Ptr[int32](32),
	// 					SupportedTier: to.Ptr("Burstable"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("15"),
	// 					SupportedSKU: to.Ptr("standard_d2s_v3"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("15"),
	// 					SupportedSKU: to.Ptr("standard_d2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](128),
	// 					SupportedTier: to.Ptr("GeneralPurpose"),
	// 				},
	// 				{
	// 					ServerCount: to.Ptr[int32](0),
	// 					SupportedServerVersions: to.Ptr("15"),
	// 					SupportedSKU: to.Ptr("standard_e2ds_v4"),
	// 					SupportedStorageGb: to.Ptr[int32](512),
	// 					SupportedTier: to.Ptr("MemoryOptimized"),
	// 			}},
	// 			SupportedServerEditions: []*armpostgresqlflexibleservers.FlexibleServerEditionCapability{
	// 				{
	// 					Name: to.Ptr("Burstable"),
	// 					DefaultSKUName: to.Ptr("Standard_B1ms"),
	// 					SupportedServerSKUs: []*armpostgresqlflexibleservers.ServerSKUCapability{
	// 						{
	// 							Name: to.Ptr("Standard_B1ms"),
	// 							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 								SupportedIops: to.Ptr[int32](640),
	// 								SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 								SupportedZones: []*string{
	// 									to.Ptr("1"),
	// 									to.Ptr("2"),
	// 									to.Ptr("3")},
	// 									VCores: to.Ptr[int32](1),
	// 								},
	// 								{
	// 									Name: to.Ptr("Standard_B2s"),
	// 									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 										SupportedIops: to.Ptr[int32](1280),
	// 										SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 										SupportedZones: []*string{
	// 											to.Ptr("1"),
	// 											to.Ptr("2"),
	// 											to.Ptr("3")},
	// 											VCores: to.Ptr[int32](2),
	// 										},
	// 										{
	// 											Name: to.Ptr("Standard_B2ms"),
	// 											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 												SupportedIops: to.Ptr[int32](1700),
	// 												SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 												SupportedZones: []*string{
	// 													to.Ptr("1"),
	// 													to.Ptr("2"),
	// 													to.Ptr("3")},
	// 													VCores: to.Ptr[int32](2),
	// 												},
	// 												{
	// 													Name: to.Ptr("Standard_B4ms"),
	// 													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 														SupportedIops: to.Ptr[int32](2400),
	// 														SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 														SupportedZones: []*string{
	// 															to.Ptr("1"),
	// 															to.Ptr("2"),
	// 															to.Ptr("3")},
	// 															VCores: to.Ptr[int32](4),
	// 														},
	// 														{
	// 															Name: to.Ptr("Standard_B8ms"),
	// 															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																SupportedIops: to.Ptr[int32](3100),
	// 																SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 																SupportedZones: []*string{
	// 																	to.Ptr("1"),
	// 																	to.Ptr("2"),
	// 																	to.Ptr("3")},
	// 																	VCores: to.Ptr[int32](8),
	// 																},
	// 																{
	// 																	Name: to.Ptr("Standard_B12ms"),
	// 																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																		SupportedIops: to.Ptr[int32](3800),
	// 																		SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 																		SupportedZones: []*string{
	// 																			to.Ptr("1"),
	// 																			to.Ptr("2"),
	// 																			to.Ptr("3")},
	// 																			VCores: to.Ptr[int32](12),
	// 																		},
	// 																		{
	// 																			Name: to.Ptr("Standard_B16ms"),
	// 																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																				SupportedIops: to.Ptr[int32](4300),
	// 																				SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 																				SupportedZones: []*string{
	// 																					to.Ptr("1"),
	// 																					to.Ptr("2"),
	// 																					to.Ptr("3")},
	// 																					VCores: to.Ptr[int32](16),
	// 																				},
	// 																				{
	// 																					Name: to.Ptr("Standard_B20ms"),
	// 																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																						SupportedIops: to.Ptr[int32](5000),
	// 																						SupportedMemoryPerVcoreMb: to.Ptr[int64](2048),
	// 																						SupportedZones: []*string{
	// 																							to.Ptr("1"),
	// 																							to.Ptr("2"),
	// 																							to.Ptr("3")},
	// 																							VCores: to.Ptr[int32](20),
	// 																					}},
	// 																					SupportedStorageEditions: []*armpostgresqlflexibleservers.StorageEditionCapability{
	// 																						{
	// 																							Name: to.Ptr("ManagedDisk"),
	// 																							DefaultStorageSizeMb: to.Ptr[int64](32768),
	// 																							SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P4"),
	// 																									StorageSizeMb: to.Ptr[int64](32768),
	// 																									SupportedIops: to.Ptr[int32](120),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P4"),
	// 																											Iops: to.Ptr[int32](120),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P6"),
	// 																											Iops: to.Ptr[int32](240),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P10"),
	// 																											Iops: to.Ptr[int32](500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P15"),
	// 																											Iops: to.Ptr[int32](1100),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P20"),
	// 																											Iops: to.Ptr[int32](2300),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P6"),
	// 																									StorageSizeMb: to.Ptr[int64](65536),
	// 																									SupportedIops: to.Ptr[int32](240),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P6"),
	// 																											Iops: to.Ptr[int32](240),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P10"),
	// 																											Iops: to.Ptr[int32](500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P15"),
	// 																											Iops: to.Ptr[int32](1100),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P20"),
	// 																											Iops: to.Ptr[int32](2300),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P10"),
	// 																									StorageSizeMb: to.Ptr[int64](131072),
	// 																									SupportedIops: to.Ptr[int32](500),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P10"),
	// 																											Iops: to.Ptr[int32](500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P15"),
	// 																											Iops: to.Ptr[int32](1100),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P20"),
	// 																											Iops: to.Ptr[int32](2300),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P15"),
	// 																									StorageSizeMb: to.Ptr[int64](262144),
	// 																									SupportedIops: to.Ptr[int32](1100),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P15"),
	// 																											Iops: to.Ptr[int32](1100),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P20"),
	// 																											Iops: to.Ptr[int32](2300),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P20"),
	// 																									StorageSizeMb: to.Ptr[int64](524288),
	// 																									SupportedIops: to.Ptr[int32](2300),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P20"),
	// 																											Iops: to.Ptr[int32](2300),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P30"),
	// 																									StorageSizeMb: to.Ptr[int64](1048576),
	// 																									SupportedIops: to.Ptr[int32](5000),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P30"),
	// 																											Iops: to.Ptr[int32](5000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P40"),
	// 																									StorageSizeMb: to.Ptr[int64](2097152),
	// 																									SupportedIops: to.Ptr[int32](7500),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P40"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P50"),
	// 																									StorageSizeMb: to.Ptr[int64](4194304),
	// 																									SupportedIops: to.Ptr[int32](7500),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P50"),
	// 																											Iops: to.Ptr[int32](7500),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P60"),
	// 																									StorageSizeMb: to.Ptr[int64](8388608),
	// 																									SupportedIops: to.Ptr[int32](16000),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P60"),
	// 																											Iops: to.Ptr[int32](16000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P70"),
	// 																											Iops: to.Ptr[int32](18000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P80"),
	// 																											Iops: to.Ptr[int32](20000),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P70"),
	// 																									StorageSizeMb: to.Ptr[int64](16777216),
	// 																									SupportedIops: to.Ptr[int32](18000),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P70"),
	// 																											Iops: to.Ptr[int32](18000),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("P80"),
	// 																											Iops: to.Ptr[int32](20000),
	// 																									}},
	// 																								},
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("P80"),
	// 																									StorageSizeMb: to.Ptr[int64](33553408),
	// 																									SupportedIops: to.Ptr[int32](20000),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("P80"),
	// 																											Iops: to.Ptr[int32](20000),
	// 																									}},
	// 																							}},
	// 																						},
	// 																						{
	// 																							Name: to.Ptr("ManagedDiskV2"),
	// 																							DefaultStorageSizeMb: to.Ptr[int64](65536),
	// 																							SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																								{
	// 																									DefaultIopsTier: to.Ptr("None"),
	// 																									MaximumStorageSizeMb: to.Ptr[int64](67108864),
	// 																									StorageSizeMb: to.Ptr[int64](32768),
	// 																									SupportedIops: to.Ptr[int32](3000),
	// 																									SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																										{
	// 																											Name: to.Ptr("None"),
	// 																											Iops: to.Ptr[int32](0),
	// 																									}},
	// 																									SupportedMaximumIops: to.Ptr[int32](80000),
	// 																									SupportedMaximumThroughput: to.Ptr[int32](750),
	// 																									SupportedThroughput: to.Ptr[int32](125),
	// 																							}},
	// 																					}},
	// 																				},
	// 																				{
	// 																					Name: to.Ptr("GeneralPurpose"),
	// 																					DefaultSKUName: to.Ptr("Standard_D2ds_v4"),
	// 																					SupportedServerSKUs: []*armpostgresqlflexibleservers.ServerSKUCapability{
	// 																						{
	// 																							Name: to.Ptr("Standard_D2s_v3"),
	// 																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																								SupportedIops: to.Ptr[int32](3200),
	// 																								SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																								SupportedZones: []*string{
	// 																									to.Ptr("1"),
	// 																									to.Ptr("2"),
	// 																									to.Ptr("3")},
	// 																									VCores: to.Ptr[int32](2),
	// 																								},
	// 																								{
	// 																									Name: to.Ptr("Standard_D4s_v3"),
	// 																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																										SupportedIops: to.Ptr[int32](6400),
	// 																										SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																										SupportedZones: []*string{
	// 																											to.Ptr("1"),
	// 																											to.Ptr("2"),
	// 																											to.Ptr("3")},
	// 																											VCores: to.Ptr[int32](4),
	// 																										},
	// 																										{
	// 																											Name: to.Ptr("Standard_D8s_v3"),
	// 																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																												SupportedIops: to.Ptr[int32](12800),
	// 																												SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																												SupportedZones: []*string{
	// 																													to.Ptr("1"),
	// 																													to.Ptr("2"),
	// 																													to.Ptr("3")},
	// 																													VCores: to.Ptr[int32](8),
	// 																												},
	// 																												{
	// 																													Name: to.Ptr("Standard_D16s_v3"),
	// 																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																														SupportedIops: to.Ptr[int32](20000),
	// 																														SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																														SupportedZones: []*string{
	// 																															to.Ptr("1"),
	// 																															to.Ptr("2"),
	// 																															to.Ptr("3")},
	// 																															VCores: to.Ptr[int32](16),
	// 																														},
	// 																														{
	// 																															Name: to.Ptr("Standard_D32s_v3"),
	// 																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																SupportedIops: to.Ptr[int32](20000),
	// 																																SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																SupportedZones: []*string{
	// 																																	to.Ptr("1"),
	// 																																	to.Ptr("2"),
	// 																																	to.Ptr("3")},
	// 																																	VCores: to.Ptr[int32](32),
	// 																																},
	// 																																{
	// 																																	Name: to.Ptr("Standard_D48s_v3"),
	// 																																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																		SupportedIops: to.Ptr[int32](20000),
	// 																																		SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																		SupportedZones: []*string{
	// 																																			to.Ptr("1"),
	// 																																			to.Ptr("2"),
	// 																																			to.Ptr("3")},
	// 																																			VCores: to.Ptr[int32](48),
	// 																																		},
	// 																																		{
	// 																																			Name: to.Ptr("Standard_D64s_v3"),
	// 																																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																				SupportedIops: to.Ptr[int32](20000),
	// 																																				SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																				SupportedZones: []*string{
	// 																																					to.Ptr("1"),
	// 																																					to.Ptr("2"),
	// 																																					to.Ptr("3")},
	// 																																					VCores: to.Ptr[int32](64),
	// 																																				},
	// 																																				{
	// 																																					Name: to.Ptr("Standard_D2ds_v4"),
	// 																																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																						SupportedIops: to.Ptr[int32](3200),
	// 																																						SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																						SupportedZones: []*string{
	// 																																							to.Ptr("1"),
	// 																																							to.Ptr("2"),
	// 																																							to.Ptr("3")},
	// 																																							VCores: to.Ptr[int32](2),
	// 																																						},
	// 																																						{
	// 																																							Name: to.Ptr("Standard_D4ds_v4"),
	// 																																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																								SupportedIops: to.Ptr[int32](6400),
	// 																																								SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																								SupportedZones: []*string{
	// 																																									to.Ptr("1"),
	// 																																									to.Ptr("2"),
	// 																																									to.Ptr("3")},
	// 																																									VCores: to.Ptr[int32](4),
	// 																																								},
	// 																																								{
	// 																																									Name: to.Ptr("Standard_D8ds_v4"),
	// 																																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																										SupportedIops: to.Ptr[int32](12800),
	// 																																										SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																										SupportedZones: []*string{
	// 																																											to.Ptr("1"),
	// 																																											to.Ptr("2"),
	// 																																											to.Ptr("3")},
	// 																																											VCores: to.Ptr[int32](8),
	// 																																										},
	// 																																										{
	// 																																											Name: to.Ptr("Standard_D16ds_v4"),
	// 																																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																												SupportedIops: to.Ptr[int32](20000),
	// 																																												SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																												SupportedZones: []*string{
	// 																																													to.Ptr("1"),
	// 																																													to.Ptr("2"),
	// 																																													to.Ptr("3")},
	// 																																													VCores: to.Ptr[int32](16),
	// 																																												},
	// 																																												{
	// 																																													Name: to.Ptr("Standard_D32ds_v4"),
	// 																																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																														SupportedIops: to.Ptr[int32](20000),
	// 																																														SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																														SupportedZones: []*string{
	// 																																															to.Ptr("1"),
	// 																																															to.Ptr("2"),
	// 																																															to.Ptr("3")},
	// 																																															VCores: to.Ptr[int32](32),
	// 																																														},
	// 																																														{
	// 																																															Name: to.Ptr("Standard_D48ds_v4"),
	// 																																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																SupportedIops: to.Ptr[int32](20000),
	// 																																																SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																SupportedZones: []*string{
	// 																																																	to.Ptr("1"),
	// 																																																	to.Ptr("2"),
	// 																																																	to.Ptr("3")},
	// 																																																	VCores: to.Ptr[int32](48),
	// 																																																},
	// 																																																{
	// 																																																	Name: to.Ptr("Standard_D64ds_v4"),
	// 																																																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																		SupportedIops: to.Ptr[int32](20000),
	// 																																																		SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																		SupportedZones: []*string{
	// 																																																			to.Ptr("1"),
	// 																																																			to.Ptr("2"),
	// 																																																			to.Ptr("3")},
	// 																																																			VCores: to.Ptr[int32](64),
	// 																																																		},
	// 																																																		{
	// 																																																			Name: to.Ptr("Standard_D2ads_v5"),
	// 																																																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																				SupportedIops: to.Ptr[int32](3200),
	// 																																																				SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																				SupportedZones: []*string{
	// 																																																					to.Ptr("1"),
	// 																																																					to.Ptr("2"),
	// 																																																					to.Ptr("3")},
	// 																																																					VCores: to.Ptr[int32](2),
	// 																																																				},
	// 																																																				{
	// 																																																					Name: to.Ptr("Standard_D4ads_v5"),
	// 																																																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																						SupportedIops: to.Ptr[int32](6400),
	// 																																																						SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																						SupportedZones: []*string{
	// 																																																							to.Ptr("1"),
	// 																																																							to.Ptr("2"),
	// 																																																							to.Ptr("3")},
	// 																																																							VCores: to.Ptr[int32](4),
	// 																																																						},
	// 																																																						{
	// 																																																							Name: to.Ptr("Standard_D8ads_v5"),
	// 																																																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																								SupportedIops: to.Ptr[int32](12800),
	// 																																																								SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																								SupportedZones: []*string{
	// 																																																									to.Ptr("1"),
	// 																																																									to.Ptr("2"),
	// 																																																									to.Ptr("3")},
	// 																																																									VCores: to.Ptr[int32](8),
	// 																																																								},
	// 																																																								{
	// 																																																									Name: to.Ptr("Standard_D16ads_v5"),
	// 																																																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																										SupportedIops: to.Ptr[int32](20000),
	// 																																																										SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																										SupportedZones: []*string{
	// 																																																											to.Ptr("1"),
	// 																																																											to.Ptr("2"),
	// 																																																											to.Ptr("3")},
	// 																																																											VCores: to.Ptr[int32](16),
	// 																																																										},
	// 																																																										{
	// 																																																											Name: to.Ptr("Standard_D32ads_v5"),
	// 																																																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																												SupportedIops: to.Ptr[int32](20000),
	// 																																																												SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																												SupportedZones: []*string{
	// 																																																													to.Ptr("1"),
	// 																																																													to.Ptr("2"),
	// 																																																													to.Ptr("3")},
	// 																																																													VCores: to.Ptr[int32](32),
	// 																																																												},
	// 																																																												{
	// 																																																													Name: to.Ptr("Standard_D48ads_v5"),
	// 																																																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																														SupportedIops: to.Ptr[int32](20000),
	// 																																																														SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																														SupportedZones: []*string{
	// 																																																															to.Ptr("1"),
	// 																																																															to.Ptr("2"),
	// 																																																															to.Ptr("3")},
	// 																																																															VCores: to.Ptr[int32](48),
	// 																																																														},
	// 																																																														{
	// 																																																															Name: to.Ptr("Standard_D64ads_v5"),
	// 																																																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																SupportedIops: to.Ptr[int32](20000),
	// 																																																																SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																																SupportedZones: []*string{
	// 																																																																	to.Ptr("1"),
	// 																																																																	to.Ptr("2"),
	// 																																																																	to.Ptr("3")},
	// 																																																																	VCores: to.Ptr[int32](64),
	// 																																																																},
	// 																																																																{
	// 																																																																	Name: to.Ptr("Standard_D96ads_v5"),
	// 																																																																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																		SupportedIops: to.Ptr[int32](20000),
	// 																																																																		SupportedMemoryPerVcoreMb: to.Ptr[int64](4096),
	// 																																																																		SupportedZones: []*string{
	// 																																																																			to.Ptr("1"),
	// 																																																																			to.Ptr("2"),
	// 																																																																			to.Ptr("3")},
	// 																																																																			VCores: to.Ptr[int32](96),
	// 																																																																	}},
	// 																																																																	SupportedStorageEditions: []*armpostgresqlflexibleservers.StorageEditionCapability{
	// 																																																																		{
	// 																																																																			Name: to.Ptr("ManagedDisk"),
	// 																																																																			DefaultStorageSizeMb: to.Ptr[int64](65536),
	// 																																																																			SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P4"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](32768),
	// 																																																																					SupportedIops: to.Ptr[int32](120),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P4"),
	// 																																																																							Iops: to.Ptr[int32](120),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P6"),
	// 																																																																							Iops: to.Ptr[int32](240),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P10"),
	// 																																																																							Iops: to.Ptr[int32](500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P15"),
	// 																																																																							Iops: to.Ptr[int32](1100),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P20"),
	// 																																																																							Iops: to.Ptr[int32](2300),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P6"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](65536),
	// 																																																																					SupportedIops: to.Ptr[int32](240),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P6"),
	// 																																																																							Iops: to.Ptr[int32](240),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P10"),
	// 																																																																							Iops: to.Ptr[int32](500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P15"),
	// 																																																																							Iops: to.Ptr[int32](1100),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P20"),
	// 																																																																							Iops: to.Ptr[int32](2300),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P10"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](131072),
	// 																																																																					SupportedIops: to.Ptr[int32](500),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P10"),
	// 																																																																							Iops: to.Ptr[int32](500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P15"),
	// 																																																																							Iops: to.Ptr[int32](1100),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P20"),
	// 																																																																							Iops: to.Ptr[int32](2300),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P15"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](262144),
	// 																																																																					SupportedIops: to.Ptr[int32](1100),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P15"),
	// 																																																																							Iops: to.Ptr[int32](1100),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P20"),
	// 																																																																							Iops: to.Ptr[int32](2300),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P20"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](524288),
	// 																																																																					SupportedIops: to.Ptr[int32](2300),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P20"),
	// 																																																																							Iops: to.Ptr[int32](2300),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P30"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](1048576),
	// 																																																																					SupportedIops: to.Ptr[int32](5000),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P30"),
	// 																																																																							Iops: to.Ptr[int32](5000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P40"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](2097152),
	// 																																																																					SupportedIops: to.Ptr[int32](7500),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P40"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P50"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](4194304),
	// 																																																																					SupportedIops: to.Ptr[int32](7500),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P50"),
	// 																																																																							Iops: to.Ptr[int32](7500),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P60"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](8388608),
	// 																																																																					SupportedIops: to.Ptr[int32](16000),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P60"),
	// 																																																																							Iops: to.Ptr[int32](16000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P70"),
	// 																																																																							Iops: to.Ptr[int32](18000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P80"),
	// 																																																																							Iops: to.Ptr[int32](20000),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P70"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](16777216),
	// 																																																																					SupportedIops: to.Ptr[int32](18000),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P70"),
	// 																																																																							Iops: to.Ptr[int32](18000),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P80"),
	// 																																																																							Iops: to.Ptr[int32](20000),
	// 																																																																					}},
	// 																																																																				},
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("P80"),
	// 																																																																					StorageSizeMb: to.Ptr[int64](33553408),
	// 																																																																					SupportedIops: to.Ptr[int32](20000),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("P80"),
	// 																																																																							Iops: to.Ptr[int32](20000),
	// 																																																																					}},
	// 																																																																			}},
	// 																																																																		},
	// 																																																																		{
	// 																																																																			Name: to.Ptr("ManagedDiskV2"),
	// 																																																																			DefaultStorageSizeMb: to.Ptr[int64](65536),
	// 																																																																			SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																																																																				{
	// 																																																																					DefaultIopsTier: to.Ptr("None"),
	// 																																																																					MaximumStorageSizeMb: to.Ptr[int64](67108864),
	// 																																																																					StorageSizeMb: to.Ptr[int64](32768),
	// 																																																																					SupportedIops: to.Ptr[int32](3000),
	// 																																																																					SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																						{
	// 																																																																							Name: to.Ptr("None"),
	// 																																																																							Iops: to.Ptr[int32](0),
	// 																																																																					}},
	// 																																																																					SupportedMaximumIops: to.Ptr[int32](80000),
	// 																																																																					SupportedMaximumThroughput: to.Ptr[int32](750),
	// 																																																																					SupportedThroughput: to.Ptr[int32](125),
	// 																																																																			}},
	// 																																																																	}},
	// 																																																																},
	// 																																																																{
	// 																																																																	Name: to.Ptr("MemoryOptimized"),
	// 																																																																	DefaultSKUName: to.Ptr("Standard_E2ds_v4"),
	// 																																																																	SupportedServerSKUs: []*armpostgresqlflexibleservers.ServerSKUCapability{
	// 																																																																		{
	// 																																																																			Name: to.Ptr("Standard_E2s_v3"),
	// 																																																																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																				SupportedIops: to.Ptr[int32](3200),
	// 																																																																				SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																				SupportedZones: []*string{
	// 																																																																					to.Ptr("1"),
	// 																																																																					to.Ptr("2"),
	// 																																																																					to.Ptr("3")},
	// 																																																																					VCores: to.Ptr[int32](2),
	// 																																																																				},
	// 																																																																				{
	// 																																																																					Name: to.Ptr("Standard_E4s_v3"),
	// 																																																																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																						SupportedIops: to.Ptr[int32](6400),
	// 																																																																						SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																						SupportedZones: []*string{
	// 																																																																							to.Ptr("1"),
	// 																																																																							to.Ptr("2"),
	// 																																																																							to.Ptr("3")},
	// 																																																																							VCores: to.Ptr[int32](4),
	// 																																																																						},
	// 																																																																						{
	// 																																																																							Name: to.Ptr("Standard_E8s_v3"),
	// 																																																																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																								SupportedIops: to.Ptr[int32](12800),
	// 																																																																								SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																								SupportedZones: []*string{
	// 																																																																									to.Ptr("1"),
	// 																																																																									to.Ptr("2"),
	// 																																																																									to.Ptr("3")},
	// 																																																																									VCores: to.Ptr[int32](8),
	// 																																																																								},
	// 																																																																								{
	// 																																																																									Name: to.Ptr("Standard_E16s_v3"),
	// 																																																																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																										SupportedIops: to.Ptr[int32](20000),
	// 																																																																										SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																										SupportedZones: []*string{
	// 																																																																											to.Ptr("1"),
	// 																																																																											to.Ptr("2"),
	// 																																																																											to.Ptr("3")},
	// 																																																																											VCores: to.Ptr[int32](16),
	// 																																																																										},
	// 																																																																										{
	// 																																																																											Name: to.Ptr("Standard_E32s_v3"),
	// 																																																																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																												SupportedIops: to.Ptr[int32](20000),
	// 																																																																												SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																												SupportedZones: []*string{
	// 																																																																													to.Ptr("1"),
	// 																																																																													to.Ptr("2"),
	// 																																																																													to.Ptr("3")},
	// 																																																																													VCores: to.Ptr[int32](32),
	// 																																																																												},
	// 																																																																												{
	// 																																																																													Name: to.Ptr("Standard_E48s_v3"),
	// 																																																																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																														SupportedIops: to.Ptr[int32](20000),
	// 																																																																														SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																														SupportedZones: []*string{
	// 																																																																															to.Ptr("1"),
	// 																																																																															to.Ptr("2"),
	// 																																																																															to.Ptr("3")},
	// 																																																																															VCores: to.Ptr[int32](48),
	// 																																																																														},
	// 																																																																														{
	// 																																																																															Name: to.Ptr("Standard_E64s_v3"),
	// 																																																																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																SupportedIops: to.Ptr[int32](20000),
	// 																																																																																SupportedMemoryPerVcoreMb: to.Ptr[int64](6912),
	// 																																																																																SupportedZones: []*string{
	// 																																																																																	to.Ptr("1"),
	// 																																																																																	to.Ptr("2"),
	// 																																																																																	to.Ptr("3")},
	// 																																																																																	VCores: to.Ptr[int32](64),
	// 																																																																																},
	// 																																																																																{
	// 																																																																																	Name: to.Ptr("Standard_E2ds_v4"),
	// 																																																																																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																		SupportedIops: to.Ptr[int32](3200),
	// 																																																																																		SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																		SupportedZones: []*string{
	// 																																																																																			to.Ptr("1"),
	// 																																																																																			to.Ptr("2"),
	// 																																																																																			to.Ptr("3")},
	// 																																																																																			VCores: to.Ptr[int32](2),
	// 																																																																																		},
	// 																																																																																		{
	// 																																																																																			Name: to.Ptr("Standard_E4ds_v4"),
	// 																																																																																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																				SupportedIops: to.Ptr[int32](6400),
	// 																																																																																				SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																				SupportedZones: []*string{
	// 																																																																																					to.Ptr("1"),
	// 																																																																																					to.Ptr("2"),
	// 																																																																																					to.Ptr("3")},
	// 																																																																																					VCores: to.Ptr[int32](4),
	// 																																																																																				},
	// 																																																																																				{
	// 																																																																																					Name: to.Ptr("Standard_E8ds_v4"),
	// 																																																																																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																						SupportedIops: to.Ptr[int32](12800),
	// 																																																																																						SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																						SupportedZones: []*string{
	// 																																																																																							to.Ptr("1"),
	// 																																																																																							to.Ptr("2"),
	// 																																																																																							to.Ptr("3")},
	// 																																																																																							VCores: to.Ptr[int32](8),
	// 																																																																																						},
	// 																																																																																						{
	// 																																																																																							Name: to.Ptr("Standard_E16ds_v4"),
	// 																																																																																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																								SupportedIops: to.Ptr[int32](20000),
	// 																																																																																								SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																								SupportedZones: []*string{
	// 																																																																																									to.Ptr("1"),
	// 																																																																																									to.Ptr("2"),
	// 																																																																																									to.Ptr("3")},
	// 																																																																																									VCores: to.Ptr[int32](16),
	// 																																																																																								},
	// 																																																																																								{
	// 																																																																																									Name: to.Ptr("Standard_E20ds_v4"),
	// 																																																																																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																										SupportedIops: to.Ptr[int32](20000),
	// 																																																																																										SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																										SupportedZones: []*string{
	// 																																																																																											to.Ptr("1"),
	// 																																																																																											to.Ptr("2"),
	// 																																																																																											to.Ptr("3")},
	// 																																																																																											VCores: to.Ptr[int32](20),
	// 																																																																																										},
	// 																																																																																										{
	// 																																																																																											Name: to.Ptr("Standard_E32ds_v4"),
	// 																																																																																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																												SupportedIops: to.Ptr[int32](20000),
	// 																																																																																												SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																												SupportedZones: []*string{
	// 																																																																																													to.Ptr("1"),
	// 																																																																																													to.Ptr("2"),
	// 																																																																																													to.Ptr("3")},
	// 																																																																																													VCores: to.Ptr[int32](32),
	// 																																																																																												},
	// 																																																																																												{
	// 																																																																																													Name: to.Ptr("Standard_E48ds_v4"),
	// 																																																																																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																														SupportedIops: to.Ptr[int32](20000),
	// 																																																																																														SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																														SupportedZones: []*string{
	// 																																																																																															to.Ptr("1"),
	// 																																																																																															to.Ptr("2"),
	// 																																																																																															to.Ptr("3")},
	// 																																																																																															VCores: to.Ptr[int32](48),
	// 																																																																																														},
	// 																																																																																														{
	// 																																																																																															Name: to.Ptr("Standard_E64ds_v4"),
	// 																																																																																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																SupportedMemoryPerVcoreMb: to.Ptr[int64](6912),
	// 																																																																																																SupportedZones: []*string{
	// 																																																																																																	to.Ptr("1"),
	// 																																																																																																	to.Ptr("2"),
	// 																																																																																																	to.Ptr("3")},
	// 																																																																																																	VCores: to.Ptr[int32](64),
	// 																																																																																																},
	// 																																																																																																{
	// 																																																																																																	Name: to.Ptr("Standard_E2ads_v5"),
	// 																																																																																																	SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																		to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																		SupportedIops: to.Ptr[int32](3200),
	// 																																																																																																		SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																		SupportedZones: []*string{
	// 																																																																																																			to.Ptr("1"),
	// 																																																																																																			to.Ptr("2"),
	// 																																																																																																			to.Ptr("3")},
	// 																																																																																																			VCores: to.Ptr[int32](2),
	// 																																																																																																		},
	// 																																																																																																		{
	// 																																																																																																			Name: to.Ptr("Standard_E4ads_v5"),
	// 																																																																																																			SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																				to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																				SupportedIops: to.Ptr[int32](6400),
	// 																																																																																																				SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																				SupportedZones: []*string{
	// 																																																																																																					to.Ptr("1"),
	// 																																																																																																					to.Ptr("2"),
	// 																																																																																																					to.Ptr("3")},
	// 																																																																																																					VCores: to.Ptr[int32](4),
	// 																																																																																																				},
	// 																																																																																																				{
	// 																																																																																																					Name: to.Ptr("Standard_E8ads_v5"),
	// 																																																																																																					SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																						to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																						SupportedIops: to.Ptr[int32](12800),
	// 																																																																																																						SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																						SupportedZones: []*string{
	// 																																																																																																							to.Ptr("1"),
	// 																																																																																																							to.Ptr("2"),
	// 																																																																																																							to.Ptr("3")},
	// 																																																																																																							VCores: to.Ptr[int32](8),
	// 																																																																																																						},
	// 																																																																																																						{
	// 																																																																																																							Name: to.Ptr("Standard_E16ads_v5"),
	// 																																																																																																							SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																								to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																								SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																								SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																								SupportedZones: []*string{
	// 																																																																																																									to.Ptr("1"),
	// 																																																																																																									to.Ptr("2"),
	// 																																																																																																									to.Ptr("3")},
	// 																																																																																																									VCores: to.Ptr[int32](16),
	// 																																																																																																								},
	// 																																																																																																								{
	// 																																																																																																									Name: to.Ptr("Standard_E32ads_v5"),
	// 																																																																																																									SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																										to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																										SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																										SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																										SupportedZones: []*string{
	// 																																																																																																											to.Ptr("1"),
	// 																																																																																																											to.Ptr("2"),
	// 																																																																																																											to.Ptr("3")},
	// 																																																																																																											VCores: to.Ptr[int32](32),
	// 																																																																																																										},
	// 																																																																																																										{
	// 																																																																																																											Name: to.Ptr("Standard_E48ads_v5"),
	// 																																																																																																											SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																												to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																												SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																												SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																												SupportedZones: []*string{
	// 																																																																																																													to.Ptr("1"),
	// 																																																																																																													to.Ptr("2"),
	// 																																																																																																													to.Ptr("3")},
	// 																																																																																																													VCores: to.Ptr[int32](48),
	// 																																																																																																												},
	// 																																																																																																												{
	// 																																																																																																													Name: to.Ptr("Standard_E64ads_v5"),
	// 																																																																																																													SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																														to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																														SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																														SupportedMemoryPerVcoreMb: to.Ptr[int64](8192),
	// 																																																																																																														SupportedZones: []*string{
	// 																																																																																																															to.Ptr("1"),
	// 																																																																																																															to.Ptr("2"),
	// 																																																																																																															to.Ptr("3")},
	// 																																																																																																															VCores: to.Ptr[int32](64),
	// 																																																																																																														},
	// 																																																																																																														{
	// 																																																																																																															Name: to.Ptr("Standard_E96ads_v5"),
	// 																																																																																																															SupportedHaMode: []*armpostgresqlflexibleservers.HaMode{
	// 																																																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeSameZone),
	// 																																																																																																																to.Ptr(armpostgresqlflexibleservers.HaModeZoneRedundant)},
	// 																																																																																																																SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																																SupportedMemoryPerVcoreMb: to.Ptr[int64](7168),
	// 																																																																																																																SupportedZones: []*string{
	// 																																																																																																																	to.Ptr("1"),
	// 																																																																																																																	to.Ptr("2"),
	// 																																																																																																																	to.Ptr("3")},
	// 																																																																																																																	VCores: to.Ptr[int32](96),
	// 																																																																																																															}},
	// 																																																																																																															SupportedStorageEditions: []*armpostgresqlflexibleservers.StorageEditionCapability{
	// 																																																																																																																{
	// 																																																																																																																	Name: to.Ptr("ManagedDisk"),
	// 																																																																																																																	DefaultStorageSizeMb: to.Ptr[int64](131072),
	// 																																																																																																																	SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P4"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](32768),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](120),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P4"),
	// 																																																																																																																					Iops: to.Ptr[int32](120),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P6"),
	// 																																																																																																																					Iops: to.Ptr[int32](240),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P10"),
	// 																																																																																																																					Iops: to.Ptr[int32](500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P15"),
	// 																																																																																																																					Iops: to.Ptr[int32](1100),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P20"),
	// 																																																																																																																					Iops: to.Ptr[int32](2300),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P6"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](65536),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](240),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P6"),
	// 																																																																																																																					Iops: to.Ptr[int32](240),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P10"),
	// 																																																																																																																					Iops: to.Ptr[int32](500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P15"),
	// 																																																																																																																					Iops: to.Ptr[int32](1100),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P20"),
	// 																																																																																																																					Iops: to.Ptr[int32](2300),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P10"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](131072),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](500),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P10"),
	// 																																																																																																																					Iops: to.Ptr[int32](500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P15"),
	// 																																																																																																																					Iops: to.Ptr[int32](1100),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P20"),
	// 																																																																																																																					Iops: to.Ptr[int32](2300),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P15"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](262144),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](1100),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P15"),
	// 																																																																																																																					Iops: to.Ptr[int32](1100),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P20"),
	// 																																																																																																																					Iops: to.Ptr[int32](2300),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P20"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](524288),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](2300),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P20"),
	// 																																																																																																																					Iops: to.Ptr[int32](2300),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P30"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](1048576),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](5000),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P30"),
	// 																																																																																																																					Iops: to.Ptr[int32](5000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P40"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](2097152),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](7500),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P40"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P50"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](4194304),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](7500),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P50"),
	// 																																																																																																																					Iops: to.Ptr[int32](7500),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P60"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](8388608),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](16000),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P60"),
	// 																																																																																																																					Iops: to.Ptr[int32](16000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P70"),
	// 																																																																																																																					Iops: to.Ptr[int32](18000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P80"),
	// 																																																																																																																					Iops: to.Ptr[int32](20000),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P70"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](16777216),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](18000),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P70"),
	// 																																																																																																																					Iops: to.Ptr[int32](18000),
	// 																																																																																																																				},
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P80"),
	// 																																																																																																																					Iops: to.Ptr[int32](20000),
	// 																																																																																																																			}},
	// 																																																																																																																		},
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("P80"),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](33553408),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](20000),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("P80"),
	// 																																																																																																																					Iops: to.Ptr[int32](20000),
	// 																																																																																																																			}},
	// 																																																																																																																	}},
	// 																																																																																																																},
	// 																																																																																																																{
	// 																																																																																																																	Name: to.Ptr("ManagedDiskV2"),
	// 																																																																																																																	DefaultStorageSizeMb: to.Ptr[int64](65536),
	// 																																																																																																																	SupportedStorageMb: []*armpostgresqlflexibleservers.StorageMbCapability{
	// 																																																																																																																		{
	// 																																																																																																																			DefaultIopsTier: to.Ptr("None"),
	// 																																																																																																																			MaximumStorageSizeMb: to.Ptr[int64](67108864),
	// 																																																																																																																			StorageSizeMb: to.Ptr[int64](32768),
	// 																																																																																																																			SupportedIops: to.Ptr[int32](3000),
	// 																																																																																																																			SupportedIopsTiers: []*armpostgresqlflexibleservers.StorageTierCapability{
	// 																																																																																																																				{
	// 																																																																																																																					Name: to.Ptr("None"),
	// 																																																																																																																					Iops: to.Ptr[int32](0),
	// 																																																																																																																			}},
	// 																																																																																																																			SupportedMaximumIops: to.Ptr[int32](80000),
	// 																																																																																																																			SupportedMaximumThroughput: to.Ptr[int32](750),
	// 																																																																																																																			SupportedThroughput: to.Ptr[int32](125),
	// 																																																																																																																	}},
	// 																																																																																																															}},
	// 																																																																																																													}},
	// 																																																																																																													SupportedServerVersions: []*armpostgresqlflexibleservers.ServerVersionCapability{
	// 																																																																																																														{
	// 																																																																																																															Name: to.Ptr("11"),
	// 																																																																																																															SupportedVersionsToUpgrade: []*string{
	// 																																																																																																																to.Ptr("12"),
	// 																																																																																																																to.Ptr("13"),
	// 																																																																																																																to.Ptr("14"),
	// 																																																																																																																to.Ptr("15")},
	// 																																																																																																															},
	// 																																																																																																															{
	// 																																																																																																																Name: to.Ptr("12"),
	// 																																																																																																																SupportedVersionsToUpgrade: []*string{
	// 																																																																																																																	to.Ptr("13"),
	// 																																																																																																																	to.Ptr("14"),
	// 																																																																																																																	to.Ptr("15")},
	// 																																																																																																																},
	// 																																																																																																																{
	// 																																																																																																																	Name: to.Ptr("13"),
	// 																																																																																																																	SupportedVersionsToUpgrade: []*string{
	// 																																																																																																																		to.Ptr("14"),
	// 																																																																																																																		to.Ptr("15")},
	// 																																																																																																																	},
	// 																																																																																																																	{
	// 																																																																																																																		Name: to.Ptr("14"),
	// 																																																																																																																		SupportedVersionsToUpgrade: []*string{
	// 																																																																																																																			to.Ptr("15")},
	// 																																																																																																																	}},
	// 																																																																																																																	ZoneRedundantHaAndGeoBackupSupported: to.Ptr(armpostgresqlflexibleservers.ZoneRedundantHaAndGeoBackupSupportedEnumEnabled),
	// 																																																																																																																	ZoneRedundantHaSupported: to.Ptr(armpostgresqlflexibleservers.ZoneRedundantHaSupportedEnumEnabled),
	// 																																																																																																															}},
	// 																																																																																																														}
}

Output:

type ServerCapabilitiesClientListOptions 

type ServerCapabilitiesClientListOptions struct {
}

ServerCapabilitiesClientListOptions contains the optional parameters for the ServerCapabilitiesClient.NewListPager method.

type ServerCapabilitiesClientListResponse 

type ServerCapabilitiesClientListResponse struct {
	// Capability for the PostgreSQL server
	CapabilitiesListResult
}

ServerCapabilitiesClientListResponse contains the response from method ServerCapabilitiesClient.NewListPager.

type ServerForUpdate 

type ServerForUpdate struct {
	// Describes the identity of the application.
	Identity *UserAssignedIdentity

	// Properties of the server.
	Properties *ServerPropertiesForUpdate

	// The SKU (pricing tier) of the server.
	SKU *SKU

	// Application-specific metadata in the form of key-value pairs.
	Tags map[string]*string
}

ServerForUpdate - Represents a server to be updated.

func (ServerForUpdate) MarshalJSON 

func (s ServerForUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerForUpdate.

func (*ServerForUpdate) UnmarshalJSON 

func (s *ServerForUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerForUpdate.

type ServerHAState 

type ServerHAState string

ServerHAState - A state of a HA server that is visible to user. 

const (
	ServerHAStateCreatingStandby ServerHAState = "CreatingStandby"
	ServerHAStateFailingOver     ServerHAState = "FailingOver"
	ServerHAStateHealthy         ServerHAState = "Healthy"
	ServerHAStateNotEnabled      ServerHAState = "NotEnabled"
	ServerHAStateRemovingStandby ServerHAState = "RemovingStandby"
	ServerHAStateReplicatingData ServerHAState = "ReplicatingData"
)

func PossibleServerHAStateValues 

func PossibleServerHAStateValues() []ServerHAState

PossibleServerHAStateValues returns the possible values for the ServerHAState const type.

type ServerListResult 

type ServerListResult struct {
	// The link used to get the next page of operations.
	NextLink *string

	// The list of flexible servers
	Value []*Server
}

ServerListResult - A list of servers.

func (ServerListResult) MarshalJSON 

func (s ServerListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerListResult.

func (*ServerListResult) UnmarshalJSON 

func (s *ServerListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerListResult.

type ServerProperties 

type ServerProperties struct {
	// The administrator's login name of a server. Can only be specified when the server is being created (and is required for
	// creation).
	AdministratorLogin *string

	// The administrator login password (required for server creation).
	AdministratorLoginPassword *string

	// AuthConfig properties of a server.
	AuthConfig *AuthConfig

	// availability zone information of the server.
	AvailabilityZone *string

	// Backup properties of a server.
	Backup *Backup

	// The mode to create a new PostgreSQL server.
	CreateMode *CreateMode

	// Data encryption properties of a server.
	DataEncryption *DataEncryption

	// High availability properties of a server.
	HighAvailability *HighAvailability

	// Maintenance window properties of a server.
	MaintenanceWindow *MaintenanceWindow

	// Network properties of a server. This Network property is required to be passed only in case you want the server to be Private
	// access server.
	Network *Network

	// Restore point creation time (ISO8601 format), specifying the time to restore from. It's required when 'createMode' is 'PointInTimeRestore'
	// or 'GeoRestore' or 'ReviveDropped'.
	PointInTimeUTC *time.Time

	// Replica properties of a server. These Replica properties are required to be passed only in case you want to Promote a server.
	Replica *Replica

	// Replication role of the server
	ReplicationRole *ReplicationRole

	// The source server resource ID to restore from. It's required when 'createMode' is 'PointInTimeRestore' or 'GeoRestore'
	// or 'Replica' or 'ReviveDropped'. This property is returned only for Replica
	// server
	SourceServerResourceID *string

	// Storage properties of a server.
	Storage *Storage

	// PostgreSQL Server version.
	Version *ServerVersion

	// READ-ONLY; The fully qualified domain name of a server.
	FullyQualifiedDomainName *string

	// READ-ONLY; The minor version of the server.
	MinorVersion *string

	// READ-ONLY; List of private endpoint connections associated with the specified resource.
	PrivateEndpointConnections []*PrivateEndpointConnection

	// READ-ONLY; Replicas allowed for a server.
	ReplicaCapacity *int32

	// READ-ONLY; A state of a server that is visible to user.
	State *ServerState
}

ServerProperties - The properties of a server.

func (ServerProperties) MarshalJSON 

func (s ServerProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerProperties.

func (*ServerProperties) UnmarshalJSON 

func (s *ServerProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerProperties.

type ServerPropertiesForUpdate 

type ServerPropertiesForUpdate struct {
	// The password of the administrator login.
	AdministratorLoginPassword *string

	// AuthConfig properties of a server.
	AuthConfig *AuthConfig

	// Backup properties of a server.
	Backup *Backup

	// The mode to update a new PostgreSQL server.
	CreateMode *CreateModeForUpdate

	// Data encryption properties of a server.
	DataEncryption *DataEncryption

	// High availability properties of a server.
	HighAvailability *HighAvailability

	// Maintenance window properties of a server.
	MaintenanceWindow *MaintenanceWindow

	// Network properties of a server. These are required to be passed only in case if server is a private access server.
	Network *Network

	// Replica properties of a server. These Replica properties are required to be passed only in case you want to Promote a server.
	Replica *Replica

	// Replication role of the server
	ReplicationRole *ReplicationRole

	// Storage properties of a server.
	Storage *Storage

	// PostgreSQL Server version. Version 16 is currently not supported for MVU.
	Version *ServerVersion
}

func (ServerPropertiesForUpdate) MarshalJSON 

func (s ServerPropertiesForUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerPropertiesForUpdate.

func (*ServerPropertiesForUpdate) UnmarshalJSON 

func (s *ServerPropertiesForUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerPropertiesForUpdate.

type ServerPublicNetworkAccessState 

type ServerPublicNetworkAccessState string

ServerPublicNetworkAccessState - public network access is enabled or not 

const (
	ServerPublicNetworkAccessStateDisabled ServerPublicNetworkAccessState = "Disabled"
	ServerPublicNetworkAccessStateEnabled  ServerPublicNetworkAccessState = "Enabled"
)

func PossibleServerPublicNetworkAccessStateValues 

func PossibleServerPublicNetworkAccessStateValues() []ServerPublicNetworkAccessState

PossibleServerPublicNetworkAccessStateValues returns the possible values for the ServerPublicNetworkAccessState const type.

type ServerSKU 

type ServerSKU struct {
	// The name of the sku, typically, tier + family + cores, e.g. StandardD4sv3.
	Name *string

	// The tier of the particular SKU, e.g. Burstable.
	Tier *SKUTier
}

ServerSKU - Sku information related properties of a server.

func (ServerSKU) MarshalJSON 

func (s ServerSKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerSKU.

func (*ServerSKU) UnmarshalJSON 

func (s *ServerSKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerSKU.

type ServerSKUCapability 

type ServerSKUCapability struct {
	// READ-ONLY; Sku name
	Name *string

	// READ-ONLY; The reason for the capability not being available.
	Reason *string

	// READ-ONLY; The status of the capability.
	Status *CapabilityStatus

	// READ-ONLY; Supported high availability mode
	SupportedHaMode []*HaMode

	// READ-ONLY; Supported IOPS
	SupportedIops *int32

	// READ-ONLY; Supported memory per vCore in MB
	SupportedMemoryPerVcoreMb *int64

	// READ-ONLY; List of supported Availability Zones. E.g. "1", "2", "3"
	SupportedZones []*string

	// READ-ONLY; Supported vCores
	VCores *int32
}

ServerSKUCapability - Sku capability

func (ServerSKUCapability) MarshalJSON 

func (s ServerSKUCapability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerSKUCapability.

func (*ServerSKUCapability) UnmarshalJSON 

func (s *ServerSKUCapability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerSKUCapability.

type ServerState 

type ServerState string

ServerState - A state of a server that is visible to user. 

const (
	ServerStateDisabled ServerState = "Disabled"
	ServerStateDropping ServerState = "Dropping"
	ServerStateReady    ServerState = "Ready"
	ServerStateStarting ServerState = "Starting"
	ServerStateStopped  ServerState = "Stopped"
	ServerStateStopping ServerState = "Stopping"
	ServerStateUpdating ServerState = "Updating"
)

func PossibleServerStateValues 

func PossibleServerStateValues() []ServerState

PossibleServerStateValues returns the possible values for the ServerState const type.

type ServerThreatProtectionListResult 

type ServerThreatProtectionListResult struct {
	// READ-ONLY; Link to retrieve next page of results.
	NextLink *string

	// READ-ONLY; Array of results.
	Value []*ServerThreatProtectionSettingsModel
}

ServerThreatProtectionListResult - A list of the server's Advanced Threat Protection settings.

func (ServerThreatProtectionListResult) MarshalJSON 

func (s ServerThreatProtectionListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerThreatProtectionListResult.

func (*ServerThreatProtectionListResult) UnmarshalJSON 

func (s *ServerThreatProtectionListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerThreatProtectionListResult.

type ServerThreatProtectionProperties 

type ServerThreatProtectionProperties struct {
	// REQUIRED; Specifies the state of the Threat Protection, whether it is enabled or disabled or a state has not been applied
	// yet on the specific server.
	State *ThreatProtectionState

	// READ-ONLY; Specifies the UTC creation time of the policy.
	CreationTime *time.Time
}

ServerThreatProtectionProperties - Properties of server Threat Protection state.

func (ServerThreatProtectionProperties) MarshalJSON 

func (s ServerThreatProtectionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerThreatProtectionProperties.

func (*ServerThreatProtectionProperties) UnmarshalJSON 

func (s *ServerThreatProtectionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerThreatProtectionProperties.

type ServerThreatProtectionSettingsClient 

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

ServerThreatProtectionSettingsClient contains the methods for the ServerThreatProtectionSettings group. Don't use this type directly, use NewServerThreatProtectionSettingsClient() instead.

func NewServerThreatProtectionSettingsClient 

func NewServerThreatProtectionSettingsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ServerThreatProtectionSettingsClient, error)

NewServerThreatProtectionSettingsClient creates a new instance of ServerThreatProtectionSettingsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ServerThreatProtectionSettingsClient) BeginCreateOrUpdate 

func (client *ServerThreatProtectionSettingsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, serverName string, threatProtectionName ThreatProtectionName, parameters ServerThreatProtectionSettingsModel, options *ServerThreatProtectionSettingsClientBeginCreateOrUpdateOptions) (*runtime.Poller[ServerThreatProtectionSettingsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a server's Advanced Threat Protection settings. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • threatProtectionName - The name of the Threat Protection state.
  • parameters - The Advanced Threat Protection state for the flexible server.
  • options - ServerThreatProtectionSettingsClientBeginCreateOrUpdateOptions contains the optional parameters for the ServerThreatProtectionSettingsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerThreatProtectionSettingsCreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServerThreatProtectionSettingsClient().BeginCreateOrUpdate(ctx, "threatprotection-4799", "threatprotection-6440", armpostgresqlflexibleservers.ThreatProtectionNameDefault, armpostgresqlflexibleservers.ServerThreatProtectionSettingsModel{
	Properties: &armpostgresqlflexibleservers.ServerThreatProtectionProperties{
		State: to.Ptr(armpostgresqlflexibleservers.ThreatProtectionStateEnabled),
	},
}, 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.ServerThreatProtectionSettingsModel = armpostgresqlflexibleservers.ServerThreatProtectionSettingsModel{
// 	Name: to.Ptr("Default"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/advancedThreatProtectionSettings"),
// 	ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/threatprotection-4799/providers/Microsoft.DBforPostgreSQL/flexibleServers/threatprotection-6440/advancedThreatProtectionSettings/Default"),
// 	Properties: &armpostgresqlflexibleservers.ServerThreatProtectionProperties{
// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-09-03T04:41:33.937Z"); return t}()),
// 		State: to.Ptr(armpostgresqlflexibleservers.ThreatProtectionStateEnabled),
// 	},
// }

Output:

func (*ServerThreatProtectionSettingsClient) Get 

func (client *ServerThreatProtectionSettingsClient) Get(ctx context.Context, resourceGroupName string, serverName string, threatProtectionName ThreatProtectionName, options *ServerThreatProtectionSettingsClientGetOptions) (ServerThreatProtectionSettingsClientGetResponse, error)

Get - Get a server's Advanced Threat Protection settings. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • threatProtectionName - The name of the Threat Protection state.
  • options - ServerThreatProtectionSettingsClientGetOptions contains the optional parameters for the ServerThreatProtectionSettingsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerThreatProtectionSettingsGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewServerThreatProtectionSettingsClient().Get(ctx, "threatprotection-6852", "threatprotection-2080", armpostgresqlflexibleservers.ThreatProtectionNameDefault, 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.ServerThreatProtectionSettingsModel = armpostgresqlflexibleservers.ServerThreatProtectionSettingsModel{
// 	Name: to.Ptr("Default"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/advancedThreatProtectionSettings"),
// 	ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/threatprotection-4799/providers/Microsoft.DBforPostgreSQL/flexibleServers/threatprotection-6440/advancedThreatProtectionSettings/Default"),
// 	Properties: &armpostgresqlflexibleservers.ServerThreatProtectionProperties{
// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-09-03T04:41:33.937Z"); return t}()),
// 		State: to.Ptr(armpostgresqlflexibleservers.ThreatProtectionStateEnabled),
// 	},
// }

Output:

func (*ServerThreatProtectionSettingsClient) NewListByServerPager 

func (client *ServerThreatProtectionSettingsClient) NewListByServerPager(resourceGroupName string, serverName string, options *ServerThreatProtectionSettingsClientListByServerOptions) *runtime.Pager[ServerThreatProtectionSettingsClientListByServerResponse]

NewListByServerPager - Get a list of server's Threat Protection state.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - ServerThreatProtectionSettingsClientListByServerOptions contains the optional parameters for the ServerThreatProtectionSettingsClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerThreatProtectionSettingsListByServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewServerThreatProtectionSettingsClient().NewListByServerPager("threatprotection-6852", "threatprotection-2080", 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.ServerThreatProtectionListResult = armpostgresqlflexibleservers.ServerThreatProtectionListResult{
	// 	Value: []*armpostgresqlflexibleservers.ServerThreatProtectionSettingsModel{
	// 		{
	// 			Name: to.Ptr("Default"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/advancedThreatProtectionSettings"),
	// 			ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/threatprotection-6852/providers/Microsoft.DBforPostgreSQL/flexibleServers/threatprotection-2080/advancedThreatProtectionSettings/Default"),
	// 			Properties: &armpostgresqlflexibleservers.ServerThreatProtectionProperties{
	// 				CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-09-03T04:41:33.937Z"); return t}()),
	// 				State: to.Ptr(armpostgresqlflexibleservers.ThreatProtectionStateEnabled),
	// 			},
	// 	}},
	// }
}

Output:

type ServerThreatProtectionSettingsClientBeginCreateOrUpdateOptions 

type ServerThreatProtectionSettingsClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ServerThreatProtectionSettingsClientBeginCreateOrUpdateOptions contains the optional parameters for the ServerThreatProtectionSettingsClient.BeginCreateOrUpdate method.

type ServerThreatProtectionSettingsClientCreateOrUpdateResponse 

type ServerThreatProtectionSettingsClientCreateOrUpdateResponse struct {
	// Server's Advanced Threat Protection settings.
	ServerThreatProtectionSettingsModel
}

ServerThreatProtectionSettingsClientCreateOrUpdateResponse contains the response from method ServerThreatProtectionSettingsClient.BeginCreateOrUpdate.

type ServerThreatProtectionSettingsClientGetOptions 

type ServerThreatProtectionSettingsClientGetOptions struct {
}

ServerThreatProtectionSettingsClientGetOptions contains the optional parameters for the ServerThreatProtectionSettingsClient.Get method.

type ServerThreatProtectionSettingsClientGetResponse 

type ServerThreatProtectionSettingsClientGetResponse struct {
	// Server's Advanced Threat Protection settings.
	ServerThreatProtectionSettingsModel
}

ServerThreatProtectionSettingsClientGetResponse contains the response from method ServerThreatProtectionSettingsClient.Get.

type ServerThreatProtectionSettingsClientListByServerOptions 

type ServerThreatProtectionSettingsClientListByServerOptions struct {
}

ServerThreatProtectionSettingsClientListByServerOptions contains the optional parameters for the ServerThreatProtectionSettingsClient.NewListByServerPager method.

type ServerThreatProtectionSettingsClientListByServerResponse 

type ServerThreatProtectionSettingsClientListByServerResponse struct {
	// A list of the server's Advanced Threat Protection settings.
	ServerThreatProtectionListResult
}

ServerThreatProtectionSettingsClientListByServerResponse contains the response from method ServerThreatProtectionSettingsClient.NewListByServerPager.

type ServerThreatProtectionSettingsModel 

type ServerThreatProtectionSettingsModel struct {
	// Advanced Threat Protection properties.
	Properties *ServerThreatProtectionProperties

	// 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
}

ServerThreatProtectionSettingsModel - Server's Advanced Threat Protection settings.

func (ServerThreatProtectionSettingsModel) MarshalJSON 

func (s ServerThreatProtectionSettingsModel) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerThreatProtectionSettingsModel.

func (*ServerThreatProtectionSettingsModel) UnmarshalJSON 

func (s *ServerThreatProtectionSettingsModel) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerThreatProtectionSettingsModel.

type ServerVersion 

type ServerVersion string

ServerVersion - The version of a server. 

const (
	ServerVersionEleven   ServerVersion = "11"
	ServerVersionFifteen  ServerVersion = "15"
	ServerVersionFourteen ServerVersion = "14"
	ServerVersionSixteen  ServerVersion = "16"
	ServerVersionThirteen ServerVersion = "13"
	ServerVersionTwelve   ServerVersion = "12"
)

func PossibleServerVersionValues 

func PossibleServerVersionValues() []ServerVersion

PossibleServerVersionValues returns the possible values for the ServerVersion const type.

type ServerVersionCapability 

type ServerVersionCapability struct {
	// READ-ONLY; Server version
	Name *string

	// READ-ONLY; The reason for the capability not being available.
	Reason *string

	// READ-ONLY; The status of the capability.
	Status *CapabilityStatus

	// READ-ONLY; Supported servers versions to upgrade
	SupportedVersionsToUpgrade []*string
}

ServerVersionCapability - Server version capabilities.

func (ServerVersionCapability) MarshalJSON 

func (s ServerVersionCapability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServerVersionCapability.

func (*ServerVersionCapability) UnmarshalJSON 

func (s *ServerVersionCapability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServerVersionCapability.

type ServersClient 

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

ServersClient contains the methods for the Servers group. Don't use this type directly, use NewServersClient() instead.

func NewServersClient 

func NewServersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ServersClient, error)

NewServersClient creates a new instance of ServersClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ServersClient) BeginCreate 

func (client *ServersClient) BeginCreate(ctx context.Context, resourceGroupName string, serverName string, parameters Server, options *ServersClientBeginCreateOptions) (*runtime.Poller[ServersClientCreateResponse], error)

BeginCreate - Creates a new server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • parameters - The required parameters for creating or updating a server.
  • options - ServersClientBeginCreateOptions contains the optional parameters for the ServersClient.BeginCreate method.
Example (CreateADatabaseAsAGeoRestoreInGeoPairedLocation)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerCreateGeoRestoreWithDataEncryptionEnabled.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "testrg", "pgtestsvc5geo", armpostgresqlflexibleservers.Server{
	Location: to.Ptr("eastus"),
	Identity: &armpostgresqlflexibleservers.UserAssignedIdentity{
		Type: to.Ptr(armpostgresqlflexibleservers.IdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armpostgresqlflexibleservers.UserIdentity{
			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-geo-usermanagedidentity": {},
			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity":     {},
		},
	},
	Properties: &armpostgresqlflexibleservers.ServerProperties{
		CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeGeoRestore),
		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
			Type:                            to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeAzureKeyVault),
			GeoBackupKeyURI:                 to.Ptr("https://test-geo-kv.vault.azure.net/keys/test-key1/66f57315bab34b0189daa113fbc78787"),
			GeoBackupUserAssignedIdentityID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-geo-usermanagedidentity"),
			PrimaryKeyURI:                   to.Ptr("https://test-kv.vault.azure.net/keys/test-key1/77f57315bab34b0189daa113fbc78787"),
			PrimaryUserAssignedIdentityID:   to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity"),
		},
		PointInTimeUTC:         to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-27T00:04:59.407Z"); return t }()),
		SourceServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/sourcepgservername"),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc5geo"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc5geo"),
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Identity: &armpostgresqlflexibleservers.UserAssignedIdentity{
// 		Type: to.Ptr(armpostgresqlflexibleservers.IdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armpostgresqlflexibleservers.UserIdentity{
// 			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-geo-usermanagedidentity": &armpostgresqlflexibleservers.UserIdentity{
// 				ClientID: to.Ptr("72f988bf-86f1-41af-91ab-2d7cd011db47"),
// 				PrincipalID: to.Ptr("0a4e0c6e-7751-4078-ae1f-a477306c11e9"),
// 			},
// 			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity": &armpostgresqlflexibleservers.UserIdentity{
// 				ClientID: to.Ptr("72f988bf-86f1-41af-91ab-2d7cd011db47"),
// 				PrincipalID: to.Ptr("0a4e0c6e-7751-4078-ae1f-a477306c11e9"),
// 			},
// 		},
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("2"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-27T00:28:17.727Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumEnabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeAzureKeyVault),
// 			GeoBackupEncryptionKeyStatus: to.Ptr(armpostgresqlflexibleservers.KeyStatusEnumValid),
// 			GeoBackupKeyURI: to.Ptr("https://test-geo-kv.vault.azure.net/keys/test-key1/66f57315bab34b0189daa113fbc78787"),
// 			GeoBackupUserAssignedIdentityID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-geo-usermanagedidentity"),
// 			PrimaryEncryptionKeyStatus: to.Ptr(armpostgresqlflexibleservers.KeyStatusEnumValid),
// 			PrimaryKeyURI: to.Ptr("https://test-kv.vault.azure.net/keys/test-key1/77f57315bab34b0189daa113fbc78787"),
// 			PrimaryUserAssignedIdentityID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity"),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("pgtestsvc5geo.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeDisabled),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateNotEnabled),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateEnabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (CreateADatabaseAsAPointInTimeRestore)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerCreatePointInTimeRestore.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "testrg", "pgtestsvc5", armpostgresqlflexibleservers.Server{
	Location: to.Ptr("westus"),
	Properties: &armpostgresqlflexibleservers.ServerProperties{
		CreateMode:             to.Ptr(armpostgresqlflexibleservers.CreateModePointInTimeRestore),
		PointInTimeUTC:         to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-27T00:04:59.407Z"); return t }()),
		SourceServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/sourcepgservername"),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc5"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc5"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("2"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-27T00:28:17.727Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("pgtestsvc5.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeDisabled),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateNotEnabled),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateEnabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (CreateANewServer)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "testrg", "pgtestsvc4", armpostgresqlflexibleservers.Server{
	Location: to.Ptr("westus"),
	Tags: map[string]*string{
		"ElasticServer": to.Ptr("1"),
	},
	Properties: &armpostgresqlflexibleservers.ServerProperties{
		AdministratorLogin:         to.Ptr("cloudsa"),
		AdministratorLoginPassword: to.Ptr("password"),
		AvailabilityZone:           to.Ptr("1"),
		Backup: &armpostgresqlflexibleservers.Backup{
			BackupRetentionDays: to.Ptr[int32](7),
			GeoRedundantBackup:  to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
		},
		CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeCreate),
		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
		},
		Network: &armpostgresqlflexibleservers.Network{
			DelegatedSubnetResourceID:   to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourcegroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
		},
		Storage: &armpostgresqlflexibleservers.Storage{
			AutoGrow:      to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
			StorageSizeGB: to.Ptr[int32](512),
			Tier:          to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
		},
		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
	},
	SKU: &armpostgresqlflexibleservers.SKU{
		Name: to.Ptr("Standard_D4s_v3"),
		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:08:06.719Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (CreateANewServerWithActiveDirectoryAuthenticationEnabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerCreateWithAadAuthEnabled.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "testrg", "pgtestsvc4", armpostgresqlflexibleservers.Server{
	Location: to.Ptr("westus"),
	Tags: map[string]*string{
		"ElasticServer": to.Ptr("1"),
	},
	Properties: &armpostgresqlflexibleservers.ServerProperties{
		AdministratorLogin:         to.Ptr("cloudsa"),
		AdministratorLoginPassword: to.Ptr("password"),
		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumEnabled),
			PasswordAuth:        to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
			TenantID:            to.Ptr("tttttt-tttt-tttt-tttt-tttttttttttt"),
		},
		AvailabilityZone: to.Ptr("1"),
		Backup: &armpostgresqlflexibleservers.Backup{
			BackupRetentionDays: to.Ptr[int32](7),
			GeoRedundantBackup:  to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
		},
		CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeCreate),
		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
		},
		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
		},
		Network: &armpostgresqlflexibleservers.Network{
			DelegatedSubnetResourceID:   to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourcegroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
		},
		Storage: &armpostgresqlflexibleservers.Storage{
			AutoGrow:      to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
			StorageSizeGB: to.Ptr[int32](512),
			Tier:          to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
		},
		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
	},
	SKU: &armpostgresqlflexibleservers.SKU{
		Name: to.Ptr("Standard_D4s_v3"),
		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumEnabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 			TenantID: to.Ptr("tttttt-tttt-tttt-tttt-tttttttttttt"),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:08:06.719Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (ServerCreateReplica)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerCreateReplica.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "testrg", "pgtestsvc5rep", armpostgresqlflexibleservers.Server{
	Location: to.Ptr("westus"),
	Identity: &armpostgresqlflexibleservers.UserAssignedIdentity{
		Type: to.Ptr(armpostgresqlflexibleservers.IdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armpostgresqlflexibleservers.UserIdentity{
			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity": {},
		},
	},
	Properties: &armpostgresqlflexibleservers.ServerProperties{
		CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeReplica),
		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
			Type:                            to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeAzureKeyVault),
			GeoBackupKeyURI:                 to.Ptr(""),
			GeoBackupUserAssignedIdentityID: to.Ptr(""),
			PrimaryKeyURI:                   to.Ptr("https://test-kv.vault.azure.net/keys/test-key1/77f57315bab34b0189daa113fbc78787"),
			PrimaryUserAssignedIdentityID:   to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity"),
		},
		PointInTimeUTC:         to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-06-27T00:04:59.407Z"); return t }()),
		SourceServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/sourcepgservername"),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc5rep"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc5rep"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Identity: &armpostgresqlflexibleservers.UserAssignedIdentity{
// 		Type: to.Ptr(armpostgresqlflexibleservers.IdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armpostgresqlflexibleservers.UserIdentity{
// 			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity": &armpostgresqlflexibleservers.UserIdentity{
// 				ClientID: to.Ptr("72f988bf-86f1-41af-91ab-2d7cd011db47"),
// 				PrincipalID: to.Ptr("0a4e0c6e-7751-4078-ae1f-a477306c11e9"),
// 			},
// 		},
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("2"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-27T00:28:17.727Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeAzureKeyVault),
// 			PrimaryEncryptionKeyStatus: to.Ptr(armpostgresqlflexibleservers.KeyStatusEnumValid),
// 			PrimaryKeyURI: to.Ptr("https://test-kv.vault.azure.net/keys/test-key1/77f57315bab34b0189daa113fbc78787"),
// 			PrimaryUserAssignedIdentityID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity"),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("pgtestsvc5rep.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeDisabled),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateNotEnabled),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateEnabled),
// 		},
// 		Replica: &armpostgresqlflexibleservers.Replica{
// 			Capacity: to.Ptr[int32](0),
// 			ReplicationState: to.Ptr(armpostgresqlflexibleservers.ReplicationStateActive),
// 			Role: to.Ptr(armpostgresqlflexibleservers.ReplicationRoleAsyncReplica),
// 		},
// 		ReplicaCapacity: to.Ptr[int32](0),
// 		ReplicationRole: to.Ptr(armpostgresqlflexibleservers.ReplicationRoleAsyncReplica),
// 		SourceServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/sourcepgservername"),
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (ServerCreateReviveDropped)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerCreateReviveDropped.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "testrg", "pgtestsvc5-rev", armpostgresqlflexibleservers.Server{
	Location: to.Ptr("westus"),
	Properties: &armpostgresqlflexibleservers.ServerProperties{
		CreateMode:             to.Ptr(armpostgresqlflexibleservers.CreateModeReviveDropped),
		PointInTimeUTC:         to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-27T00:04:59.407Z"); return t }()),
		SourceServerResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc5"),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc5-rev"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc5-rev"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("2"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-27T00:28:17.727Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("pgtestsvc5-rev.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeDisabled),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateNotEnabled),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateEnabled),
// 		},
// 		ReplicaCapacity: to.Ptr[int32](0),
// 		ReplicationRole: to.Ptr(armpostgresqlflexibleservers.ReplicationRolePrimary),
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (ServerCreateWithDataEncryptionEnabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerCreateWithDataEncryptionEnabled.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "testrg", "pgtestsvc4", armpostgresqlflexibleservers.Server{
	Location: to.Ptr("westus"),
	Tags: map[string]*string{
		"ElasticServer": to.Ptr("1"),
	},
	Identity: &armpostgresqlflexibleservers.UserAssignedIdentity{
		Type: to.Ptr(armpostgresqlflexibleservers.IdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armpostgresqlflexibleservers.UserIdentity{
			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity": {},
		},
	},
	Properties: &armpostgresqlflexibleservers.ServerProperties{
		AdministratorLogin:         to.Ptr("cloudsa"),
		AdministratorLoginPassword: to.Ptr("password"),
		AvailabilityZone:           to.Ptr("1"),
		Backup: &armpostgresqlflexibleservers.Backup{
			BackupRetentionDays: to.Ptr[int32](7),
			GeoRedundantBackup:  to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
		},
		CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeCreate),
		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
			Type:                            to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeAzureKeyVault),
			GeoBackupKeyURI:                 to.Ptr(""),
			GeoBackupUserAssignedIdentityID: to.Ptr(""),
			PrimaryKeyURI:                   to.Ptr("https://test-kv.vault.azure.net/keys/test-key1/77f57315bab34b0189daa113fbc78787"),
			PrimaryUserAssignedIdentityID:   to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity"),
		},
		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
		},
		Network: &armpostgresqlflexibleservers.Network{
			DelegatedSubnetResourceID:   to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourcegroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
		},
		Storage: &armpostgresqlflexibleservers.Storage{
			AutoGrow:      to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
			StorageSizeGB: to.Ptr[int32](512),
		},
		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
	},
	SKU: &armpostgresqlflexibleservers.SKU{
		Name: to.Ptr("Standard_D4s_v3"),
		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Identity: &armpostgresqlflexibleservers.UserAssignedIdentity{
// 		Type: to.Ptr(armpostgresqlflexibleservers.IdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armpostgresqlflexibleservers.UserIdentity{
// 			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity": &armpostgresqlflexibleservers.UserIdentity{
// 				ClientID: to.Ptr("72f988bf-86f1-41af-91ab-2d7cd011db47"),
// 				PrincipalID: to.Ptr("0a4e0c6e-7751-4078-ae1f-a477306c11e9"),
// 			},
// 		},
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumEnabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:08:06.719Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeAzureKeyVault),
// 			PrimaryEncryptionKeyStatus: to.Ptr(armpostgresqlflexibleservers.KeyStatusEnumValid),
// 			PrimaryKeyURI: to.Ptr("https://test-kv.vault.azure.net/keys/test-key1/77f57315bab34b0189daa113fbc78787"),
// 			PrimaryUserAssignedIdentityID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity"),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:

func (*ServersClient) BeginDelete 

func (client *ServersClient) BeginDelete(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientBeginDeleteOptions) (*runtime.Poller[ServersClientDeleteResponse], error)

BeginDelete - Deletes a server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - ServersClientBeginDeleteOptions contains the optional parameters for the ServersClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginDelete(ctx, "testrg", "testserver", 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)
}

Output:

func (*ServersClient) BeginRestart 

func (client *ServersClient) BeginRestart(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientBeginRestartOptions) (*runtime.Poller[ServersClientRestartResponse], error)

BeginRestart - Restarts a server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - ServersClientBeginRestartOptions contains the optional parameters for the ServersClient.BeginRestart method.
Example (ServerRestart)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerRestart.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginRestart(ctx, "testrg", "testserver", &armpostgresqlflexibleservers.ServersClientBeginRestartOptions{Parameters: 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)
}

Output:
Example (ServerRestartWithFailover)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerRestartWithFailover.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginRestart(ctx, "testrg", "testserver", &armpostgresqlflexibleservers.ServersClientBeginRestartOptions{Parameters: &armpostgresqlflexibleservers.RestartParameter{
	FailoverMode:        to.Ptr(armpostgresqlflexibleservers.FailoverModeForcedFailover),
	RestartWithFailover: to.Ptr(true),
},
})
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)
}

Output:

func (*ServersClient) BeginStart 

func (client *ServersClient) BeginStart(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientBeginStartOptions) (*runtime.Poller[ServersClientStartResponse], error)

BeginStart - Starts a server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - ServersClientBeginStartOptions contains the optional parameters for the ServersClient.BeginStart method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerStart.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginStart(ctx, "testrg", "testserver", 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)
}

Output:

func (*ServersClient) BeginStop 

func (client *ServersClient) BeginStop(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientBeginStopOptions) (*runtime.Poller[ServersClientStopResponse], error)

BeginStop - Stops a server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - ServersClientBeginStopOptions contains the optional parameters for the ServersClient.BeginStop method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerStop.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginStop(ctx, "testrg", "testserver", 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)
}

Output:

func (*ServersClient) BeginUpdate 

func (client *ServersClient) BeginUpdate(ctx context.Context, resourceGroupName string, serverName string, parameters ServerForUpdate, options *ServersClientBeginUpdateOptions) (*runtime.Poller[ServersClientUpdateResponse], error)

BeginUpdate - Updates an existing server. The request body can contain one to many of the properties present in the normal server definition. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • parameters - The required parameters for updating a server.
  • options - ServersClientBeginUpdateOptions contains the optional parameters for the ServersClient.BeginUpdate method.
Example (PromoteAReplicaServerAsAStandaloneServerAsForcedIEItWillPromoteAReplicaServerImmediatelyWithoutWaitingForPrimaryAndReplicaToBeInSync)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/PromoteReplicaAsForcedStandaloneServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "testResourceGroup", "pgtestsvc4-replica", armpostgresqlflexibleservers.ServerForUpdate{
	Properties: &armpostgresqlflexibleservers.ServerPropertiesForUpdate{
		Replica: &armpostgresqlflexibleservers.Replica{
			PromoteMode:   to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteModeStandalone),
			PromoteOption: to.Ptr(armpostgresqlflexibleservers.ReplicationPromoteOptionForced),
		},
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4-replica"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4-replica"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](20),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("pgtestsvc4-replica.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		Replica: &armpostgresqlflexibleservers.Replica{
// 			Capacity: to.Ptr[int32](0),
// 			Role: to.Ptr(armpostgresqlflexibleservers.ReplicationRoleNone),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowEnabled),
// 			Iops: to.Ptr[int32](5000),
// 			StorageSizeGB: to.Ptr[int32](1024),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP30),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D8s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (PromoteAReplicaServerAsAStandaloneServerAsPlannedIEItWillWaitForReplicationToComplete)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/PromoteReplicaAsPlannedStandaloneServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "testResourceGroup", "pgtestsvc4-replica", armpostgresqlflexibleservers.ServerForUpdate{
	Properties: &armpostgresqlflexibleservers.ServerPropertiesForUpdate{
		Replica: &armpostgresqlflexibleservers.Replica{
			PromoteMode:   to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteModeStandalone),
			PromoteOption: to.Ptr(armpostgresqlflexibleservers.ReplicationPromoteOptionPlanned),
		},
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4-replica"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4-replica"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](20),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("pgtestsvc4-replica.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		Replica: &armpostgresqlflexibleservers.Replica{
// 			Capacity: to.Ptr[int32](0),
// 			Role: to.Ptr(armpostgresqlflexibleservers.ReplicationRoleNone),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowEnabled),
// 			Iops: to.Ptr[int32](5000),
// 			StorageSizeGB: to.Ptr[int32](1024),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP30),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D8s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (ServerUpdate)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "TestGroup", "pgtestsvc4", armpostgresqlflexibleservers.ServerForUpdate{
	Properties: &armpostgresqlflexibleservers.ServerPropertiesForUpdate{
		AdministratorLoginPassword: to.Ptr("newpassword"),
		Backup: &armpostgresqlflexibleservers.Backup{
			BackupRetentionDays: to.Ptr[int32](20),
		},
		CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForUpdateUpdate),
		Storage: &armpostgresqlflexibleservers.Storage{
			AutoGrow:      to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowEnabled),
			StorageSizeGB: to.Ptr[int32](1024),
			Tier:          to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP30),
		},
	},
	SKU: &armpostgresqlflexibleservers.SKU{
		Name: to.Ptr("Standard_D8s_v3"),
		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](20),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowEnabled),
// 			Iops: to.Ptr[int32](5000),
// 			StorageSizeGB: to.Ptr[int32](1024),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP30),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D8s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (ServerUpdateWithAadAuthEnabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerUpdateWithAadAuthEnabled.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "TestGroup", "pgtestsvc4", armpostgresqlflexibleservers.ServerForUpdate{
	Properties: &armpostgresqlflexibleservers.ServerPropertiesForUpdate{
		AdministratorLoginPassword: to.Ptr("newpassword"),
		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumEnabled),
			PasswordAuth:        to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
			TenantID:            to.Ptr("tttttt-tttt-tttt-tttt-tttttttttttt"),
		},
		Backup: &armpostgresqlflexibleservers.Backup{
			BackupRetentionDays: to.Ptr[int32](20),
		},
		CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForUpdateUpdate),
		Storage: &armpostgresqlflexibleservers.Storage{
			AutoGrow:      to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
			StorageSizeGB: to.Ptr[int32](1024),
			Tier:          to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP30),
		},
	},
	SKU: &armpostgresqlflexibleservers.SKU{
		Name: to.Ptr("Standard_D8s_v3"),
		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumEnabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 			TenantID: to.Ptr("tttttt-tttt-tttt-tttt-tttttttttttt"),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](20),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](5000),
// 			StorageSizeGB: to.Ptr[int32](1024),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP30),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D8s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (ServerUpdateWithCustomerMaintenanceWindow)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerUpdateWithCustomerMaintenanceWindow.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "testrg", "pgtestsvc4", armpostgresqlflexibleservers.ServerForUpdate{
	Properties: &armpostgresqlflexibleservers.ServerPropertiesForUpdate{
		CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForUpdateUpdate),
		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
			CustomWindow: to.Ptr("Enabled"),
			DayOfWeek:    to.Ptr[int32](0),
			StartHour:    to.Ptr[int32](8),
			StartMinute:  to.Ptr[int32](0),
		},
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Enabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](8),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (ServerUpdateWithDataEncryptionEnabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerUpdateWithDataEncryptionEnabled.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "TestGroup", "pgtestsvc4", armpostgresqlflexibleservers.ServerForUpdate{
	Identity: &armpostgresqlflexibleservers.UserAssignedIdentity{
		Type: to.Ptr(armpostgresqlflexibleservers.IdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armpostgresqlflexibleservers.UserIdentity{
			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-geo-usermanagedidentity": {},
			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity":     {},
		},
	},
	Properties: &armpostgresqlflexibleservers.ServerPropertiesForUpdate{
		AdministratorLoginPassword: to.Ptr("newpassword"),
		Backup: &armpostgresqlflexibleservers.Backup{
			BackupRetentionDays: to.Ptr[int32](20),
		},
		CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForUpdateUpdate),
		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
			Type:                            to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeAzureKeyVault),
			GeoBackupKeyURI:                 to.Ptr("https://test-geo-kv.vault.azure.net/keys/test-key1/66f57315bab34b0189daa113fbc78787"),
			GeoBackupUserAssignedIdentityID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-geo-usermanagedidentity"),
			PrimaryKeyURI:                   to.Ptr("https://test-kv.vault.azure.net/keys/test-key1/77f57315bab34b0189daa113fbc78787"),
			PrimaryUserAssignedIdentityID:   to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity"),
		},
	},
	SKU: &armpostgresqlflexibleservers.SKU{
		Name: to.Ptr("Standard_D8s_v3"),
		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Identity: &armpostgresqlflexibleservers.UserAssignedIdentity{
// 		Type: to.Ptr(armpostgresqlflexibleservers.IdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armpostgresqlflexibleservers.UserIdentity{
// 			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-geo-usermanagedidentity": &armpostgresqlflexibleservers.UserIdentity{
// 				ClientID: to.Ptr("72f988bf-86f1-41af-91ab-2d7cd011db47"),
// 				PrincipalID: to.Ptr("0a4e0c6e-7751-4078-ae1f-a477306c11e9"),
// 			},
// 			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity": &armpostgresqlflexibleservers.UserIdentity{
// 				ClientID: to.Ptr("72f988bf-86f1-41af-91ab-2d7cd011db47"),
// 				PrincipalID: to.Ptr("0a4e0c6e-7751-4078-ae1f-a477306c11e9"),
// 			},
// 			"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity-1": &armpostgresqlflexibleservers.UserIdentity{
// 				ClientID: to.Ptr("72f988bf-86f1-41af-91ab-2d7cd011db47"),
// 				PrincipalID: to.Ptr("90008082-e024-4cc3-8fcf-63bcdb9cf6b6"),
// 			},
// 		},
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](20),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumEnabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeAzureKeyVault),
// 			GeoBackupEncryptionKeyStatus: to.Ptr(armpostgresqlflexibleservers.KeyStatusEnumValid),
// 			GeoBackupKeyURI: to.Ptr("https://test-geo-kv.vault.azure.net/keys/test-key1/66f57315bab34b0189daa113fbc78787"),
// 			GeoBackupUserAssignedIdentityID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-geo-usermanagedidentity"),
// 			PrimaryEncryptionKeyStatus: to.Ptr(armpostgresqlflexibleservers.KeyStatusEnumValid),
// 			PrimaryKeyURI: to.Ptr("https://test-kv.vault.azure.net/keys/test-key1/77f57315bab34b0189daa113fbc78787"),
// 			PrimaryUserAssignedIdentityID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-usermanagedidentity"),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](5000),
// 			StorageSizeGB: to.Ptr[int32](1024),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP30),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D8s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (ServerUpdateWithMajorVersionUpgrade)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerUpdateWithMajorVersionUpgrade.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "testrg", "pgtestsvc4", armpostgresqlflexibleservers.ServerForUpdate{
	Properties: &armpostgresqlflexibleservers.ServerPropertiesForUpdate{
		CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForUpdateUpdate),
		Version:    to.Ptr(armpostgresqlflexibleservers.ServerVersionFourteen),
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowEnabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionFourteen),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (SwitchOverAReplicaServerAsForcedIEItWillReplicaAsPrimaryAndOriginalPrimaryAsReplicaImmediatelyWithoutWaitingForPrimaryAndReplicaToBeInSync)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/PromoteReplicaAsForcedSwitchover.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "testResourceGroup", "pgtestsvc4-replica", armpostgresqlflexibleservers.ServerForUpdate{
	Properties: &armpostgresqlflexibleservers.ServerPropertiesForUpdate{
		Replica: &armpostgresqlflexibleservers.Replica{
			PromoteMode:   to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteModeSwitchover),
			PromoteOption: to.Ptr(armpostgresqlflexibleservers.ReplicationPromoteOptionForced),
		},
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4-replica"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4-replica"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](20),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("pgtestsvc4-replica.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		Replica: &armpostgresqlflexibleservers.Replica{
// 			Capacity: to.Ptr[int32](5),
// 			Role: to.Ptr(armpostgresqlflexibleservers.ReplicationRolePrimary),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowEnabled),
// 			Iops: to.Ptr[int32](5000),
// 			StorageSizeGB: to.Ptr[int32](1024),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP30),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D8s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (SwitchOverAReplicaServerAsPlannedIEItWillWaitForReplicationToCompleteBeforePromotingReplicaAsPrimaryAndOriginalPrimaryAsReplica)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/PromoteReplicaAsPlannedSwitchover.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "testResourceGroup", "pgtestsvc4-replica", armpostgresqlflexibleservers.ServerForUpdate{
	Properties: &armpostgresqlflexibleservers.ServerPropertiesForUpdate{
		Replica: &armpostgresqlflexibleservers.Replica{
			PromoteMode:   to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteModeSwitchover),
			PromoteOption: to.Ptr(armpostgresqlflexibleservers.ReplicationPromoteOptionPlanned),
		},
	},
}, 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4-replica"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4-replica"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](20),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
// 			Type: to.Ptr(armpostgresqlflexibleservers.ArmServerKeyTypeSystemManaged),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("pgtestsvc4-replica.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		Replica: &armpostgresqlflexibleservers.Replica{
// 			Capacity: to.Ptr[int32](5),
// 			Role: to.Ptr(armpostgresqlflexibleservers.ReplicationRolePrimary),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowEnabled),
// 			Iops: to.Ptr[int32](5000),
// 			StorageSizeGB: to.Ptr[int32](1024),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP30),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D8s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:

func (*ServersClient) Get 

func (client *ServersClient) Get(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientGetOptions) (ServersClientGetResponse, error)

Get - Gets information about a server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - ServersClientGetOptions contains the optional parameters for the ServersClient.Get method.
Example (ServerGet)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewServersClient().Get(ctx, "testrg", "pgtestsvc1", 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc1"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T23:07:25.816Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("pgtestsvc1.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeDisabled),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateNotEnabled),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateEnabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:
Example (ServerGetWithPrivateEndpoints)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerGetWithPrivateEndpoints.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewServersClient().Get(ctx, "testrg", "pgtestsvc2", 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc2"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T23:07:25.816Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("pgtestsvc2.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeDisabled),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateNotEnabled),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateEnabled),
// 		},
// 		PrivateEndpointConnections: []*armpostgresqlflexibleservers.PrivateEndpointConnection{
// 			{
// 				Name: to.Ptr("asdfasdfa.40c899c7-5847-493e-9c9e-d0a0c90aaf92"),
// 				Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/privateEndpointConnections"),
// 				ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc2/privateEndpointConnections/asdfasdfa.40c899c7-5847-493e-9c9e-d0a0c90aaf92"),
// 				Properties: &armpostgresqlflexibleservers.PrivateEndpointConnectionProperties{
// 					GroupIDs: []*string{
// 						to.Ptr("postgresqlServer")},
// 						PrivateEndpoint: &armpostgresqlflexibleservers.PrivateEndpoint{
// 							ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/pe-test-rg/providers/Microsoft.Network/privateEndpoints/asdfasdfa"),
// 						},
// 						PrivateLinkServiceConnectionState: &armpostgresqlflexibleservers.PrivateLinkServiceConnectionState{
// 							Description: to.Ptr("Auto-Approved"),
// 							ActionsRequired: to.Ptr("None"),
// 							Status: to.Ptr(armpostgresqlflexibleservers.PrivateEndpointServiceConnectionStatusApproved),
// 						},
// 						ProvisioningState: to.Ptr(armpostgresqlflexibleservers.PrivateEndpointConnectionProvisioningStateSucceeded),
// 					},
// 			}},
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 			Storage: &armpostgresqlflexibleservers.Storage{
// 				AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 				Iops: to.Ptr[int32](2300),
// 				StorageSizeGB: to.Ptr[int32](512),
// 				Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 			},
// 			Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 		},
// 		SKU: &armpostgresqlflexibleservers.SKU{
// 			Name: to.Ptr("Standard_D4s_v3"),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 		},
// 	}

Output:
Example (ServerGetWithVnet)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerGetWithVnet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewServersClient().Get(ctx, "testrg", "pgtestsvc4", 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.Server = armpostgresqlflexibleservers.Server{
// 	Name: to.Ptr("pgtestsvc4"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"ElasticServer": to.Ptr("1"),
// 	},
// 	Properties: &armpostgresqlflexibleservers.ServerProperties{
// 		AdministratorLogin: to.Ptr("cloudsa"),
// 		AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
// 			ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
// 			PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
// 		},
// 		AvailabilityZone: to.Ptr("1"),
// 		Backup: &armpostgresqlflexibleservers.Backup{
// 			BackupRetentionDays: to.Ptr[int32](7),
// 			EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
// 			GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
// 		},
// 		FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
// 		HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
// 			Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
// 			StandbyAvailabilityZone: to.Ptr("2"),
// 			State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
// 		},
// 		MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindow{
// 			CustomWindow: to.Ptr("Disabled"),
// 			DayOfWeek: to.Ptr[int32](0),
// 			StartHour: to.Ptr[int32](0),
// 			StartMinute: to.Ptr[int32](0),
// 		},
// 		MinorVersion: to.Ptr("6"),
// 		Network: &armpostgresqlflexibleservers.Network{
// 			DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
// 			PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
// 			PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
// 		},
// 		State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
// 		Storage: &armpostgresqlflexibleservers.Storage{
// 			AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
// 			Iops: to.Ptr[int32](2300),
// 			StorageSizeGB: to.Ptr[int32](512),
// 			Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
// 		},
// 		Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
// 	},
// 	SKU: &armpostgresqlflexibleservers.SKU{
// 		Name: to.Ptr("Standard_D4s_v3"),
// 		Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
// 	},
// }

Output:

func (*ServersClient) NewListByResourceGroupPager 

func (client *ServersClient) NewListByResourceGroupPager(resourceGroupName string, options *ServersClientListByResourceGroupOptions) *runtime.Pager[ServersClientListByResourceGroupResponse]

NewListByResourceGroupPager - List all the servers in a given resource group.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - ServersClientListByResourceGroupOptions contains the optional parameters for the ServersClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewServersClient().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.ServerListResult = armpostgresqlflexibleservers.ServerListResult{
	// 	Value: []*armpostgresqlflexibleservers.Server{
	// 		{
	// 			Name: to.Ptr("pgtestsvc4"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
	// 			Location: to.Ptr("westus"),
	// 			Tags: map[string]*string{
	// 				"ElasticServer": to.Ptr("1"),
	// 			},
	// 			Properties: &armpostgresqlflexibleservers.ServerProperties{
	// 				AdministratorLogin: to.Ptr("cloudsa"),
	// 				AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
	// 					ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
	// 					PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
	// 				},
	// 				AvailabilityZone: to.Ptr("1"),
	// 				Backup: &armpostgresqlflexibleservers.Backup{
	// 					BackupRetentionDays: to.Ptr[int32](7),
	// 					EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
	// 					GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
	// 				},
	// 				FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
	// 				HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
	// 					Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
	// 					StandbyAvailabilityZone: to.Ptr("2"),
	// 					State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
	// 				},
	// 				MinorVersion: to.Ptr("6"),
	// 				Network: &armpostgresqlflexibleservers.Network{
	// 					DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
	// 					PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
	// 					PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
	// 				},
	// 				State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
	// 				Storage: &armpostgresqlflexibleservers.Storage{
	// 					AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
	// 					Iops: to.Ptr[int32](2300),
	// 					StorageSizeGB: to.Ptr[int32](512),
	// 					Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
	// 				},
	// 				Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
	// 			},
	// 			SKU: &armpostgresqlflexibleservers.SKU{
	// 				Name: to.Ptr("Standard_D4s_v3"),
	// 				Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("pgtestsvc1"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc1"),
	// 			Location: to.Ptr("westus"),
	// 			Tags: map[string]*string{
	// 				"ElasticServer": to.Ptr("1"),
	// 			},
	// 			Properties: &armpostgresqlflexibleservers.ServerProperties{
	// 				AdministratorLogin: to.Ptr("cloudsa"),
	// 				AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
	// 					ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
	// 					PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
	// 				},
	// 				AvailabilityZone: to.Ptr("1"),
	// 				Backup: &armpostgresqlflexibleservers.Backup{
	// 					BackupRetentionDays: to.Ptr[int32](7),
	// 					EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T23:15:38.813Z"); return t}()),
	// 					GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
	// 				},
	// 				FullyQualifiedDomainName: to.Ptr("pgtestsvc1.postgres.database.azure.com"),
	// 				HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
	// 					Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeDisabled),
	// 					State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateNotEnabled),
	// 				},
	// 				MinorVersion: to.Ptr("6"),
	// 				Network: &armpostgresqlflexibleservers.Network{
	// 					PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateEnabled),
	// 				},
	// 				State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
	// 				Storage: &armpostgresqlflexibleservers.Storage{
	// 					AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
	// 					Iops: to.Ptr[int32](2300),
	// 					StorageSizeGB: to.Ptr[int32](512),
	// 					Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
	// 				},
	// 				Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
	// 			},
	// 			SKU: &armpostgresqlflexibleservers.SKU{
	// 				Name: to.Ptr("Standard_D4s_v3"),
	// 				Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	// 			},
	// 	}},
	// }
}

Output:

func (*ServersClient) NewListPager 

func (client *ServersClient) NewListPager(options *ServersClientListOptions) *runtime.Pager[ServersClientListResponse]

NewListPager - List all the servers in a given subscription.

Generated from API version 2023-12-01-preview

  • options - ServersClientListOptions contains the optional parameters for the ServersClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/ServerList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewServersClient().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.ServerListResult = armpostgresqlflexibleservers.ServerListResult{
	// 	Value: []*armpostgresqlflexibleservers.Server{
	// 		{
	// 			Name: to.Ptr("pgtestsvc4"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4"),
	// 			Location: to.Ptr("westus"),
	// 			Tags: map[string]*string{
	// 				"ElasticServer": to.Ptr("1"),
	// 			},
	// 			Properties: &armpostgresqlflexibleservers.ServerProperties{
	// 				AdministratorLogin: to.Ptr("cloudsa"),
	// 				AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
	// 					ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
	// 					PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
	// 				},
	// 				AvailabilityZone: to.Ptr("1"),
	// 				Backup: &armpostgresqlflexibleservers.Backup{
	// 					BackupRetentionDays: to.Ptr[int32](7),
	// 					EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T01:16:58.372Z"); return t}()),
	// 					GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
	// 				},
	// 				FullyQualifiedDomainName: to.Ptr("c7d7483a8ceb.test-private-dns-zone.postgres.database.azure.com"),
	// 				HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
	// 					Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeZoneRedundant),
	// 					StandbyAvailabilityZone: to.Ptr("2"),
	// 					State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateHealthy),
	// 				},
	// 				MinorVersion: to.Ptr("6"),
	// 				Network: &armpostgresqlflexibleservers.Network{
	// 					DelegatedSubnetResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/test-vnet-subnet"),
	// 					PrivateDNSZoneArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/privateDnsZones/test-private-dns-zone.postgres.database.azure.com"),
	// 					PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateDisabled),
	// 				},
	// 				State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
	// 				Storage: &armpostgresqlflexibleservers.Storage{
	// 					AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
	// 					StorageSizeGB: to.Ptr[int32](512),
	// 				},
	// 				Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
	// 			},
	// 			SKU: &armpostgresqlflexibleservers.SKU{
	// 				Name: to.Ptr("Standard_D4s_v3"),
	// 				Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("pgtestsvc1"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc1"),
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 				"ElasticServer": to.Ptr("1"),
	// 			},
	// 			Properties: &armpostgresqlflexibleservers.ServerProperties{
	// 				AdministratorLogin: to.Ptr("cloudsa"),
	// 				AuthConfig: &armpostgresqlflexibleservers.AuthConfig{
	// 					ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.ActiveDirectoryAuthEnumDisabled),
	// 					PasswordAuth: to.Ptr(armpostgresqlflexibleservers.PasswordAuthEnumEnabled),
	// 				},
	// 				AvailabilityZone: to.Ptr("1"),
	// 				Backup: &armpostgresqlflexibleservers.Backup{
	// 					BackupRetentionDays: to.Ptr[int32](7),
	// 					EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-05-26T23:15:38.813Z"); return t}()),
	// 					GeoRedundantBackup: to.Ptr(armpostgresqlflexibleservers.GeoRedundantBackupEnumDisabled),
	// 				},
	// 				FullyQualifiedDomainName: to.Ptr("pgtestsvc1.postgres.database.azure.com"),
	// 				HighAvailability: &armpostgresqlflexibleservers.HighAvailability{
	// 					Mode: to.Ptr(armpostgresqlflexibleservers.HighAvailabilityModeDisabled),
	// 					State: to.Ptr(armpostgresqlflexibleservers.ServerHAStateNotEnabled),
	// 				},
	// 				MinorVersion: to.Ptr("6"),
	// 				Network: &armpostgresqlflexibleservers.Network{
	// 					PublicNetworkAccess: to.Ptr(armpostgresqlflexibleservers.ServerPublicNetworkAccessStateEnabled),
	// 				},
	// 				State: to.Ptr(armpostgresqlflexibleservers.ServerStateReady),
	// 				Storage: &armpostgresqlflexibleservers.Storage{
	// 					AutoGrow: to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowEnabled),
	// 					Iops: to.Ptr[int32](2300),
	// 					StorageSizeGB: to.Ptr[int32](512),
	// 					Tier: to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTiersP20),
	// 				},
	// 				Version: to.Ptr(armpostgresqlflexibleservers.ServerVersionTwelve),
	// 			},
	// 			SKU: &armpostgresqlflexibleservers.SKU{
	// 				Name: to.Ptr("Standard_D4s_v3"),
	// 				Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
	// 			},
	// 	}},
	// }
}

Output:

type ServersClientBeginCreateOptions 

type ServersClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ServersClientBeginCreateOptions contains the optional parameters for the ServersClient.BeginCreate method.

type ServersClientBeginDeleteOptions 

type ServersClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ServersClientBeginDeleteOptions contains the optional parameters for the ServersClient.BeginDelete method.

type ServersClientBeginRestartOptions 

type ServersClientBeginRestartOptions struct {
	// The parameters for restarting a server.
	Parameters *RestartParameter

	// Resumes the LRO from the provided token.
	ResumeToken string
}

ServersClientBeginRestartOptions contains the optional parameters for the ServersClient.BeginRestart method.

type ServersClientBeginStartOptions 

type ServersClientBeginStartOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ServersClientBeginStartOptions contains the optional parameters for the ServersClient.BeginStart method.

type ServersClientBeginStopOptions 

type ServersClientBeginStopOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ServersClientBeginStopOptions contains the optional parameters for the ServersClient.BeginStop method.

type ServersClientBeginUpdateOptions 

type ServersClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ServersClientBeginUpdateOptions contains the optional parameters for the ServersClient.BeginUpdate method.

type ServersClientCreateResponse 

type ServersClientCreateResponse struct {
	// Represents a server.
	Server
}

ServersClientCreateResponse contains the response from method ServersClient.BeginCreate.

type ServersClientDeleteResponse 

type ServersClientDeleteResponse struct {
}

ServersClientDeleteResponse contains the response from method ServersClient.BeginDelete.

type ServersClientGetOptions 

type ServersClientGetOptions struct {
}

ServersClientGetOptions contains the optional parameters for the ServersClient.Get method.

type ServersClientGetResponse 

type ServersClientGetResponse struct {
	// Represents a server.
	Server
}

ServersClientGetResponse contains the response from method ServersClient.Get.

type ServersClientListByResourceGroupOptions 

type ServersClientListByResourceGroupOptions struct {
}

ServersClientListByResourceGroupOptions contains the optional parameters for the ServersClient.NewListByResourceGroupPager method.

type ServersClientListByResourceGroupResponse 

type ServersClientListByResourceGroupResponse struct {
	// A list of servers.
	ServerListResult
}

ServersClientListByResourceGroupResponse contains the response from method ServersClient.NewListByResourceGroupPager.

type ServersClientListOptions 

type ServersClientListOptions struct {
}

ServersClientListOptions contains the optional parameters for the ServersClient.NewListPager method.

type ServersClientListResponse 

type ServersClientListResponse struct {
	// A list of servers.
	ServerListResult
}

ServersClientListResponse contains the response from method ServersClient.NewListPager.

type ServersClientRestartResponse 

type ServersClientRestartResponse struct {
}

ServersClientRestartResponse contains the response from method ServersClient.BeginRestart.

type ServersClientStartResponse 

type ServersClientStartResponse struct {
}

ServersClientStartResponse contains the response from method ServersClient.BeginStart.

type ServersClientStopResponse 

type ServersClientStopResponse struct {
}

ServersClientStopResponse contains the response from method ServersClient.BeginStop.

type ServersClientUpdateResponse 

type ServersClientUpdateResponse struct {
	// Represents a server.
	Server
}

ServersClientUpdateResponse contains the response from method ServersClient.BeginUpdate.

type SourceType 

type SourceType string

SourceType - Migration source server type : OnPremises, AWS, GCP, AzureVM, PostgreSQLSingleServer, AWSRDS, AWSAURORA, AWSEC2, GCPCloudSQL, GCPAlloyDB, GCPCompute, or EDB 

const (
	SourceTypeAWS                    SourceType = "AWS"
	SourceTypeAWSAURORA              SourceType = "AWS_AURORA"
	SourceTypeAWSEC2                 SourceType = "AWS_EC2"
	SourceTypeAWSRDS                 SourceType = "AWS_RDS"
	SourceTypeAzureVM                SourceType = "AzureVM"
	SourceTypeEDB                    SourceType = "EDB"
	SourceTypeGCP                    SourceType = "GCP"
	SourceTypeGCPAlloyDB             SourceType = "GCP_AlloyDB"
	SourceTypeGCPCloudSQL            SourceType = "GCP_CloudSQL"
	SourceTypeGCPCompute             SourceType = "GCP_Compute"
	SourceTypeOnPremises             SourceType = "OnPremises"
	SourceTypePostgreSQLSingleServer SourceType = "PostgreSQLSingleServer"
)

func PossibleSourceTypeValues 

func PossibleSourceTypeValues() []SourceType

PossibleSourceTypeValues returns the possible values for the SourceType const type.

type StartDataMigrationEnum 

type StartDataMigrationEnum string

StartDataMigrationEnum - Indicates whether the data migration should start right away 

const (
	StartDataMigrationEnumFalse StartDataMigrationEnum = "False"
	StartDataMigrationEnumTrue  StartDataMigrationEnum = "True"
)

func PossibleStartDataMigrationEnumValues 

func PossibleStartDataMigrationEnumValues() []StartDataMigrationEnum

PossibleStartDataMigrationEnumValues returns the possible values for the StartDataMigrationEnum const type.

type Storage 

type Storage struct {
	// Flag to enable / disable Storage Auto grow for flexible server.
	AutoGrow *StorageAutoGrow

	// Storage tier IOPS quantity. This property is required to be set for storage Type PremiumV2_LRS
	Iops *int32

	// Max storage allowed for a server.
	StorageSizeGB *int32

	// Storage throughput for the server. This is required to be set for storage Type PremiumV2_LRS
	Throughput *int32

	// Name of storage tier for IOPS.
	Tier *AzureManagedDiskPerformanceTiers

	// Storage type for the server. Allowed values are PremiumLRS and PremiumV2LRS, and default is Premium_LRS if not specified
	Type *StorageType
}

Storage properties of a server

func (Storage) MarshalJSON 

func (s Storage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Storage.

func (*Storage) UnmarshalJSON 

func (s *Storage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Storage.

type StorageAutoGrow 

type StorageAutoGrow string

StorageAutoGrow - Flag to enable / disable Storage Auto grow for flexible server. 

const (
	StorageAutoGrowDisabled StorageAutoGrow = "Disabled"
	StorageAutoGrowEnabled  StorageAutoGrow = "Enabled"
)

func PossibleStorageAutoGrowValues 

func PossibleStorageAutoGrowValues() []StorageAutoGrow

PossibleStorageAutoGrowValues returns the possible values for the StorageAutoGrow const type.

type StorageAutoGrowthSupportedEnum 

type StorageAutoGrowthSupportedEnum string

StorageAutoGrowthSupportedEnum - A value indicating whether storage auto-grow is supported in this region. "Enabled" means storage auto-grow is supported. "Disabled" stands for storage auto-grow is not supported. 

const (
	StorageAutoGrowthSupportedEnumDisabled StorageAutoGrowthSupportedEnum = "Disabled"
	StorageAutoGrowthSupportedEnumEnabled  StorageAutoGrowthSupportedEnum = "Enabled"
)

func PossibleStorageAutoGrowthSupportedEnumValues 

func PossibleStorageAutoGrowthSupportedEnumValues() []StorageAutoGrowthSupportedEnum

PossibleStorageAutoGrowthSupportedEnumValues returns the possible values for the StorageAutoGrowthSupportedEnum const type.

type StorageEditionCapability 

type StorageEditionCapability struct {
	// READ-ONLY; Default storage size in MB for storage edition
	DefaultStorageSizeMb *int64

	// READ-ONLY; Storage edition name
	Name *string

	// READ-ONLY; The reason for the capability not being available.
	Reason *string

	// READ-ONLY; The status of the capability.
	Status *CapabilityStatus

	// READ-ONLY; Flexible server supported storage range in MB
	SupportedStorageMb []*StorageMbCapability
}

StorageEditionCapability - Storage edition capability

func (StorageEditionCapability) MarshalJSON 

func (s StorageEditionCapability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type StorageEditionCapability.

func (*StorageEditionCapability) UnmarshalJSON 

func (s *StorageEditionCapability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type StorageEditionCapability.

type StorageMbCapability 

type StorageMbCapability struct {
	// READ-ONLY; Default tier for IOPS
	DefaultIopsTier *string

	// READ-ONLY; Maximum value of Storage size in MB
	MaximumStorageSizeMb *int64

	// READ-ONLY; The reason for the capability not being available.
	Reason *string

	// READ-ONLY; The status of the capability.
	Status *CapabilityStatus

	// READ-ONLY; Storage size in MB
	StorageSizeMb *int64

	// READ-ONLY; Supported IOPS
	SupportedIops *int32

	// READ-ONLY; List of available options to upgrade the storage performance
	SupportedIopsTiers []*StorageTierCapability

	// READ-ONLY; Maximum IOPS supported by this #Vcores or PremiumV2_LRS Storage Size
	SupportedMaximumIops *int32

	// READ-ONLY; Maximum values of throughput in MB/s
	SupportedMaximumThroughput *int32

	// READ-ONLY; Values of throughput in MB/s
	SupportedThroughput *int32
}

StorageMbCapability - storage size in MB capability

func (StorageMbCapability) MarshalJSON 

func (s StorageMbCapability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type StorageMbCapability.

func (*StorageMbCapability) UnmarshalJSON 

func (s *StorageMbCapability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type StorageMbCapability.

type StorageTierCapability 

type StorageTierCapability struct {
	// READ-ONLY; Supported IOPS for this storage tier
	Iops *int32

	// READ-ONLY; Name to represent Storage tier capability
	Name *string

	// READ-ONLY; The reason for the capability not being available.
	Reason *string

	// READ-ONLY; The status of the capability.
	Status *CapabilityStatus
}

StorageTierCapability - Represents capability of a storage tier

func (StorageTierCapability) MarshalJSON 

func (s StorageTierCapability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type StorageTierCapability.

func (*StorageTierCapability) UnmarshalJSON 

func (s *StorageTierCapability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type StorageTierCapability.

type StorageType 

type StorageType string

StorageType - Storage type for the server. Allowed values are PremiumLRS and PremiumV2LRS, and default is Premium_LRS if not specified 

const (
	StorageTypePremiumLRS   StorageType = "Premium_LRS"
	StorageTypePremiumV2LRS StorageType = "PremiumV2_LRS"
)

func PossibleStorageTypeValues 

func PossibleStorageTypeValues() []StorageType

PossibleStorageTypeValues returns the possible values for the StorageType const type.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON 

func (s SystemData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

func (s *SystemData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type ThreatProtectionName 

type ThreatProtectionName string
const (
	ThreatProtectionNameDefault ThreatProtectionName = "Default"
)

func PossibleThreatProtectionNameValues 

func PossibleThreatProtectionNameValues() []ThreatProtectionName

PossibleThreatProtectionNameValues returns the possible values for the ThreatProtectionName const type.

type ThreatProtectionState 

type ThreatProtectionState string

ThreatProtectionState - Specifies the state of the Threat Protection, whether it is enabled or disabled or a state has not been applied yet on the specific server. 

const (
	ThreatProtectionStateDisabled ThreatProtectionState = "Disabled"
	ThreatProtectionStateEnabled  ThreatProtectionState = "Enabled"
)

func PossibleThreatProtectionStateValues 

func PossibleThreatProtectionStateValues() []ThreatProtectionState

PossibleThreatProtectionStateValues returns the possible values for the ThreatProtectionState const type.

type TriggerCutoverEnum 

type TriggerCutoverEnum string

TriggerCutoverEnum - To trigger cutover for entire migration we need to send this flag as True 

const (
	TriggerCutoverEnumFalse TriggerCutoverEnum = "False"
	TriggerCutoverEnumTrue  TriggerCutoverEnum = "True"
)

func PossibleTriggerCutoverEnumValues 

func PossibleTriggerCutoverEnumValues() []TriggerCutoverEnum

PossibleTriggerCutoverEnumValues returns the possible values for the TriggerCutoverEnum const type.

type UserAssignedIdentity 

type UserAssignedIdentity struct {
	// REQUIRED; the types of identities associated with this resource; currently restricted to 'None and UserAssigned'
	Type *IdentityType

	// represents user assigned identities map.
	UserAssignedIdentities map[string]*UserIdentity

	// READ-ONLY; Tenant id of the server.
	TenantID *string
}

UserAssignedIdentity - Information describing the identities associated with this application.

func (UserAssignedIdentity) MarshalJSON 

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON 

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type UserIdentity 

type UserIdentity struct {
	// the client identifier of the Service Principal which this identity represents.
	ClientID *string

	// the object identifier of the Service Principal which this identity represents.
	PrincipalID *string
}

UserIdentity - Describes a single user-assigned identity associated with the application.

func (UserIdentity) MarshalJSON 

func (u UserIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserIdentity.

func (*UserIdentity) UnmarshalJSON 

func (u *UserIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserIdentity.

type ValidationDetails 

type ValidationDetails struct {
	// Details of server level validations
	DbLevelValidationDetails []*DbLevelValidationStatus

	// Details of server level validations
	ServerLevelValidationDetails []*ValidationSummaryItem

	// Validation status for migration
	Status *ValidationState

	// Validation End date-time in UTC
	ValidationEndTimeInUTC *time.Time

	// Validation Start date-time in UTC
	ValidationStartTimeInUTC *time.Time
}

ValidationDetails - Details for the validation for migration

func (ValidationDetails) MarshalJSON 

func (v ValidationDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidationDetails.

func (*ValidationDetails) UnmarshalJSON 

func (v *ValidationDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidationDetails.

type ValidationMessage 

type ValidationMessage struct {
	// Validation message string
	Message *string

	// Severity of validation message
	State *ValidationState
}

ValidationMessage - Validation message object

func (ValidationMessage) MarshalJSON 

func (v ValidationMessage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidationMessage.

func (*ValidationMessage) UnmarshalJSON 

func (v *ValidationMessage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidationMessage.

type ValidationState 

type ValidationState string

ValidationState - Validation status for migration 

const (
	ValidationStateFailed    ValidationState = "Failed"
	ValidationStateSucceeded ValidationState = "Succeeded"
	ValidationStateWarning   ValidationState = "Warning"
)

func PossibleValidationStateValues 

func PossibleValidationStateValues() []ValidationState

PossibleValidationStateValues returns the possible values for the ValidationState const type.

type ValidationSummaryItem 

type ValidationSummaryItem struct {
	// Validation messages
	Messages []*ValidationMessage

	// Validation status for migration
	State *ValidationState

	// Validation type
	Type *string
}

ValidationSummaryItem - Validation summary object

func (ValidationSummaryItem) MarshalJSON 

func (v ValidationSummaryItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidationSummaryItem.

func (*ValidationSummaryItem) UnmarshalJSON 

func (v *ValidationSummaryItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidationSummaryItem.

type VirtualEndpointResource 

type VirtualEndpointResource struct {
	// Properties of the virtual endpoint resource.
	Properties *VirtualEndpointResourceProperties

	// 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
}

VirtualEndpointResource - Represents a virtual endpoint for a server.

func (VirtualEndpointResource) MarshalJSON 

func (v VirtualEndpointResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualEndpointResource.

func (*VirtualEndpointResource) UnmarshalJSON 

func (v *VirtualEndpointResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualEndpointResource.

type VirtualEndpointResourceForPatch 

type VirtualEndpointResourceForPatch struct {
	// Properties of the virtual endpoint resource.
	Properties *VirtualEndpointResourceProperties
}

VirtualEndpointResourceForPatch - Represents a virtual endpoint for a server.

func (VirtualEndpointResourceForPatch) MarshalJSON 

func (v VirtualEndpointResourceForPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualEndpointResourceForPatch.

func (*VirtualEndpointResourceForPatch) UnmarshalJSON 

func (v *VirtualEndpointResourceForPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualEndpointResourceForPatch.

type VirtualEndpointResourceProperties 

type VirtualEndpointResourceProperties struct {
	// The endpoint type for the virtual endpoint.
	EndpointType *VirtualEndpointType

	// List of members for a virtual endpoint
	Members []*string

	// READ-ONLY; List of virtual endpoints for a server
	VirtualEndpoints []*string
}

VirtualEndpointResourceProperties - The properties of a virtual endpoint.

func (VirtualEndpointResourceProperties) MarshalJSON 

func (v VirtualEndpointResourceProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualEndpointResourceProperties.

func (*VirtualEndpointResourceProperties) UnmarshalJSON 

func (v *VirtualEndpointResourceProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualEndpointResourceProperties.

type VirtualEndpointType 

type VirtualEndpointType string

VirtualEndpointType - The endpoint type for the virtual endpoint. 

const (
	VirtualEndpointTypeReadWrite VirtualEndpointType = "ReadWrite"
)

func PossibleVirtualEndpointTypeValues 

func PossibleVirtualEndpointTypeValues() []VirtualEndpointType

PossibleVirtualEndpointTypeValues returns the possible values for the VirtualEndpointType const type.

type VirtualEndpointsClient 

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

VirtualEndpointsClient contains the methods for the VirtualEndpoints group. Don't use this type directly, use NewVirtualEndpointsClient() instead.

func NewVirtualEndpointsClient 

func NewVirtualEndpointsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*VirtualEndpointsClient, error)

NewVirtualEndpointsClient creates a new instance of VirtualEndpointsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*VirtualEndpointsClient) BeginCreate 

func (client *VirtualEndpointsClient) BeginCreate(ctx context.Context, resourceGroupName string, serverName string, virtualEndpointName string, parameters VirtualEndpointResource, options *VirtualEndpointsClientBeginCreateOptions) (*runtime.Poller[VirtualEndpointsClientCreateResponse], error)

BeginCreate - Creates a new virtual endpoint for PostgreSQL flexible server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • virtualEndpointName - The name of the virtual endpoint.
  • parameters - The required parameters for creating or updating virtual endpoints.
  • options - VirtualEndpointsClientBeginCreateOptions contains the optional parameters for the VirtualEndpointsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/VirtualEndpointCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVirtualEndpointsClient().BeginCreate(ctx, "testrg", "pgtestsvc4", "pgVirtualEndpoint1", armpostgresqlflexibleservers.VirtualEndpointResource{
	Properties: &armpostgresqlflexibleservers.VirtualEndpointResourceProperties{
		EndpointType: to.Ptr(armpostgresqlflexibleservers.VirtualEndpointTypeReadWrite),
		Members: []*string{
			to.Ptr("testPrimary1")},
	},
}, 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.VirtualEndpointResource = armpostgresqlflexibleservers.VirtualEndpointResource{
// 	Name: to.Ptr("pgVirtualEndpoint1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/virtualEndpoints"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4/virtualEndpoints/pgVirtualEndpoint1"),
// 	Properties: &armpostgresqlflexibleservers.VirtualEndpointResourceProperties{
// 		EndpointType: to.Ptr(armpostgresqlflexibleservers.VirtualEndpointTypeReadWrite),
// 		Members: []*string{
// 			to.Ptr("testPrimary1")},
// 			VirtualEndpoints: []*string{
// 				to.Ptr("pgVirtualEndpoint1.reader.postgres.database.azure.com"),
// 				to.Ptr("pgVirtualEndpoint1.writer.postgres.database.azure.com")},
// 			},
// 		}

Output:

func (*VirtualEndpointsClient) BeginDelete 

func (client *VirtualEndpointsClient) BeginDelete(ctx context.Context, resourceGroupName string, serverName string, virtualEndpointName string, options *VirtualEndpointsClientBeginDeleteOptions) (*runtime.Poller[VirtualEndpointsClientDeleteResponse], error)

BeginDelete - Deletes a virtual endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • virtualEndpointName - The name of the virtual endpoint.
  • options - VirtualEndpointsClientBeginDeleteOptions contains the optional parameters for the VirtualEndpointsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/VirtualEndpointDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVirtualEndpointsClient().BeginDelete(ctx, "testrg", "pgtestsvc4", "pgVirtualEndpoint1", 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)
}

Output:

func (*VirtualEndpointsClient) BeginUpdate 

func (client *VirtualEndpointsClient) BeginUpdate(ctx context.Context, resourceGroupName string, serverName string, virtualEndpointName string, parameters VirtualEndpointResourceForPatch, options *VirtualEndpointsClientBeginUpdateOptions) (*runtime.Poller[VirtualEndpointsClientUpdateResponse], error)

BeginUpdate - Updates an existing virtual endpoint. The request body can contain one to many of the properties present in the normal virtual endpoint definition. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • virtualEndpointName - The name of the virtual endpoint.
  • parameters - The required parameters for updating a server.
  • options - VirtualEndpointsClientBeginUpdateOptions contains the optional parameters for the VirtualEndpointsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/VirtualEndpointUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewVirtualEndpointsClient().BeginUpdate(ctx, "testrg", "pgtestsvc4", "pgVirtualEndpoint1", armpostgresqlflexibleservers.VirtualEndpointResourceForPatch{
	Properties: &armpostgresqlflexibleservers.VirtualEndpointResourceProperties{
		EndpointType: to.Ptr(armpostgresqlflexibleservers.VirtualEndpointTypeReadWrite),
		Members: []*string{
			to.Ptr("testReplica1")},
	},
}, 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.VirtualEndpointResource = armpostgresqlflexibleservers.VirtualEndpointResource{
// 	Name: to.Ptr("pgVirtualEndpoint1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/virtualEndpoints"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4/virtualEndpoints/pgVirtualEndpoint1"),
// 	Properties: &armpostgresqlflexibleservers.VirtualEndpointResourceProperties{
// 		EndpointType: to.Ptr(armpostgresqlflexibleservers.VirtualEndpointTypeReadWrite),
// 		Members: []*string{
// 			to.Ptr("testReplica1")},
// 			VirtualEndpoints: []*string{
// 				to.Ptr("pgVirtualEndpoint1.reader.postgres.database.azure.com"),
// 				to.Ptr("pgVirtualEndpoint1.writer.postgres.database.azure.com")},
// 			},
// 		}

Output:

func (*VirtualEndpointsClient) Get 

func (client *VirtualEndpointsClient) Get(ctx context.Context, resourceGroupName string, serverName string, virtualEndpointName string, options *VirtualEndpointsClientGetOptions) (VirtualEndpointsClientGetResponse, error)

Get - Gets information about a virtual endpoint. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • virtualEndpointName - The name of the virtual endpoint.
  • options - VirtualEndpointsClientGetOptions contains the optional parameters for the VirtualEndpointsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/VirtualEndpointsGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewVirtualEndpointsClient().Get(ctx, "testrg", "pgtestsvc4", "pgVirtualEndpoint1", 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.VirtualEndpointResource = armpostgresqlflexibleservers.VirtualEndpointResource{
// 	Name: to.Ptr("pgVirtualEndpoint1"),
// 	Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/virtualEndpoints"),
// 	ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4/virtualEndpoints/pgVirtualEndpoint1"),
// 	Properties: &armpostgresqlflexibleservers.VirtualEndpointResourceProperties{
// 		EndpointType: to.Ptr(armpostgresqlflexibleservers.VirtualEndpointTypeReadWrite),
// 		Members: []*string{
// 			to.Ptr("testReplica1")},
// 			VirtualEndpoints: []*string{
// 				to.Ptr("pgVirtualEndpoint1.reader.postgres.database.azure.com"),
// 				to.Ptr("pgVirtualEndpoint1.writer.postgres.database.azure.com")},
// 			},
// 		}

Output:

func (*VirtualEndpointsClient) NewListByServerPager 

func (client *VirtualEndpointsClient) NewListByServerPager(resourceGroupName string, serverName string, options *VirtualEndpointsClientListByServerOptions) *runtime.Pager[VirtualEndpointsClientListByServerResponse]

NewListByServerPager - List all the servers in a given resource group.

Generated from API version 2023-12-01-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • serverName - The name of the server.
  • options - VirtualEndpointsClientListByServerOptions contains the optional parameters for the VirtualEndpointsClient.NewListByServerPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/VirtualEndpointsListByServer.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewVirtualEndpointsClient().NewListByServerPager("testrg", "pgtestsvc4", 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.VirtualEndpointsListResult = armpostgresqlflexibleservers.VirtualEndpointsListResult{
	// 	Value: []*armpostgresqlflexibleservers.VirtualEndpointResource{
	// 		{
	// 			Name: to.Ptr("pgVirtualEndpoint1"),
	// 			Type: to.Ptr("Microsoft.DBforPostgreSQL/flexibleServers/virtualEndpoints"),
	// 			ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/flexibleServers/pgtestsvc4/virtualEndpoints/pgVirtualEndpoint1"),
	// 			Properties: &armpostgresqlflexibleservers.VirtualEndpointResourceProperties{
	// 				EndpointType: to.Ptr(armpostgresqlflexibleservers.VirtualEndpointTypeReadWrite),
	// 				Members: []*string{
	// 					to.Ptr("testReplica1")},
	// 					VirtualEndpoints: []*string{
	// 						to.Ptr("pgVirtualEndpoint1.reader.postgres.database.azure.com"),
	// 						to.Ptr("pgVirtualEndpoint1.writer.postgres.database.azure.com")},
	// 					},
	// 			}},
	// 		}
}

Output:

type VirtualEndpointsClientBeginCreateOptions 

type VirtualEndpointsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

VirtualEndpointsClientBeginCreateOptions contains the optional parameters for the VirtualEndpointsClient.BeginCreate method.

type VirtualEndpointsClientBeginDeleteOptions 

type VirtualEndpointsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

VirtualEndpointsClientBeginDeleteOptions contains the optional parameters for the VirtualEndpointsClient.BeginDelete method.

type VirtualEndpointsClientBeginUpdateOptions 

type VirtualEndpointsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

VirtualEndpointsClientBeginUpdateOptions contains the optional parameters for the VirtualEndpointsClient.BeginUpdate method.

type VirtualEndpointsClientCreateResponse 

type VirtualEndpointsClientCreateResponse struct {
	// Represents a virtual endpoint for a server.
	VirtualEndpointResource
}

VirtualEndpointsClientCreateResponse contains the response from method VirtualEndpointsClient.BeginCreate.

type VirtualEndpointsClientDeleteResponse 

type VirtualEndpointsClientDeleteResponse struct {
}

VirtualEndpointsClientDeleteResponse contains the response from method VirtualEndpointsClient.BeginDelete.

type VirtualEndpointsClientGetOptions 

type VirtualEndpointsClientGetOptions struct {
}

VirtualEndpointsClientGetOptions contains the optional parameters for the VirtualEndpointsClient.Get method.

type VirtualEndpointsClientGetResponse 

type VirtualEndpointsClientGetResponse struct {
	// Represents a virtual endpoint for a server.
	VirtualEndpointResource
}

VirtualEndpointsClientGetResponse contains the response from method VirtualEndpointsClient.Get.

type VirtualEndpointsClientListByServerOptions 

type VirtualEndpointsClientListByServerOptions struct {
}

VirtualEndpointsClientListByServerOptions contains the optional parameters for the VirtualEndpointsClient.NewListByServerPager method.

type VirtualEndpointsClientListByServerResponse 

type VirtualEndpointsClientListByServerResponse struct {
	// A list of virtual endpoints.
	VirtualEndpointsListResult
}

VirtualEndpointsClientListByServerResponse contains the response from method VirtualEndpointsClient.NewListByServerPager.

type VirtualEndpointsClientUpdateResponse 

type VirtualEndpointsClientUpdateResponse struct {
	// Represents a virtual endpoint for a server.
	VirtualEndpointResource
}

VirtualEndpointsClientUpdateResponse contains the response from method VirtualEndpointsClient.BeginUpdate.

type VirtualEndpointsListResult 

type VirtualEndpointsListResult struct {
	// The link used to get the next page of operations.
	NextLink *string

	// The list of virtual endpoints
	Value []*VirtualEndpointResource
}

VirtualEndpointsListResult - A list of virtual endpoints.

func (VirtualEndpointsListResult) MarshalJSON 

func (v VirtualEndpointsListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualEndpointsListResult.

func (*VirtualEndpointsListResult) UnmarshalJSON 

func (v *VirtualEndpointsListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualEndpointsListResult.

type VirtualNetworkSubnetUsageClient 

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

VirtualNetworkSubnetUsageClient contains the methods for the VirtualNetworkSubnetUsage group. Don't use this type directly, use NewVirtualNetworkSubnetUsageClient() instead.

func NewVirtualNetworkSubnetUsageClient 

func NewVirtualNetworkSubnetUsageClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*VirtualNetworkSubnetUsageClient, error)

NewVirtualNetworkSubnetUsageClient creates a new instance of VirtualNetworkSubnetUsageClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*VirtualNetworkSubnetUsageClient) Execute 

func (client *VirtualNetworkSubnetUsageClient) Execute(ctx context.Context, locationName string, parameters VirtualNetworkSubnetUsageParameter, options *VirtualNetworkSubnetUsageClientExecuteOptions) (VirtualNetworkSubnetUsageClientExecuteResponse, error)

Execute - Get virtual network subnet usage for a given vNet resource id. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-12-01-preview

  • locationName - The name of the location.
  • parameters - The required parameters for creating or updating a server.
  • options - VirtualNetworkSubnetUsageClientExecuteOptions contains the optional parameters for the VirtualNetworkSubnetUsageClient.Execute method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/92de53a5f1e0e03c94b40475d2135d97148ed014/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/preview/2023-12-01-preview/examples/VirtualNetworkSubnetUsage.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewVirtualNetworkSubnetUsageClient().Execute(ctx, "westus", armpostgresqlflexibleservers.VirtualNetworkSubnetUsageParameter{
	VirtualNetworkArmResourceID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/testvnet"),
}, 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.VirtualNetworkSubnetUsageResult = armpostgresqlflexibleservers.VirtualNetworkSubnetUsageResult{
// 	DelegatedSubnetsUsage: []*armpostgresqlflexibleservers.DelegatedSubnetUsage{
// 		{
// 			SubnetName: to.Ptr("test-subnet-1"),
// 			Usage: to.Ptr[int64](2),
// 		},
// 		{
// 			SubnetName: to.Ptr("test-subnet-2"),
// 			Usage: to.Ptr[int64](3),
// 	}},
// 	Location: to.Ptr("westus"),
// 	SubscriptionID: to.Ptr("ffffffff-ffff-ffff-ffff-ffffffffffff"),
// }

Output:

type VirtualNetworkSubnetUsageClientExecuteOptions 

type VirtualNetworkSubnetUsageClientExecuteOptions struct {
}

VirtualNetworkSubnetUsageClientExecuteOptions contains the optional parameters for the VirtualNetworkSubnetUsageClient.Execute method.

type VirtualNetworkSubnetUsageClientExecuteResponse 

type VirtualNetworkSubnetUsageClientExecuteResponse struct {
	// Virtual network subnet usage data.
	VirtualNetworkSubnetUsageResult
}

VirtualNetworkSubnetUsageClientExecuteResponse contains the response from method VirtualNetworkSubnetUsageClient.Execute.

type VirtualNetworkSubnetUsageParameter 

type VirtualNetworkSubnetUsageParameter struct {
	// Virtual network resource id.
	VirtualNetworkArmResourceID *string
}

VirtualNetworkSubnetUsageParameter - Virtual network subnet usage parameter

func (VirtualNetworkSubnetUsageParameter) MarshalJSON 

func (v VirtualNetworkSubnetUsageParameter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualNetworkSubnetUsageParameter.

func (*VirtualNetworkSubnetUsageParameter) UnmarshalJSON 

func (v *VirtualNetworkSubnetUsageParameter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualNetworkSubnetUsageParameter.

type VirtualNetworkSubnetUsageResult 

type VirtualNetworkSubnetUsageResult struct {
	// READ-ONLY
	DelegatedSubnetsUsage []*DelegatedSubnetUsage

	// READ-ONLY; location of the delegated subnet usage
	Location *string

	// READ-ONLY; subscriptionId of the delegated subnet usage
	SubscriptionID *string
}

VirtualNetworkSubnetUsageResult - Virtual network subnet usage data.

func (VirtualNetworkSubnetUsageResult) MarshalJSON 

func (v VirtualNetworkSubnetUsageResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualNetworkSubnetUsageResult.

func (*VirtualNetworkSubnetUsageResult) UnmarshalJSON 

func (v *VirtualNetworkSubnetUsageResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualNetworkSubnetUsageResult.

type ZoneRedundantHaAndGeoBackupSupportedEnum 

type ZoneRedundantHaAndGeoBackupSupportedEnum string

ZoneRedundantHaAndGeoBackupSupportedEnum - A value indicating whether Zone Redundant HA and Geo-backup is supported in this region. "Enabled" means zone redundant HA and geo-backup is supported. "Disabled" stands for zone redundant HA and geo-backup is not supported. 

const (
	ZoneRedundantHaAndGeoBackupSupportedEnumDisabled ZoneRedundantHaAndGeoBackupSupportedEnum = "Disabled"
	ZoneRedundantHaAndGeoBackupSupportedEnumEnabled  ZoneRedundantHaAndGeoBackupSupportedEnum = "Enabled"
)

func PossibleZoneRedundantHaAndGeoBackupSupportedEnumValues 

func PossibleZoneRedundantHaAndGeoBackupSupportedEnumValues() []ZoneRedundantHaAndGeoBackupSupportedEnum

PossibleZoneRedundantHaAndGeoBackupSupportedEnumValues returns the possible values for the ZoneRedundantHaAndGeoBackupSupportedEnum const type.

type ZoneRedundantHaSupportedEnum 

type ZoneRedundantHaSupportedEnum string

ZoneRedundantHaSupportedEnum - A value indicating whether Zone Redundant HA is supported in this region. "Enabled" means zone redundant HA is supported. "Disabled" stands for zone redundant HA is not supported. 

const (
	ZoneRedundantHaSupportedEnumDisabled ZoneRedundantHaSupportedEnum = "Disabled"
	ZoneRedundantHaSupportedEnumEnabled  ZoneRedundantHaSupportedEnum = "Enabled"
)

func PossibleZoneRedundantHaSupportedEnumValues 

func PossibleZoneRedundantHaSupportedEnumValues() []ZoneRedundantHaSupportedEnum

PossibleZoneRedundantHaSupportedEnumValues returns the possible values for the ZoneRedundantHaSupportedEnum const type.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.