diff --git a/sdk/resourcemanager/keyvault/armkeyvault/CHANGELOG.md b/sdk/resourcemanager/keyvault/armkeyvault/CHANGELOG.md index 4fa9c127289d..8e1dfa68deb4 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/CHANGELOG.md +++ b/sdk/resourcemanager/keyvault/armkeyvault/CHANGELOG.md @@ -1,33 +1,70 @@ # Release History -## 1.1.0-beta.2 (2023-03-27) -### Features Added - -- New struct `ClientFactory` which is a client factory used to create any client in this module +## 2.0.0 (2023-04-07) +### Breaking Changes +- Struct `CloudError` has been removed +- Struct `CloudErrorBody` has been removed -## 1.1.0-beta.1 (2022-05-19) ### Features Added -- New const `KeyRotationPolicyActionTypeNotify` -- New const `JSONWebKeyOperationRelease` -- New const `KeyRotationPolicyActionTypeRotate` -- New const `KeyPermissionsRotate` -- New const `KeyPermissionsRelease` -- New const `KeyPermissionsSetrotationpolicy` -- New const `KeyPermissionsGetrotationpolicy` -- New function `PossibleKeyRotationPolicyActionTypeValues() []KeyRotationPolicyActionType` -- New function `*KeyReleasePolicy.UnmarshalJSON([]byte) error` -- New function `KeyReleasePolicy.MarshalJSON() ([]byte, error)` -- New function `RotationPolicy.MarshalJSON() ([]byte, error)` +- New value `JSONWebKeyOperationRelease` added to enum type `JSONWebKeyOperation` +- New value `KeyPermissionsGetrotationpolicy`, `KeyPermissionsRelease`, `KeyPermissionsRotate`, `KeyPermissionsSetrotationpolicy` added to enum type `KeyPermissions` +- New value `ManagedHsmSKUNameCustomB6` added to enum type `ManagedHsmSKUName` +- New enum type `ActivationStatus` with values `ActivationStatusActive`, `ActivationStatusFailed`, `ActivationStatusNotActivated`, `ActivationStatusUnknown` +- New enum type `GeoReplicationRegionProvisioningState` with values `GeoReplicationRegionProvisioningStateCleanup`, `GeoReplicationRegionProvisioningStateDeleting`, `GeoReplicationRegionProvisioningStateFailed`, `GeoReplicationRegionProvisioningStatePreprovisioning`, `GeoReplicationRegionProvisioningStateProvisioning`, `GeoReplicationRegionProvisioningStateSucceeded` +- New enum type `KeyRotationPolicyActionType` with values `KeyRotationPolicyActionTypeNotify`, `KeyRotationPolicyActionTypeRotate` +- New function `NewClientFactory(string, azcore.TokenCredential, *arm.ClientOptions) (*ClientFactory, error)` +- New function `*ClientFactory.NewKeysClient() *KeysClient` +- New function `*ClientFactory.NewMHSMPrivateEndpointConnectionsClient() *MHSMPrivateEndpointConnectionsClient` +- New function `*ClientFactory.NewMHSMPrivateLinkResourcesClient() *MHSMPrivateLinkResourcesClient` +- New function `*ClientFactory.NewMHSMRegionsClient() *MHSMRegionsClient` +- New function `*ClientFactory.NewManagedHsmKeysClient() *ManagedHsmKeysClient` +- New function `*ClientFactory.NewManagedHsmsClient() *ManagedHsmsClient` +- New function `*ClientFactory.NewOperationsClient() *OperationsClient` +- New function `*ClientFactory.NewPrivateEndpointConnectionsClient() *PrivateEndpointConnectionsClient` +- New function `*ClientFactory.NewPrivateLinkResourcesClient() *PrivateLinkResourcesClient` +- New function `*ClientFactory.NewSecretsClient() *SecretsClient` +- New function `*ClientFactory.NewVaultsClient() *VaultsClient` +- New function `NewMHSMRegionsClient(string, azcore.TokenCredential, *arm.ClientOptions) (*MHSMRegionsClient, error)` +- New function `*MHSMRegionsClient.NewListByResourcePager(string, string, *MHSMRegionsClientListByResourceOptions) *runtime.Pager[MHSMRegionsClientListByResourceResponse]` +- New function `NewManagedHsmKeysClient(string, azcore.TokenCredential, *arm.ClientOptions) (*ManagedHsmKeysClient, error)` +- New function `*ManagedHsmKeysClient.CreateIfNotExist(context.Context, string, string, string, ManagedHsmKeyCreateParameters, *ManagedHsmKeysClientCreateIfNotExistOptions) (ManagedHsmKeysClientCreateIfNotExistResponse, error)` +- New function `*ManagedHsmKeysClient.Get(context.Context, string, string, string, *ManagedHsmKeysClientGetOptions) (ManagedHsmKeysClientGetResponse, error)` +- New function `*ManagedHsmKeysClient.GetVersion(context.Context, string, string, string, string, *ManagedHsmKeysClientGetVersionOptions) (ManagedHsmKeysClientGetVersionResponse, error)` +- New function `*ManagedHsmKeysClient.NewListPager(string, string, *ManagedHsmKeysClientListOptions) *runtime.Pager[ManagedHsmKeysClientListResponse]` +- New function `*ManagedHsmKeysClient.NewListVersionsPager(string, string, string, *ManagedHsmKeysClientListVersionsOptions) *runtime.Pager[ManagedHsmKeysClientListVersionsResponse]` +- New function `*ManagedHsmsClient.CheckMhsmNameAvailability(context.Context, CheckMhsmNameAvailabilityParameters, *ManagedHsmsClientCheckMhsmNameAvailabilityOptions) (ManagedHsmsClientCheckMhsmNameAvailabilityResponse, error)` - New struct `Action` +- New struct `CheckMhsmNameAvailabilityParameters` +- New struct `CheckMhsmNameAvailabilityResult` +- New struct `ClientFactory` - New struct `KeyReleasePolicy` - New struct `KeyRotationPolicyAttributes` - New struct `LifetimeAction` +- New struct `MHSMGeoReplicatedRegion` +- New struct `MHSMRegionsListResult` +- New struct `ManagedHSMSecurityDomainProperties` +- New struct `ManagedHsmAction` +- New struct `ManagedHsmKey` +- New struct `ManagedHsmKeyAttributes` +- New struct `ManagedHsmKeyCreateParameters` +- New struct `ManagedHsmKeyListResult` +- New struct `ManagedHsmKeyProperties` +- New struct `ManagedHsmKeyReleasePolicy` +- New struct `ManagedHsmKeyRotationPolicyAttributes` +- New struct `ManagedHsmLifetimeAction` +- New struct `ManagedHsmRotationPolicy` +- New struct `ManagedHsmTrigger` +- New struct `ProxyResourceWithoutSystemData` - New struct `RotationPolicy` - New struct `Trigger` - New field `ReleasePolicy` in struct `KeyProperties` - New field `RotationPolicy` in struct `KeyProperties` +- New field `Etag` in struct `MHSMPrivateEndpointConnectionItem` +- New field `ID` in struct `MHSMPrivateEndpointConnectionItem` +- New field `Regions` in struct `ManagedHsmProperties` +- New field `SecurityDomainProperties` in struct `ManagedHsmProperties` ## 1.0.0 (2022-05-16) diff --git a/sdk/resourcemanager/keyvault/armkeyvault/autorest.md b/sdk/resourcemanager/keyvault/armkeyvault/autorest.md index 5596125974a7..9efc0ab5f00a 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/autorest.md +++ b/sdk/resourcemanager/keyvault/armkeyvault/autorest.md @@ -5,10 +5,10 @@ ``` yaml azure-arm: true require: -- https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/readme.md -- https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/readme.go.md +- /mnt/vss/_work/1/s/azure-rest-api-specs/specification/keyvault/resource-manager/readme.md +- /mnt/vss/_work/1/s/azure-rest-api-specs/specification/keyvault/resource-manager/readme.go.md license-header: MICROSOFT_MIT_NO_VERSION -module-version: 1.1.0-beta.2 +module-version: 2.0.0 modelerfour: seal-single-value-enum-by-default: true ``` \ No newline at end of file diff --git a/sdk/resourcemanager/keyvault/armkeyvault/client_factory.go b/sdk/resourcemanager/keyvault/armkeyvault/client_factory.go index 2cb7fe6d75ed..ff61f9101ef7 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/client_factory.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/client_factory.go @@ -44,6 +44,11 @@ func (c *ClientFactory) NewKeysClient() *KeysClient { return subClient } +func (c *ClientFactory) NewManagedHsmKeysClient() *ManagedHsmKeysClient { + subClient, _ := NewManagedHsmKeysClient(c.subscriptionID, c.credential, c.options) + return subClient +} + func (c *ClientFactory) NewVaultsClient() *VaultsClient { subClient, _ := NewVaultsClient(c.subscriptionID, c.credential, c.options) return subClient @@ -74,6 +79,11 @@ func (c *ClientFactory) NewMHSMPrivateLinkResourcesClient() *MHSMPrivateLinkReso return subClient } +func (c *ClientFactory) NewMHSMRegionsClient() *MHSMRegionsClient { + subClient, _ := NewMHSMRegionsClient(c.subscriptionID, c.credential, c.options) + return subClient +} + func (c *ClientFactory) NewOperationsClient() *OperationsClient { subClient, _ := NewOperationsClient(c.credential, c.options) return subClient diff --git a/sdk/resourcemanager/keyvault/armkeyvault/constants.go b/sdk/resourcemanager/keyvault/armkeyvault/constants.go index 921e27d4c04a..940e9446f7e6 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/constants.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/constants.go @@ -11,7 +11,7 @@ package armkeyvault const ( moduleName = "armkeyvault" - moduleVersion = "v1.1.0-beta.2" + moduleVersion = "v2.0.0" ) type AccessPolicyUpdateKind string @@ -45,6 +45,30 @@ func PossibleActionsRequiredValues() []ActionsRequired { } } +// ActivationStatus - Activation Status +type ActivationStatus string + +const ( + // ActivationStatusActive - The managed HSM Pool is active. + ActivationStatusActive ActivationStatus = "Active" + // ActivationStatusFailed - Failed to activate managed hsm. + ActivationStatusFailed ActivationStatus = "Failed" + // ActivationStatusNotActivated - The managed HSM Pool is not yet activated. + ActivationStatusNotActivated ActivationStatus = "NotActivated" + // ActivationStatusUnknown - An unknown error occurred while activating managed hsm. + ActivationStatusUnknown ActivationStatus = "Unknown" +) + +// PossibleActivationStatusValues returns the possible values for the ActivationStatus const type. +func PossibleActivationStatusValues() []ActivationStatus { + return []ActivationStatus{ + ActivationStatusActive, + ActivationStatusFailed, + ActivationStatusNotActivated, + ActivationStatusUnknown, + } +} + type CertificatePermissions string const ( @@ -128,6 +152,30 @@ func PossibleDeletionRecoveryLevelValues() []DeletionRecoveryLevel { } } +// GeoReplicationRegionProvisioningState - The current provisioning state. +type GeoReplicationRegionProvisioningState string + +const ( + GeoReplicationRegionProvisioningStateCleanup GeoReplicationRegionProvisioningState = "Cleanup" + GeoReplicationRegionProvisioningStateDeleting GeoReplicationRegionProvisioningState = "Deleting" + GeoReplicationRegionProvisioningStateFailed GeoReplicationRegionProvisioningState = "Failed" + GeoReplicationRegionProvisioningStatePreprovisioning GeoReplicationRegionProvisioningState = "Preprovisioning" + GeoReplicationRegionProvisioningStateProvisioning GeoReplicationRegionProvisioningState = "Provisioning" + GeoReplicationRegionProvisioningStateSucceeded GeoReplicationRegionProvisioningState = "Succeeded" +) + +// PossibleGeoReplicationRegionProvisioningStateValues returns the possible values for the GeoReplicationRegionProvisioningState const type. +func PossibleGeoReplicationRegionProvisioningStateValues() []GeoReplicationRegionProvisioningState { + return []GeoReplicationRegionProvisioningState{ + GeoReplicationRegionProvisioningStateCleanup, + GeoReplicationRegionProvisioningStateDeleting, + GeoReplicationRegionProvisioningStateFailed, + GeoReplicationRegionProvisioningStatePreprovisioning, + GeoReplicationRegionProvisioningStateProvisioning, + GeoReplicationRegionProvisioningStateSucceeded, + } +} + // IdentityType - The type of identity. type IdentityType string @@ -305,6 +353,7 @@ type ManagedHsmSKUName string const ( ManagedHsmSKUNameStandardB1 ManagedHsmSKUName = "Standard_B1" ManagedHsmSKUNameCustomB32 ManagedHsmSKUName = "Custom_B32" + ManagedHsmSKUNameCustomB6 ManagedHsmSKUName = "Custom_B6" ) // PossibleManagedHsmSKUNameValues returns the possible values for the ManagedHsmSKUName const type. @@ -312,6 +361,7 @@ func PossibleManagedHsmSKUNameValues() []ManagedHsmSKUName { return []ManagedHsmSKUName{ ManagedHsmSKUNameStandardB1, ManagedHsmSKUNameCustomB32, + ManagedHsmSKUNameCustomB6, } } @@ -429,7 +479,7 @@ func PossibleProvisioningStateValues() []ProvisioningState { } } -// PublicNetworkAccess - Control permission for data plane traffic coming from public networks while private endpoint is enabled. +// PublicNetworkAccess - Control permission to the managed HSM from public networks. type PublicNetworkAccess string const ( diff --git a/sdk/resourcemanager/keyvault/armkeyvault/go.mod b/sdk/resourcemanager/keyvault/armkeyvault/go.mod index 10794b172667..11cd78fc6c62 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/go.mod +++ b/sdk/resourcemanager/keyvault/armkeyvault/go.mod @@ -1,15 +1,15 @@ -module github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault +module github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault/v2 go 1.18 require ( github.com/Azure/azure-sdk-for-go/sdk/azcore v1.4.0 - github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.2.0 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/internal v1.1.2 github.com/stretchr/testify v1.7.0 ) require ( + github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.2.0 // indirect github.com/Azure/azure-sdk-for-go/sdk/internal v1.2.0 // indirect github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources v1.0.0 // indirect github.com/AzureAD/microsoft-authentication-library-for-go v0.7.0 // indirect diff --git a/sdk/resourcemanager/keyvault/armkeyvault/keys_client.go b/sdk/resourcemanager/keyvault/armkeyvault/keys_client.go index 7e9dd960e75f..bd55b5b7cc2c 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/keys_client.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/keys_client.go @@ -50,10 +50,12 @@ func NewKeysClient(subscriptionID string, credential azcore.TokenCredential, opt // versions, and does not update existing keys. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the resource group which contains the specified key vault. // - vaultName - The name of the key vault which contains the key to be created. -// - keyName - The name of the key to be created. +// - keyName - The name of the key to be created. The value you provide may be copied globally for the purpose of running the +// service. The value provided should not include personally identifiable or sensitive +// information. // - parameters - The parameters used to create the specified key. // - options - KeysClientCreateIfNotExistOptions contains the optional parameters for the KeysClient.CreateIfNotExist method. func (client *KeysClient) CreateIfNotExist(ctx context.Context, resourceGroupName string, vaultName string, keyName string, parameters KeyCreateParameters, options *KeysClientCreateIfNotExistOptions) (KeysClientCreateIfNotExistResponse, error) { @@ -95,7 +97,7 @@ func (client *KeysClient) createIfNotExistCreateRequest(ctx context.Context, res return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, parameters) @@ -113,7 +115,7 @@ func (client *KeysClient) createIfNotExistHandleResponse(resp *http.Response) (K // Get - Gets the current version of the specified key from the specified key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the resource group which contains the specified key vault. // - vaultName - The name of the vault which contains the key to be retrieved. // - keyName - The name of the key to be retrieved. @@ -157,7 +159,7 @@ func (client *KeysClient) getCreateRequest(ctx context.Context, resourceGroupNam return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -175,7 +177,7 @@ func (client *KeysClient) getHandleResponse(resp *http.Response) (KeysClientGetR // GetVersion - Gets the specified version of the specified key in the specified key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the resource group which contains the specified key vault. // - vaultName - The name of the vault which contains the key version to be retrieved. // - keyName - The name of the key version to be retrieved. @@ -224,7 +226,7 @@ func (client *KeysClient) getVersionCreateRequest(ctx context.Context, resourceG return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -241,7 +243,7 @@ func (client *KeysClient) getVersionHandleResponse(resp *http.Response) (KeysCli // NewListPager - Lists the keys in the specified key vault. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the resource group which contains the specified key vault. // - vaultName - The name of the vault which contains the keys to be retrieved. // - options - KeysClientListOptions contains the optional parameters for the KeysClient.NewListPager method. @@ -293,7 +295,7 @@ func (client *KeysClient) listCreateRequest(ctx context.Context, resourceGroupNa return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -310,7 +312,7 @@ func (client *KeysClient) listHandleResponse(resp *http.Response) (KeysClientLis // NewListVersionsPager - Lists the versions of the specified key in the specified key vault. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the resource group which contains the specified key vault. // - vaultName - The name of the vault which contains the key versions to be retrieved. // - keyName - The name of the key versions to be retrieved. @@ -367,7 +369,7 @@ func (client *KeysClient) listVersionsCreateRequest(ctx context.Context, resourc return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil diff --git a/sdk/resourcemanager/keyvault/armkeyvault/keys_client_example_test.go b/sdk/resourcemanager/keyvault/armkeyvault/keys_client_example_test.go deleted file mode 100644 index 54261b66162a..000000000000 --- a/sdk/resourcemanager/keyvault/armkeyvault/keys_client_example_test.go +++ /dev/null @@ -1,276 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armkeyvault_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/createKey.json -func ExampleKeysClient_CreateIfNotExist() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewKeysClient().CreateIfNotExist(ctx, "sample-group", "sample-vault-name", "sample-key-name", armkeyvault.KeyCreateParameters{ - Properties: &armkeyvault.KeyProperties{ - Kty: to.Ptr(armkeyvault.JSONWebKeyTypeRSA), - }, - }, 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.Key = armkeyvault.Key{ - // Name: to.Ptr("sample-key-name"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/keys"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault-name/keys/sample-key-name"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.KeyProperties{ - // Attributes: &armkeyvault.KeyAttributes{ - // Created: to.Ptr[int64](1598533051), - // Enabled: to.Ptr(true), - // RecoveryLevel: to.Ptr(armkeyvault.DeletionRecoveryLevelPurgeable), - // Updated: to.Ptr[int64](1598533051), - // }, - // KeyOps: []*armkeyvault.JSONWebKeyOperation{ - // to.Ptr(armkeyvault.JSONWebKeyOperationEncrypt), - // to.Ptr(armkeyvault.JSONWebKeyOperationDecrypt), - // to.Ptr(armkeyvault.JSONWebKeyOperationSign), - // to.Ptr(armkeyvault.JSONWebKeyOperationVerify), - // to.Ptr(armkeyvault.JSONWebKeyOperationWrapKey), - // to.Ptr(armkeyvault.JSONWebKeyOperationUnwrapKey)}, - // KeySize: to.Ptr[int32](2048), - // KeyURI: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name"), - // KeyURIWithVersion: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name/fd618d9519b74f9aae94ade66b876acc"), - // Kty: to.Ptr(armkeyvault.JSONWebKeyTypeRSA), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/getKey.json -func ExampleKeysClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewKeysClient().Get(ctx, "sample-group", "sample-vault-name", "sample-key-name", 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.Key = armkeyvault.Key{ - // Name: to.Ptr("sample-key-name"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/keys"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault-name/keys/sample-key-name"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.KeyProperties{ - // Attributes: &armkeyvault.KeyAttributes{ - // Created: to.Ptr[int64](1598533051), - // Enabled: to.Ptr(true), - // RecoveryLevel: to.Ptr(armkeyvault.DeletionRecoveryLevelPurgeable), - // Updated: to.Ptr[int64](1598533051), - // }, - // KeyOps: []*armkeyvault.JSONWebKeyOperation{ - // to.Ptr(armkeyvault.JSONWebKeyOperationEncrypt), - // to.Ptr(armkeyvault.JSONWebKeyOperationDecrypt), - // to.Ptr(armkeyvault.JSONWebKeyOperationSign), - // to.Ptr(armkeyvault.JSONWebKeyOperationVerify), - // to.Ptr(armkeyvault.JSONWebKeyOperationWrapKey), - // to.Ptr(armkeyvault.JSONWebKeyOperationUnwrapKey)}, - // KeySize: to.Ptr[int32](2048), - // KeyURI: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name"), - // KeyURIWithVersion: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name/fd618d9519b74f9aae94ade66b876acc"), - // Kty: to.Ptr(armkeyvault.JSONWebKeyTypeRSA), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/listKeys.json -func ExampleKeysClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewKeysClient().NewListPager("sample-group", "sample-vault-name", 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.KeyListResult = armkeyvault.KeyListResult{ - // Value: []*armkeyvault.Key{ - // { - // Name: to.Ptr("sample-key-name-1"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/keys"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault-name/keys/sample-key-name-1"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.KeyProperties{ - // Attributes: &armkeyvault.KeyAttributes{ - // Created: to.Ptr[int64](1596493796), - // Enabled: to.Ptr(true), - // RecoveryLevel: to.Ptr(armkeyvault.DeletionRecoveryLevelPurgeable), - // Updated: to.Ptr[int64](1596493796), - // }, - // KeyURI: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name-1"), - // }, - // }, - // { - // Name: to.Ptr("sample-key-name-2"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/keys"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault-name/keys/sample-key-name-2"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.KeyProperties{ - // Attributes: &armkeyvault.KeyAttributes{ - // Created: to.Ptr[int64](1596493797), - // Enabled: to.Ptr(true), - // RecoveryLevel: to.Ptr(armkeyvault.DeletionRecoveryLevelPurgeable), - // Updated: to.Ptr[int64](1596493797), - // }, - // KeyURI: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name-2"), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/getKeyVersion.json -func ExampleKeysClient_GetVersion() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewKeysClient().GetVersion(ctx, "sample-group", "sample-vault-name", "sample-key-name", "fd618d9519b74f9aae94ade66b876acc", 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.Key = armkeyvault.Key{ - // Name: to.Ptr("fd618d9519b74f9aae94ade66b876acc"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/keys/versions"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault-name/keys/sample-key-name/versions/fd618d9519b74f9aae94ade66b876acc"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.KeyProperties{ - // Attributes: &armkeyvault.KeyAttributes{ - // Created: to.Ptr[int64](1598533051), - // Enabled: to.Ptr(true), - // RecoveryLevel: to.Ptr(armkeyvault.DeletionRecoveryLevelPurgeable), - // Updated: to.Ptr[int64](1598533051), - // }, - // KeyOps: []*armkeyvault.JSONWebKeyOperation{ - // to.Ptr(armkeyvault.JSONWebKeyOperationEncrypt), - // to.Ptr(armkeyvault.JSONWebKeyOperationDecrypt), - // to.Ptr(armkeyvault.JSONWebKeyOperationSign), - // to.Ptr(armkeyvault.JSONWebKeyOperationVerify), - // to.Ptr(armkeyvault.JSONWebKeyOperationWrapKey), - // to.Ptr(armkeyvault.JSONWebKeyOperationUnwrapKey)}, - // KeySize: to.Ptr[int32](2048), - // KeyURI: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name"), - // KeyURIWithVersion: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name/fd618d9519b74f9aae94ade66b876acc"), - // Kty: to.Ptr(armkeyvault.JSONWebKeyTypeRSA), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/listKeyVersions.json -func ExampleKeysClient_NewListVersionsPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewKeysClient().NewListVersionsPager("sample-group", "sample-vault-name", "sample-key-name", 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.KeyListResult = armkeyvault.KeyListResult{ - // Value: []*armkeyvault.Key{ - // { - // Name: to.Ptr("c2296aa24acf4daf86942bff5aca73dd"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/keys/versions"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault-name/keys/sample-key-name/versions/c2296aa24acf4daf86942bff5aca73dd"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.KeyProperties{ - // Attributes: &armkeyvault.KeyAttributes{ - // Created: to.Ptr[int64](1598641074), - // Enabled: to.Ptr(true), - // RecoveryLevel: to.Ptr(armkeyvault.DeletionRecoveryLevelPurgeable), - // Updated: to.Ptr[int64](1598641074), - // }, - // KeyURI: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name"), - // KeyURIWithVersion: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name/c2296aa24acf4daf86942bff5aca73dd"), - // }, - // }, - // { - // Name: to.Ptr("d5a04667b6f44b0ca62825f5eae93da6"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/keys/versions"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault-name/keys/sample-key-name/versions/d5a04667b6f44b0ca62825f5eae93da6"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.KeyProperties{ - // Attributes: &armkeyvault.KeyAttributes{ - // Created: to.Ptr[int64](1598641295), - // Enabled: to.Ptr(true), - // RecoveryLevel: to.Ptr(armkeyvault.DeletionRecoveryLevelPurgeable), - // Updated: to.Ptr[int64](1598641295), - // }, - // KeyURI: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name"), - // KeyURIWithVersion: to.Ptr("https://sample-vault-name.vault.azure.net:443/keys/sample-key-name/d5a04667b6f44b0ca62825f5eae93da6"), - // }, - // }}, - // } - } -} diff --git a/sdk/resourcemanager/keyvault/armkeyvault/managedhsmkeys_client.go b/sdk/resourcemanager/keyvault/armkeyvault/managedhsmkeys_client.go new file mode 100644 index 000000000000..3288eefd3f28 --- /dev/null +++ b/sdk/resourcemanager/keyvault/armkeyvault/managedhsmkeys_client.go @@ -0,0 +1,394 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. +// DO NOT EDIT. + +package armkeyvault + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// ManagedHsmKeysClient contains the methods for the ManagedHsmKeys group. +// Don't use this type directly, use NewManagedHsmKeysClient() instead. +type ManagedHsmKeysClient struct { + internal *arm.Client + subscriptionID string +} + +// NewManagedHsmKeysClient creates a new instance of ManagedHsmKeysClient with the specified values. +// - subscriptionID - Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms +// part of the URI for every service call. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewManagedHsmKeysClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ManagedHsmKeysClient, error) { + cl, err := arm.NewClient(moduleName+".ManagedHsmKeysClient", moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &ManagedHsmKeysClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// CreateIfNotExist - Creates the first version of a new key if it does not exist. If it already exists, then the existing +// key is returned without any write operations being performed. This API does not create subsequent +// versions, and does not update existing keys. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2023-02-01 +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - name - The name of the Managed HSM Pool within the specified resource group. +// - keyName - The name of the key to be created. The value you provide may be copied globally for the purpose of running the +// service. The value provided should not include personally identifiable or sensitive +// information. +// - parameters - The parameters used to create the specified key. +// - options - ManagedHsmKeysClientCreateIfNotExistOptions contains the optional parameters for the ManagedHsmKeysClient.CreateIfNotExist +// method. +func (client *ManagedHsmKeysClient) CreateIfNotExist(ctx context.Context, resourceGroupName string, name string, keyName string, parameters ManagedHsmKeyCreateParameters, options *ManagedHsmKeysClientCreateIfNotExistOptions) (ManagedHsmKeysClientCreateIfNotExistResponse, error) { + req, err := client.createIfNotExistCreateRequest(ctx, resourceGroupName, name, keyName, parameters, options) + if err != nil { + return ManagedHsmKeysClientCreateIfNotExistResponse{}, err + } + resp, err := client.internal.Pipeline().Do(req) + if err != nil { + return ManagedHsmKeysClientCreateIfNotExistResponse{}, err + } + if !runtime.HasStatusCode(resp, http.StatusOK) { + return ManagedHsmKeysClientCreateIfNotExistResponse{}, runtime.NewResponseError(resp) + } + return client.createIfNotExistHandleResponse(resp) +} + +// createIfNotExistCreateRequest creates the CreateIfNotExist request. +func (client *ManagedHsmKeysClient) createIfNotExistCreateRequest(ctx context.Context, resourceGroupName string, name string, keyName string, parameters ManagedHsmKeyCreateParameters, options *ManagedHsmKeysClientCreateIfNotExistOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/keys/{keyName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if name == "" { + return nil, errors.New("parameter name cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name)) + if keyName == "" { + return nil, errors.New("parameter keyName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{keyName}", url.PathEscape(keyName)) + req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2023-02-01") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, runtime.MarshalAsJSON(req, parameters) +} + +// createIfNotExistHandleResponse handles the CreateIfNotExist response. +func (client *ManagedHsmKeysClient) createIfNotExistHandleResponse(resp *http.Response) (ManagedHsmKeysClientCreateIfNotExistResponse, error) { + result := ManagedHsmKeysClientCreateIfNotExistResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.ManagedHsmKey); err != nil { + return ManagedHsmKeysClientCreateIfNotExistResponse{}, err + } + return result, nil +} + +// Get - Gets the current version of the specified key from the specified managed HSM. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2023-02-01 +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - name - The name of the Managed HSM Pool within the specified resource group. +// - keyName - The name of the key to be created. The value you provide may be copied globally for the purpose of running the +// service. The value provided should not include personally identifiable or sensitive +// information. +// - options - ManagedHsmKeysClientGetOptions contains the optional parameters for the ManagedHsmKeysClient.Get method. +func (client *ManagedHsmKeysClient) Get(ctx context.Context, resourceGroupName string, name string, keyName string, options *ManagedHsmKeysClientGetOptions) (ManagedHsmKeysClientGetResponse, error) { + req, err := client.getCreateRequest(ctx, resourceGroupName, name, keyName, options) + if err != nil { + return ManagedHsmKeysClientGetResponse{}, err + } + resp, err := client.internal.Pipeline().Do(req) + if err != nil { + return ManagedHsmKeysClientGetResponse{}, err + } + if !runtime.HasStatusCode(resp, http.StatusOK) { + return ManagedHsmKeysClientGetResponse{}, runtime.NewResponseError(resp) + } + return client.getHandleResponse(resp) +} + +// getCreateRequest creates the Get request. +func (client *ManagedHsmKeysClient) getCreateRequest(ctx context.Context, resourceGroupName string, name string, keyName string, options *ManagedHsmKeysClientGetOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/keys/{keyName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if name == "" { + return nil, errors.New("parameter name cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name)) + if keyName == "" { + return nil, errors.New("parameter keyName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{keyName}", url.PathEscape(keyName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2023-02-01") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getHandleResponse handles the Get response. +func (client *ManagedHsmKeysClient) getHandleResponse(resp *http.Response) (ManagedHsmKeysClientGetResponse, error) { + result := ManagedHsmKeysClientGetResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.ManagedHsmKey); err != nil { + return ManagedHsmKeysClientGetResponse{}, err + } + return result, nil +} + +// GetVersion - Gets the specified version of the specified key in the specified managed HSM. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2023-02-01 +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - name - The name of the Managed HSM Pool within the specified resource group. +// - keyName - The name of the key to be created. The value you provide may be copied globally for the purpose of running the +// service. The value provided should not include personally identifiable or sensitive +// information. +// - keyVersion - The version of the key to be retrieved. +// - options - ManagedHsmKeysClientGetVersionOptions contains the optional parameters for the ManagedHsmKeysClient.GetVersion +// method. +func (client *ManagedHsmKeysClient) GetVersion(ctx context.Context, resourceGroupName string, name string, keyName string, keyVersion string, options *ManagedHsmKeysClientGetVersionOptions) (ManagedHsmKeysClientGetVersionResponse, error) { + req, err := client.getVersionCreateRequest(ctx, resourceGroupName, name, keyName, keyVersion, options) + if err != nil { + return ManagedHsmKeysClientGetVersionResponse{}, err + } + resp, err := client.internal.Pipeline().Do(req) + if err != nil { + return ManagedHsmKeysClientGetVersionResponse{}, err + } + if !runtime.HasStatusCode(resp, http.StatusOK) { + return ManagedHsmKeysClientGetVersionResponse{}, runtime.NewResponseError(resp) + } + return client.getVersionHandleResponse(resp) +} + +// getVersionCreateRequest creates the GetVersion request. +func (client *ManagedHsmKeysClient) getVersionCreateRequest(ctx context.Context, resourceGroupName string, name string, keyName string, keyVersion string, options *ManagedHsmKeysClientGetVersionOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/keys/{keyName}/versions/{keyVersion}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if name == "" { + return nil, errors.New("parameter name cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name)) + if keyName == "" { + return nil, errors.New("parameter keyName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{keyName}", url.PathEscape(keyName)) + if keyVersion == "" { + return nil, errors.New("parameter keyVersion cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{keyVersion}", url.PathEscape(keyVersion)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2023-02-01") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getVersionHandleResponse handles the GetVersion response. +func (client *ManagedHsmKeysClient) getVersionHandleResponse(resp *http.Response) (ManagedHsmKeysClientGetVersionResponse, error) { + result := ManagedHsmKeysClientGetVersionResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.ManagedHsmKey); err != nil { + return ManagedHsmKeysClientGetVersionResponse{}, err + } + return result, nil +} + +// NewListPager - Lists the keys in the specified managed HSM. +// +// Generated from API version 2023-02-01 +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - name - The name of the Managed HSM Pool within the specified resource group. +// - options - ManagedHsmKeysClientListOptions contains the optional parameters for the ManagedHsmKeysClient.NewListPager method. +func (client *ManagedHsmKeysClient) NewListPager(resourceGroupName string, name string, options *ManagedHsmKeysClientListOptions) *runtime.Pager[ManagedHsmKeysClientListResponse] { + return runtime.NewPager(runtime.PagingHandler[ManagedHsmKeysClientListResponse]{ + More: func(page ManagedHsmKeysClientListResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *ManagedHsmKeysClientListResponse) (ManagedHsmKeysClientListResponse, error) { + var req *policy.Request + var err error + if page == nil { + req, err = client.listCreateRequest(ctx, resourceGroupName, name, options) + } else { + req, err = runtime.NewRequest(ctx, http.MethodGet, *page.NextLink) + } + if err != nil { + return ManagedHsmKeysClientListResponse{}, err + } + resp, err := client.internal.Pipeline().Do(req) + if err != nil { + return ManagedHsmKeysClientListResponse{}, err + } + if !runtime.HasStatusCode(resp, http.StatusOK) { + return ManagedHsmKeysClientListResponse{}, runtime.NewResponseError(resp) + } + return client.listHandleResponse(resp) + }, + }) +} + +// listCreateRequest creates the List request. +func (client *ManagedHsmKeysClient) listCreateRequest(ctx context.Context, resourceGroupName string, name string, options *ManagedHsmKeysClientListOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/keys" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if name == "" { + return nil, errors.New("parameter name cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2023-02-01") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listHandleResponse handles the List response. +func (client *ManagedHsmKeysClient) listHandleResponse(resp *http.Response) (ManagedHsmKeysClientListResponse, error) { + result := ManagedHsmKeysClientListResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.ManagedHsmKeyListResult); err != nil { + return ManagedHsmKeysClientListResponse{}, err + } + return result, nil +} + +// NewListVersionsPager - Lists the versions of the specified key in the specified managed HSM. +// +// Generated from API version 2023-02-01 +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - name - The name of the Managed HSM Pool within the specified resource group. +// - keyName - The name of the key to be created. The value you provide may be copied globally for the purpose of running the +// service. The value provided should not include personally identifiable or sensitive +// information. +// - options - ManagedHsmKeysClientListVersionsOptions contains the optional parameters for the ManagedHsmKeysClient.NewListVersionsPager +// method. +func (client *ManagedHsmKeysClient) NewListVersionsPager(resourceGroupName string, name string, keyName string, options *ManagedHsmKeysClientListVersionsOptions) *runtime.Pager[ManagedHsmKeysClientListVersionsResponse] { + return runtime.NewPager(runtime.PagingHandler[ManagedHsmKeysClientListVersionsResponse]{ + More: func(page ManagedHsmKeysClientListVersionsResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *ManagedHsmKeysClientListVersionsResponse) (ManagedHsmKeysClientListVersionsResponse, error) { + var req *policy.Request + var err error + if page == nil { + req, err = client.listVersionsCreateRequest(ctx, resourceGroupName, name, keyName, options) + } else { + req, err = runtime.NewRequest(ctx, http.MethodGet, *page.NextLink) + } + if err != nil { + return ManagedHsmKeysClientListVersionsResponse{}, err + } + resp, err := client.internal.Pipeline().Do(req) + if err != nil { + return ManagedHsmKeysClientListVersionsResponse{}, err + } + if !runtime.HasStatusCode(resp, http.StatusOK) { + return ManagedHsmKeysClientListVersionsResponse{}, runtime.NewResponseError(resp) + } + return client.listVersionsHandleResponse(resp) + }, + }) +} + +// listVersionsCreateRequest creates the ListVersions request. +func (client *ManagedHsmKeysClient) listVersionsCreateRequest(ctx context.Context, resourceGroupName string, name string, keyName string, options *ManagedHsmKeysClientListVersionsOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/keys/{keyName}/versions" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if name == "" { + return nil, errors.New("parameter name cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name)) + if keyName == "" { + return nil, errors.New("parameter keyName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{keyName}", url.PathEscape(keyName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2023-02-01") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listVersionsHandleResponse handles the ListVersions response. +func (client *ManagedHsmKeysClient) listVersionsHandleResponse(resp *http.Response) (ManagedHsmKeysClientListVersionsResponse, error) { + result := ManagedHsmKeysClientListVersionsResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.ManagedHsmKeyListResult); err != nil { + return ManagedHsmKeysClientListVersionsResponse{}, err + } + return result, nil +} diff --git a/sdk/resourcemanager/keyvault/armkeyvault/managedhsms_client.go b/sdk/resourcemanager/keyvault/armkeyvault/managedhsms_client.go index 4415b962c8d9..21d87f4e5ccf 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/managedhsms_client.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/managedhsms_client.go @@ -46,10 +46,59 @@ func NewManagedHsmsClient(subscriptionID string, credential azcore.TokenCredenti return client, nil } +// CheckMhsmNameAvailability - Checks that the managed hsm name is valid and is not already in use. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2023-02-01 +// - mhsmName - The name of the managed hsm. +// - options - ManagedHsmsClientCheckMhsmNameAvailabilityOptions contains the optional parameters for the ManagedHsmsClient.CheckMhsmNameAvailability +// method. +func (client *ManagedHsmsClient) CheckMhsmNameAvailability(ctx context.Context, mhsmName CheckMhsmNameAvailabilityParameters, options *ManagedHsmsClientCheckMhsmNameAvailabilityOptions) (ManagedHsmsClientCheckMhsmNameAvailabilityResponse, error) { + req, err := client.checkMhsmNameAvailabilityCreateRequest(ctx, mhsmName, options) + if err != nil { + return ManagedHsmsClientCheckMhsmNameAvailabilityResponse{}, err + } + resp, err := client.internal.Pipeline().Do(req) + if err != nil { + return ManagedHsmsClientCheckMhsmNameAvailabilityResponse{}, err + } + if !runtime.HasStatusCode(resp, http.StatusOK) { + return ManagedHsmsClientCheckMhsmNameAvailabilityResponse{}, runtime.NewResponseError(resp) + } + return client.checkMhsmNameAvailabilityHandleResponse(resp) +} + +// checkMhsmNameAvailabilityCreateRequest creates the CheckMhsmNameAvailability request. +func (client *ManagedHsmsClient) checkMhsmNameAvailabilityCreateRequest(ctx context.Context, mhsmName CheckMhsmNameAvailabilityParameters, options *ManagedHsmsClientCheckMhsmNameAvailabilityOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.KeyVault/checkMhsmNameAvailability" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + req, err := runtime.NewRequest(ctx, http.MethodPost, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2023-02-01") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, runtime.MarshalAsJSON(req, mhsmName) +} + +// checkMhsmNameAvailabilityHandleResponse handles the CheckMhsmNameAvailability response. +func (client *ManagedHsmsClient) checkMhsmNameAvailabilityHandleResponse(resp *http.Response) (ManagedHsmsClientCheckMhsmNameAvailabilityResponse, error) { + result := ManagedHsmsClientCheckMhsmNameAvailabilityResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.CheckMhsmNameAvailabilityResult); err != nil { + return ManagedHsmsClientCheckMhsmNameAvailabilityResponse{}, err + } + return result, nil +} + // BeginCreateOrUpdate - Create or update a managed HSM Pool in the specified subscription. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the managed HSM pool. // - name - Name of the managed HSM Pool // - parameters - Parameters to create or update the managed HSM Pool @@ -70,7 +119,7 @@ func (client *ManagedHsmsClient) BeginCreateOrUpdate(ctx context.Context, resour // CreateOrUpdate - Create or update a managed HSM Pool in the specified subscription. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 func (client *ManagedHsmsClient) createOrUpdate(ctx context.Context, resourceGroupName string, name string, parameters ManagedHsm, options *ManagedHsmsClientBeginCreateOrUpdateOptions) (*http.Response, error) { req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, name, parameters, options) if err != nil { @@ -106,7 +155,7 @@ func (client *ManagedHsmsClient) createOrUpdateCreateRequest(ctx context.Context return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, parameters) @@ -115,7 +164,7 @@ func (client *ManagedHsmsClient) createOrUpdateCreateRequest(ctx context.Context // BeginDelete - Deletes the specified managed HSM Pool. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the managed HSM pool. // - name - The name of the managed HSM Pool to delete // - options - ManagedHsmsClientBeginDeleteOptions contains the optional parameters for the ManagedHsmsClient.BeginDelete method. @@ -134,7 +183,7 @@ func (client *ManagedHsmsClient) BeginDelete(ctx context.Context, resourceGroupN // Delete - Deletes the specified managed HSM Pool. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 func (client *ManagedHsmsClient) deleteOperation(ctx context.Context, resourceGroupName string, name string, options *ManagedHsmsClientBeginDeleteOptions) (*http.Response, error) { req, err := client.deleteCreateRequest(ctx, resourceGroupName, name, options) if err != nil { @@ -170,7 +219,7 @@ func (client *ManagedHsmsClient) deleteCreateRequest(ctx context.Context, resour return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -179,7 +228,7 @@ func (client *ManagedHsmsClient) deleteCreateRequest(ctx context.Context, resour // Get - Gets the specified managed HSM Pool. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the managed HSM pool. // - name - The name of the managed HSM Pool. // - options - ManagedHsmsClientGetOptions contains the optional parameters for the ManagedHsmsClient.Get method. @@ -192,7 +241,7 @@ func (client *ManagedHsmsClient) Get(ctx context.Context, resourceGroupName stri if err != nil { return ManagedHsmsClientGetResponse{}, err } - if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusAccepted, http.StatusNoContent) { + if !runtime.HasStatusCode(resp, http.StatusOK, http.StatusNoContent) { return ManagedHsmsClientGetResponse{}, runtime.NewResponseError(resp) } return client.getHandleResponse(resp) @@ -218,7 +267,7 @@ func (client *ManagedHsmsClient) getCreateRequest(ctx context.Context, resourceG return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -236,7 +285,7 @@ func (client *ManagedHsmsClient) getHandleResponse(resp *http.Response) (Managed // GetDeleted - Gets the specified deleted managed HSM. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - name - The name of the deleted managed HSM. // - location - The location of the deleted managed HSM. // - options - ManagedHsmsClientGetDeletedOptions contains the optional parameters for the ManagedHsmsClient.GetDeleted method. @@ -275,7 +324,7 @@ func (client *ManagedHsmsClient) getDeletedCreateRequest(ctx context.Context, na return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -293,7 +342,7 @@ func (client *ManagedHsmsClient) getDeletedHandleResponse(resp *http.Response) ( // NewListByResourceGroupPager - The List operation gets information about the managed HSM Pools associated with the subscription // and within the specified resource group. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the managed HSM pool. // - options - ManagedHsmsClientListByResourceGroupOptions contains the optional parameters for the ManagedHsmsClient.NewListByResourceGroupPager // method. @@ -344,7 +393,7 @@ func (client *ManagedHsmsClient) listByResourceGroupCreateRequest(ctx context.Co if options != nil && options.Top != nil { reqQP.Set("$top", strconv.FormatInt(int64(*options.Top), 10)) } - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -361,7 +410,7 @@ func (client *ManagedHsmsClient) listByResourceGroupHandleResponse(resp *http.Re // NewListBySubscriptionPager - The List operation gets information about the managed HSM Pools associated with the subscription. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - options - ManagedHsmsClientListBySubscriptionOptions contains the optional parameters for the ManagedHsmsClient.NewListBySubscriptionPager // method. func (client *ManagedHsmsClient) NewListBySubscriptionPager(options *ManagedHsmsClientListBySubscriptionOptions) *runtime.Pager[ManagedHsmsClientListBySubscriptionResponse] { @@ -407,7 +456,7 @@ func (client *ManagedHsmsClient) listBySubscriptionCreateRequest(ctx context.Con if options != nil && options.Top != nil { reqQP.Set("$top", strconv.FormatInt(int64(*options.Top), 10)) } - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -424,7 +473,7 @@ func (client *ManagedHsmsClient) listBySubscriptionHandleResponse(resp *http.Res // NewListDeletedPager - The List operation gets information about the deleted managed HSMs associated with the subscription. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - options - ManagedHsmsClientListDeletedOptions contains the optional parameters for the ManagedHsmsClient.NewListDeletedPager // method. func (client *ManagedHsmsClient) NewListDeletedPager(options *ManagedHsmsClientListDeletedOptions) *runtime.Pager[ManagedHsmsClientListDeletedResponse] { @@ -467,7 +516,7 @@ func (client *ManagedHsmsClient) listDeletedCreateRequest(ctx context.Context, o return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -485,7 +534,7 @@ func (client *ManagedHsmsClient) listDeletedHandleResponse(resp *http.Response) // BeginPurgeDeleted - Permanently deletes the specified managed HSM. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - name - The name of the soft-deleted managed HSM. // - location - The location of the soft-deleted managed HSM. // - options - ManagedHsmsClientBeginPurgeDeletedOptions contains the optional parameters for the ManagedHsmsClient.BeginPurgeDeleted @@ -505,7 +554,7 @@ func (client *ManagedHsmsClient) BeginPurgeDeleted(ctx context.Context, name str // PurgeDeleted - Permanently deletes the specified managed HSM. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 func (client *ManagedHsmsClient) purgeDeleted(ctx context.Context, name string, location string, options *ManagedHsmsClientBeginPurgeDeletedOptions) (*http.Response, error) { req, err := client.purgeDeletedCreateRequest(ctx, name, location, options) if err != nil { @@ -541,7 +590,7 @@ func (client *ManagedHsmsClient) purgeDeletedCreateRequest(ctx context.Context, return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -550,7 +599,7 @@ func (client *ManagedHsmsClient) purgeDeletedCreateRequest(ctx context.Context, // BeginUpdate - Update a managed HSM Pool in the specified subscription. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the managed HSM pool. // - name - Name of the managed HSM Pool // - parameters - Parameters to patch the managed HSM Pool @@ -570,7 +619,7 @@ func (client *ManagedHsmsClient) BeginUpdate(ctx context.Context, resourceGroupN // Update - Update a managed HSM Pool in the specified subscription. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 func (client *ManagedHsmsClient) update(ctx context.Context, resourceGroupName string, name string, parameters ManagedHsm, options *ManagedHsmsClientBeginUpdateOptions) (*http.Response, error) { req, err := client.updateCreateRequest(ctx, resourceGroupName, name, parameters, options) if err != nil { @@ -606,7 +655,7 @@ func (client *ManagedHsmsClient) updateCreateRequest(ctx context.Context, resour return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, parameters) diff --git a/sdk/resourcemanager/keyvault/armkeyvault/managedhsms_client_example_test.go b/sdk/resourcemanager/keyvault/armkeyvault/managedhsms_client_example_test.go deleted file mode 100644 index 260ab5e22632..000000000000 --- a/sdk/resourcemanager/keyvault/armkeyvault/managedhsms_client_example_test.go +++ /dev/null @@ -1,481 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armkeyvault_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_CreateOrUpdate.json -func ExampleManagedHsmsClient_BeginCreateOrUpdate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewManagedHsmsClient().BeginCreateOrUpdate(ctx, "hsm-group", "hsm1", armkeyvault.ManagedHsm{ - Location: to.Ptr("westus"), - SKU: &armkeyvault.ManagedHsmSKU{ - Name: to.Ptr(armkeyvault.ManagedHsmSKUNameStandardB1), - Family: to.Ptr(armkeyvault.ManagedHsmSKUFamilyB), - }, - Tags: map[string]*string{ - "Dept": to.Ptr("hsm"), - "Environment": to.Ptr("dogfood"), - }, - Properties: &armkeyvault.ManagedHsmProperties{ - EnablePurgeProtection: to.Ptr(true), - EnableSoftDelete: to.Ptr(true), - InitialAdminObjectIDs: []*string{ - to.Ptr("00000000-0000-0000-0000-000000000000")}, - SoftDeleteRetentionInDays: to.Ptr[int32](90), - TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - }, - }, 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.ManagedHsm = armkeyvault.ManagedHsm{ - // Name: to.Ptr("hsm1"), - // Type: to.Ptr("Microsoft.KeyVault/managedHSMs"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/hsm-group/providers/Microsoft.KeyVault/managedHSMs/hsm1"), - // Location: to.Ptr("westus"), - // SKU: &armkeyvault.ManagedHsmSKU{ - // Name: to.Ptr(armkeyvault.ManagedHsmSKUNameStandardB1), - // Family: to.Ptr(armkeyvault.ManagedHsmSKUFamilyB), - // }, - // Tags: map[string]*string{ - // "Dept": to.Ptr("hsm"), - // "Environment": to.Ptr("dogfood"), - // }, - // Properties: &armkeyvault.ManagedHsmProperties{ - // EnablePurgeProtection: to.Ptr(true), - // EnableSoftDelete: to.Ptr(true), - // HsmURI: to.Ptr("https://westus.hsm1.managedhsm.azure.net"), - // InitialAdminObjectIDs: []*string{ - // to.Ptr("00000000-0000-0000-0000-000000000000")}, - // ProvisioningState: to.Ptr(armkeyvault.ProvisioningStateSucceeded), - // SoftDeleteRetentionInDays: to.Ptr[int32](90), - // StatusMessage: to.Ptr("ManagedHsm is functional."), - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_Update.json -func ExampleManagedHsmsClient_BeginUpdate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewManagedHsmsClient().BeginUpdate(ctx, "hsm-group", "hsm1", armkeyvault.ManagedHsm{ - Tags: map[string]*string{ - "Dept": to.Ptr("hsm"), - "Environment": to.Ptr("dogfood"), - "Slice": to.Ptr("A"), - }, - }, 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.ManagedHsm = armkeyvault.ManagedHsm{ - // Name: to.Ptr("hsm1"), - // Type: to.Ptr("Microsoft.KeyVault/managedHSMs"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/hsm-group/providers/Microsoft.KeyVault/managedHSMs/hsm1"), - // Location: to.Ptr("westus"), - // SKU: &armkeyvault.ManagedHsmSKU{ - // Name: to.Ptr(armkeyvault.ManagedHsmSKUNameStandardB1), - // Family: to.Ptr(armkeyvault.ManagedHsmSKUFamilyB), - // }, - // Tags: map[string]*string{ - // "Dept": to.Ptr("hsm"), - // "Environment": to.Ptr("dogfood"), - // "Slice": to.Ptr("A"), - // }, - // Properties: &armkeyvault.ManagedHsmProperties{ - // EnablePurgeProtection: to.Ptr(true), - // EnableSoftDelete: to.Ptr(true), - // HsmURI: to.Ptr("https://westus.hsm1.managedhsm.azure.net"), - // InitialAdminObjectIDs: []*string{ - // to.Ptr("00000000-0000-0000-0000-000000000000")}, - // ProvisioningState: to.Ptr(armkeyvault.ProvisioningStateSucceeded), - // SoftDeleteRetentionInDays: to.Ptr[int32](90), - // StatusMessage: to.Ptr("ManagedHsm is functional."), - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_Delete.json -func ExampleManagedHsmsClient_BeginDelete() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewManagedHsmsClient().BeginDelete(ctx, "hsm-group", "hsm1", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - _, err = poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_Get.json -func ExampleManagedHsmsClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewManagedHsmsClient().Get(ctx, "hsm-group", "hsm1", 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.ManagedHsm = armkeyvault.ManagedHsm{ - // Name: to.Ptr("hsm1"), - // Type: to.Ptr("Microsoft.KeyVault/managedHSMs"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/hsm-group/providers/Microsoft.KeyVault/managedHSMs/hsm1"), - // Location: to.Ptr("westus"), - // SKU: &armkeyvault.ManagedHsmSKU{ - // Name: to.Ptr(armkeyvault.ManagedHsmSKUNameStandardB1), - // Family: to.Ptr(armkeyvault.ManagedHsmSKUFamilyB), - // }, - // Tags: map[string]*string{ - // "Dept": to.Ptr("hsm"), - // "Environment": to.Ptr("dogfood"), - // }, - // Properties: &armkeyvault.ManagedHsmProperties{ - // EnablePurgeProtection: to.Ptr(true), - // EnableSoftDelete: to.Ptr(true), - // HsmURI: to.Ptr("https://westus.hsm1.managedhsm.azure.net"), - // InitialAdminObjectIDs: []*string{ - // to.Ptr("00000000-0000-0000-0000-000000000000")}, - // ProvisioningState: to.Ptr(armkeyvault.ProvisioningStateSucceeded), - // SoftDeleteRetentionInDays: to.Ptr[int32](90), - // StatusMessage: to.Ptr("ManagedHsm is functional."), - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_ListByResourceGroup.json -func ExampleManagedHsmsClient_NewListByResourceGroupPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewManagedHsmsClient().NewListByResourceGroupPager("hsm-group", &armkeyvault.ManagedHsmsClientListByResourceGroupOptions{Top: 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.ManagedHsmListResult = armkeyvault.ManagedHsmListResult{ - // Value: []*armkeyvault.ManagedHsm{ - // { - // Name: to.Ptr("hsm1"), - // Type: to.Ptr("Microsoft.KeyVault/managedHSMs"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/hsm-group/providers/Microsoft.KeyVault/managedHSMs/hsm1"), - // Location: to.Ptr("westus"), - // SKU: &armkeyvault.ManagedHsmSKU{ - // Name: to.Ptr(armkeyvault.ManagedHsmSKUNameStandardB1), - // Family: to.Ptr(armkeyvault.ManagedHsmSKUFamilyB), - // }, - // Tags: map[string]*string{ - // "Dept": to.Ptr("hsm"), - // "Environment": to.Ptr("dogfood"), - // }, - // Properties: &armkeyvault.ManagedHsmProperties{ - // EnablePurgeProtection: to.Ptr(true), - // EnableSoftDelete: to.Ptr(true), - // HsmURI: to.Ptr("https://westus.hsm1.managedhsm.azure.net"), - // InitialAdminObjectIDs: []*string{ - // to.Ptr("00000000-0000-0000-0000-000000000000")}, - // ProvisioningState: to.Ptr(armkeyvault.ProvisioningStateSucceeded), - // SoftDeleteRetentionInDays: to.Ptr[int32](90), - // StatusMessage: to.Ptr("ManagedHsm is functional."), - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }, - // }, - // { - // Name: to.Ptr("hsm2"), - // Type: to.Ptr("Microsoft.KeyVault/managedHSMs"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/hsm-group/providers/Microsoft.KeyVault/managedHSMs/hsm2"), - // Location: to.Ptr("westus"), - // SKU: &armkeyvault.ManagedHsmSKU{ - // Name: to.Ptr(armkeyvault.ManagedHsmSKUNameStandardB1), - // Family: to.Ptr(armkeyvault.ManagedHsmSKUFamilyB), - // }, - // Tags: map[string]*string{ - // "Dept": to.Ptr("hsm"), - // "Environment": to.Ptr("production"), - // }, - // Properties: &armkeyvault.ManagedHsmProperties{ - // EnablePurgeProtection: to.Ptr(true), - // EnableSoftDelete: to.Ptr(true), - // HsmURI: to.Ptr("https://westus.hsm2.managedhsm.azure.net"), - // InitialAdminObjectIDs: []*string{ - // to.Ptr("00000000-0000-0000-0000-000000000000")}, - // ProvisioningState: to.Ptr(armkeyvault.ProvisioningStateSucceeded), - // SoftDeleteRetentionInDays: to.Ptr[int32](90), - // StatusMessage: to.Ptr("ManagedHsm is functional."), - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_ListBySubscription.json -func ExampleManagedHsmsClient_NewListBySubscriptionPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewManagedHsmsClient().NewListBySubscriptionPager(&armkeyvault.ManagedHsmsClientListBySubscriptionOptions{Top: 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.ManagedHsmListResult = armkeyvault.ManagedHsmListResult{ - // Value: []*armkeyvault.ManagedHsm{ - // { - // Name: to.Ptr("hsm1"), - // Type: to.Ptr("Microsoft.KeyVault/managedHSMs"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/hsm-group/providers/Microsoft.KeyVault/managedHSMs/hsm1"), - // Location: to.Ptr("westus"), - // SKU: &armkeyvault.ManagedHsmSKU{ - // Name: to.Ptr(armkeyvault.ManagedHsmSKUNameStandardB1), - // Family: to.Ptr(armkeyvault.ManagedHsmSKUFamilyB), - // }, - // Tags: map[string]*string{ - // "Dept": to.Ptr("hsm"), - // "Environment": to.Ptr("dogfood"), - // }, - // Properties: &armkeyvault.ManagedHsmProperties{ - // EnablePurgeProtection: to.Ptr(true), - // EnableSoftDelete: to.Ptr(true), - // HsmURI: to.Ptr("https://westus.hsm1.managedhsm.azure.net"), - // InitialAdminObjectIDs: []*string{ - // to.Ptr("00000000-0000-0000-0000-000000000000")}, - // ProvisioningState: to.Ptr(armkeyvault.ProvisioningStateSucceeded), - // SoftDeleteRetentionInDays: to.Ptr[int32](90), - // StatusMessage: to.Ptr("ManagedHsm is functional."), - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }, - // }, - // { - // Name: to.Ptr("hsm2"), - // Type: to.Ptr("Microsoft.KeyVault/managedHSMs"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/hsm-group/providers/Microsoft.KeyVault/managedHSMs/hsm2"), - // Location: to.Ptr("westus"), - // SKU: &armkeyvault.ManagedHsmSKU{ - // Name: to.Ptr(armkeyvault.ManagedHsmSKUNameStandardB1), - // Family: to.Ptr(armkeyvault.ManagedHsmSKUFamilyB), - // }, - // Tags: map[string]*string{ - // "Dept": to.Ptr("hsm"), - // "Environment": to.Ptr("production"), - // }, - // Properties: &armkeyvault.ManagedHsmProperties{ - // EnablePurgeProtection: to.Ptr(true), - // EnableSoftDelete: to.Ptr(true), - // HsmURI: to.Ptr("https://westus.hsm2.managedhsm.azure.net"), - // InitialAdminObjectIDs: []*string{ - // to.Ptr("00000000-0000-0000-0000-000000000000")}, - // ProvisioningState: to.Ptr(armkeyvault.ProvisioningStateSucceeded), - // SoftDeleteRetentionInDays: to.Ptr[int32](90), - // StatusMessage: to.Ptr("ManagedHsm is functional."), - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/DeletedManagedHsm_List.json -func ExampleManagedHsmsClient_NewListDeletedPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewManagedHsmsClient().NewListDeletedPager(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.DeletedManagedHsmListResult = armkeyvault.DeletedManagedHsmListResult{ - // Value: []*armkeyvault.DeletedManagedHsm{ - // { - // Name: to.Ptr("vault-agile-drawer-6404"), - // Type: to.Ptr("Microsoft.KeyVault/deletedManagedHSMs"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.KeyVault/locations/westus/deletedManagedHSMs/hsm1"), - // Properties: &armkeyvault.DeletedManagedHsmProperties{ - // DeletionDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-04-01T00:00:59Z"); return t}()), - // Location: to.Ptr("westus"), - // MhsmID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/hsm-group/providers/Microsoft.KeyVault/managedHSMs/hsm1"), - // PurgeProtectionEnabled: to.Ptr(true), - // ScheduledPurgeDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-04-01T00:00:59Z"); return t}()), - // Tags: map[string]*string{ - // "Dept": to.Ptr("hsm"), - // "Environment": to.Ptr("production"), - // }, - // }, - // }, - // { - // Name: to.Ptr("vault-agile-drawer-6404"), - // Type: to.Ptr("Microsoft.KeyVault/deletedManagedHSMs"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.KeyVault/locations/westus/deletedManagedHSMs/hsm2"), - // Properties: &armkeyvault.DeletedManagedHsmProperties{ - // DeletionDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-04-01T00:00:59Z"); return t}()), - // Location: to.Ptr("westus"), - // MhsmID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/hsm-group/providers/Microsoft.KeyVault/managedHSMs/hsm2"), - // PurgeProtectionEnabled: to.Ptr(true), - // ScheduledPurgeDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-04-01T00:00:59Z"); return t}()), - // Tags: map[string]*string{ - // "Dept": to.Ptr("hsm"), - // "Environment": to.Ptr("production"), - // }, - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/DeletedManagedHsm_Get.json -func ExampleManagedHsmsClient_GetDeleted() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewManagedHsmsClient().GetDeleted(ctx, "hsm1", "westus", 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.DeletedManagedHsm = armkeyvault.DeletedManagedHsm{ - // Name: to.Ptr("vault-agile-drawer-6404"), - // Type: to.Ptr("Microsoft.KeyVault/deletedManagedHSMs"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.KeyVault/locations/westus/deletedManagedHSMs/hsm1"), - // Properties: &armkeyvault.DeletedManagedHsmProperties{ - // DeletionDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-04-01T00:00:59Z"); return t}()), - // Location: to.Ptr("westus"), - // MhsmID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/hsm-group/providers/Microsoft.KeyVault/managedHSMs/hsm1"), - // PurgeProtectionEnabled: to.Ptr(true), - // ScheduledPurgeDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-04-01T00:00:59Z"); return t}()), - // Tags: map[string]*string{ - // "Dept": to.Ptr("hsm"), - // "Environment": to.Ptr("production"), - // }, - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/DeletedManagedHsm_Purge.json -func ExampleManagedHsmsClient_BeginPurgeDeleted() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewManagedHsmsClient().BeginPurgeDeleted(ctx, "hsm1", "westus", 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) - } -} diff --git a/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivateendpointconnections_client.go b/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivateendpointconnections_client.go index 30d17e35dc26..b8b66a494414 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivateendpointconnections_client.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivateendpointconnections_client.go @@ -49,7 +49,7 @@ func NewMHSMPrivateEndpointConnectionsClient(subscriptionID string, credential a // BeginDelete - Deletes the specified private endpoint connection associated with the managed hsm pool. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the managed HSM pool. // - name - Name of the managed HSM Pool // - privateEndpointConnectionName - Name of the private endpoint connection associated with the managed hsm pool. @@ -70,7 +70,7 @@ func (client *MHSMPrivateEndpointConnectionsClient) BeginDelete(ctx context.Cont // Delete - Deletes the specified private endpoint connection associated with the managed hsm pool. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 func (client *MHSMPrivateEndpointConnectionsClient) deleteOperation(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, options *MHSMPrivateEndpointConnectionsClientBeginDeleteOptions) (*http.Response, error) { req, err := client.deleteCreateRequest(ctx, resourceGroupName, name, privateEndpointConnectionName, options) if err != nil { @@ -110,7 +110,7 @@ func (client *MHSMPrivateEndpointConnectionsClient) deleteCreateRequest(ctx cont return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -119,7 +119,7 @@ func (client *MHSMPrivateEndpointConnectionsClient) deleteCreateRequest(ctx cont // Get - Gets the specified private endpoint connection associated with the managed HSM Pool. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the managed HSM pool. // - name - Name of the managed HSM Pool // - privateEndpointConnectionName - Name of the private endpoint connection associated with the managed hsm pool. @@ -164,7 +164,7 @@ func (client *MHSMPrivateEndpointConnectionsClient) getCreateRequest(ctx context return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -182,7 +182,7 @@ func (client *MHSMPrivateEndpointConnectionsClient) getHandleResponse(resp *http // NewListByResourcePager - The List operation gets information about the private endpoint connections associated with the // managed HSM Pool. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the managed HSM pool. // - name - Name of the managed HSM Pool // - options - MHSMPrivateEndpointConnectionsClientListByResourceOptions contains the optional parameters for the MHSMPrivateEndpointConnectionsClient.NewListByResourcePager @@ -235,7 +235,7 @@ func (client *MHSMPrivateEndpointConnectionsClient) listByResourceCreateRequest( return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -253,7 +253,7 @@ func (client *MHSMPrivateEndpointConnectionsClient) listByResourceHandleResponse // Put - Updates the specified private endpoint connection associated with the managed hsm pool. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the managed HSM pool. // - name - Name of the managed HSM Pool // - privateEndpointConnectionName - Name of the private endpoint connection associated with the managed hsm pool. @@ -299,7 +299,7 @@ func (client *MHSMPrivateEndpointConnectionsClient) putCreateRequest(ctx context return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, properties) diff --git a/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivateendpointconnections_client_example_test.go b/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivateendpointconnections_client_example_test.go deleted file mode 100644 index 3d914dd44956..000000000000 --- a/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivateendpointconnections_client_example_test.go +++ /dev/null @@ -1,193 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armkeyvault_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_ListPrivateEndpointConnectionsByResource.json -func ExampleMHSMPrivateEndpointConnectionsClient_NewListByResourcePager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewMHSMPrivateEndpointConnectionsClient().NewListByResourcePager("sample-group", "sample-mhsm", 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.MHSMPrivateEndpointConnectionsListResult = armkeyvault.MHSMPrivateEndpointConnectionsListResult{ - // Value: []*armkeyvault.MHSMPrivateEndpointConnection{ - // { - // Name: to.Ptr("sample-pec1"), - // Type: to.Ptr("Microsoft.KeyVault/managedhsms/privateEndpointConnections"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/managedhsms/sample-mhsm/privateEndpointConnections/sample-pec1"), - // Etag: to.Ptr(""), - // Properties: &armkeyvault.MHSMPrivateEndpointConnectionProperties{ - // PrivateEndpoint: &armkeyvault.MHSMPrivateEndpoint{ - // ID: to.Ptr("/subscriptions/00000000-0000-0000-1234-000000000000/resourceGroups/sample-group/providers/Microsoft.Network/privateEndpoints/sample-pe1"), - // }, - // PrivateLinkServiceConnectionState: &armkeyvault.MHSMPrivateLinkServiceConnectionState{ - // Description: to.Ptr("This was automatically approved by user1234@contoso.com"), - // ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone), - // Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - // }, - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // }, - // { - // Name: to.Ptr("sample-pec2"), - // Type: to.Ptr("Microsoft.KeyVault/managedhsms/privateEndpointConnections"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/managedhsms/sample-mhsm/privateEndpointConnections/sample-pec2"), - // Etag: to.Ptr(""), - // Properties: &armkeyvault.MHSMPrivateEndpointConnectionProperties{ - // PrivateEndpoint: &armkeyvault.MHSMPrivateEndpoint{ - // ID: to.Ptr("/subscriptions/00000000-0000-0000-1234-000000000000/resourceGroups/sample-group/providers/Microsoft.Network/privateEndpoints/sample-pe2"), - // }, - // PrivateLinkServiceConnectionState: &armkeyvault.MHSMPrivateLinkServiceConnectionState{ - // Description: to.Ptr("This was automatically approved by user1234@contoso.com"), - // ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone), - // Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - // }, - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_getPrivateEndpointConnection.json -func ExampleMHSMPrivateEndpointConnectionsClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewMHSMPrivateEndpointConnectionsClient().Get(ctx, "sample-group", "sample-mhsm", "sample-pec", 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.MHSMPrivateEndpointConnection = armkeyvault.MHSMPrivateEndpointConnection{ - // Name: to.Ptr("sample-pec"), - // Type: to.Ptr("Microsoft.KeyVault/managedhsms/privateEndpointConnections"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/managedhsms/sample-mhsm/privateEndpointConnections/sample-pec"), - // Etag: to.Ptr(""), - // Properties: &armkeyvault.MHSMPrivateEndpointConnectionProperties{ - // PrivateEndpoint: &armkeyvault.MHSMPrivateEndpoint{ - // ID: to.Ptr("/subscriptions/00000000-0000-0000-1234-000000000000/resourceGroups/sample-group/providers/Microsoft.Network/privateEndpoints/sample-pe"), - // }, - // PrivateLinkServiceConnectionState: &armkeyvault.MHSMPrivateLinkServiceConnectionState{ - // Description: to.Ptr("This was automatically approved by user1234@contoso.com"), - // ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone), - // Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - // }, - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_putPrivateEndpointConnection.json -func ExampleMHSMPrivateEndpointConnectionsClient_Put() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewMHSMPrivateEndpointConnectionsClient().Put(ctx, "sample-group", "sample-mhsm", "sample-pec", armkeyvault.MHSMPrivateEndpointConnection{ - Properties: &armkeyvault.MHSMPrivateEndpointConnectionProperties{ - PrivateLinkServiceConnectionState: &armkeyvault.MHSMPrivateLinkServiceConnectionState{ - Description: to.Ptr("My name is Joe and I'm approving this."), - Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - }, - }, - }, 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.MHSMPrivateEndpointConnection = armkeyvault.MHSMPrivateEndpointConnection{ - // Name: to.Ptr("sample-pec"), - // Type: to.Ptr("Microsoft.KeyVault/managedhsms/privateEndpointConnections"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/managedhsms/sample-mhsm/privateEndpointConnections/sample-pec"), - // Properties: &armkeyvault.MHSMPrivateEndpointConnectionProperties{ - // PrivateEndpoint: &armkeyvault.MHSMPrivateEndpoint{ - // ID: to.Ptr("/subscriptions/00000000-0000-0000-1234-000000000000/resourceGroups/sample-group/providers/Microsoft.Network/privateEndpoints/sample-pe"), - // }, - // PrivateLinkServiceConnectionState: &armkeyvault.MHSMPrivateLinkServiceConnectionState{ - // Description: to.Ptr("My name is Joe and I'm approving this."), - // ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone), - // Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - // }, - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_deletePrivateEndpointConnection.json -func ExampleMHSMPrivateEndpointConnectionsClient_BeginDelete() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewMHSMPrivateEndpointConnectionsClient().BeginDelete(ctx, "sample-group", "sample-mhsm", "sample-pec", 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.MHSMPrivateEndpointConnection = armkeyvault.MHSMPrivateEndpointConnection{ - // Name: to.Ptr("sample-pec"), - // Type: to.Ptr("Microsoft.KeyVault/managedhsms/privateEndpointConnections"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/managedhsms/sample-vault/privateEndpointConnections/sample-pec"), - // Properties: &armkeyvault.MHSMPrivateEndpointConnectionProperties{ - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // } -} diff --git a/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivatelinkresources_client.go b/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivatelinkresources_client.go index d2345bb4920f..4bff50b0f79d 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivatelinkresources_client.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivatelinkresources_client.go @@ -48,7 +48,7 @@ func NewMHSMPrivateLinkResourcesClient(subscriptionID string, credential azcore. // ListByMHSMResource - Gets the private link resources supported for the managed hsm pool. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the managed HSM pool. // - name - Name of the managed HSM Pool // - options - MHSMPrivateLinkResourcesClientListByMHSMResourceOptions contains the optional parameters for the MHSMPrivateLinkResourcesClient.ListByMHSMResource @@ -88,7 +88,7 @@ func (client *MHSMPrivateLinkResourcesClient) listByMHSMResourceCreateRequest(ct return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil diff --git a/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivatelinkresources_client_example_test.go b/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivatelinkresources_client_example_test.go deleted file mode 100644 index d31981450253..000000000000 --- a/sdk/resourcemanager/keyvault/armkeyvault/mhsmprivatelinkresources_client_example_test.go +++ /dev/null @@ -1,53 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armkeyvault_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/ManagedHsm_listPrivateLinkResources.json -func ExampleMHSMPrivateLinkResourcesClient_ListByMHSMResource() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewMHSMPrivateLinkResourcesClient().ListByMHSMResource(ctx, "sample-group", "sample-mhsm", 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.MHSMPrivateLinkResourceListResult = armkeyvault.MHSMPrivateLinkResourceListResult{ - // Value: []*armkeyvault.MHSMPrivateLinkResource{ - // { - // Name: to.Ptr("managedhsm"), - // Type: to.Ptr("Microsoft.KeyVault/managedhsms/privateLinkResources"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-resource-group/providers/Microsoft.KeyVault/managedhsms/sample-mhsm/privateLinkResources/managedhsm"), - // Properties: &armkeyvault.MHSMPrivateLinkResourceProperties{ - // GroupID: to.Ptr("managedhsms"), - // RequiredMembers: []*string{ - // to.Ptr("default")}, - // RequiredZoneNames: []*string{ - // to.Ptr("privatelink.managedhsm.azure.net")}, - // }, - // }}, - // } -} diff --git a/sdk/resourcemanager/keyvault/armkeyvault/mhsmregions_client.go b/sdk/resourcemanager/keyvault/armkeyvault/mhsmregions_client.go new file mode 100644 index 000000000000..64692ec10312 --- /dev/null +++ b/sdk/resourcemanager/keyvault/armkeyvault/mhsmregions_client.go @@ -0,0 +1,116 @@ +//go:build go1.18 +// +build go1.18 + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. +// DO NOT EDIT. + +package armkeyvault + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// MHSMRegionsClient contains the methods for the MHSMRegions group. +// Don't use this type directly, use NewMHSMRegionsClient() instead. +type MHSMRegionsClient struct { + internal *arm.Client + subscriptionID string +} + +// NewMHSMRegionsClient creates a new instance of MHSMRegionsClient with the specified values. +// - subscriptionID - Subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms +// part of the URI for every service call. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewMHSMRegionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*MHSMRegionsClient, error) { + cl, err := arm.NewClient(moduleName+".MHSMRegionsClient", moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &MHSMRegionsClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// NewListByResourcePager - The List operation gets information about the regions associated with the managed HSM Pool. +// +// Generated from API version 2023-02-01 +// - resourceGroupName - Name of the resource group that contains the managed HSM pool. +// - name - Name of the managed HSM Pool +// - options - MHSMRegionsClientListByResourceOptions contains the optional parameters for the MHSMRegionsClient.NewListByResourcePager +// method. +func (client *MHSMRegionsClient) NewListByResourcePager(resourceGroupName string, name string, options *MHSMRegionsClientListByResourceOptions) *runtime.Pager[MHSMRegionsClientListByResourceResponse] { + return runtime.NewPager(runtime.PagingHandler[MHSMRegionsClientListByResourceResponse]{ + More: func(page MHSMRegionsClientListByResourceResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *MHSMRegionsClientListByResourceResponse) (MHSMRegionsClientListByResourceResponse, error) { + var req *policy.Request + var err error + if page == nil { + req, err = client.listByResourceCreateRequest(ctx, resourceGroupName, name, options) + } else { + req, err = runtime.NewRequest(ctx, http.MethodGet, *page.NextLink) + } + if err != nil { + return MHSMRegionsClientListByResourceResponse{}, err + } + resp, err := client.internal.Pipeline().Do(req) + if err != nil { + return MHSMRegionsClientListByResourceResponse{}, err + } + if !runtime.HasStatusCode(resp, http.StatusOK) { + return MHSMRegionsClientListByResourceResponse{}, runtime.NewResponseError(resp) + } + return client.listByResourceHandleResponse(resp) + }, + }) +} + +// listByResourceCreateRequest creates the ListByResource request. +func (client *MHSMRegionsClient) listByResourceCreateRequest(ctx context.Context, resourceGroupName string, name string, options *MHSMRegionsClientListByResourceOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/managedHSMs/{name}/regions" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if name == "" { + return nil, errors.New("parameter name cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2023-02-01") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listByResourceHandleResponse handles the ListByResource response. +func (client *MHSMRegionsClient) listByResourceHandleResponse(resp *http.Response) (MHSMRegionsClientListByResourceResponse, error) { + result := MHSMRegionsClientListByResourceResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.MHSMRegionsListResult); err != nil { + return MHSMRegionsClientListByResourceResponse{}, err + } + return result, nil +} diff --git a/sdk/resourcemanager/keyvault/armkeyvault/models.go b/sdk/resourcemanager/keyvault/armkeyvault/models.go index f2f89af40243..3c4503859699 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/models.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/models.go @@ -51,6 +51,26 @@ type Attributes struct { Updated *time.Time `json:"updated,omitempty" azure:"ro"` } +// CheckMhsmNameAvailabilityParameters - The parameters used to check the availability of the managed hsm name. +type CheckMhsmNameAvailabilityParameters struct { + // REQUIRED; The managed hsm name. + Name *string `json:"name,omitempty"` +} + +// CheckMhsmNameAvailabilityResult - The CheckMhsmNameAvailability operation response. +type CheckMhsmNameAvailabilityResult struct { + // READ-ONLY; An error message explaining the Reason value in more detail. + Message *string `json:"message,omitempty" azure:"ro"` + + // READ-ONLY; A boolean value that indicates whether the name is available for you to use. If true, the name is available. + // If false, the name has already been taken or is invalid and cannot be used. + NameAvailable *bool `json:"nameAvailable,omitempty" azure:"ro"` + + // READ-ONLY; The reason that a managed hsm name could not be used. The reason element is only returned if NameAvailable is + // false. + Reason *Reason `json:"reason,omitempty" azure:"ro"` +} + // CheckNameAvailabilityResult - The CheckNameAvailability operation response. type CheckNameAvailabilityResult struct { // READ-ONLY; An error message explaining the Reason value in more detail. @@ -341,7 +361,19 @@ type LogSpecification struct { Name *string `json:"name,omitempty"` } -// MHSMIPRule - A rule governing the accessibility of a managed hsm pool from a specific ip address or ip range. +// MHSMGeoReplicatedRegion - A region that this managed HSM Pool has been extended to. +type MHSMGeoReplicatedRegion struct { + // A boolean value that indicates whether the region is the primary region or a secondary region. + IsPrimary *bool `json:"isPrimary,omitempty"` + + // Name of the geo replicated region. + Name *string `json:"name,omitempty"` + + // READ-ONLY; Provisioning state of the geo replicated region. + ProvisioningState *GeoReplicationRegionProvisioningState `json:"provisioningState,omitempty" azure:"ro"` +} + +// MHSMIPRule - A rule governing the accessibility of a managed HSM pool from a specific IP address or IP range. type MHSMIPRule struct { // REQUIRED; An IPv4 address range in CIDR notation, such as '124.56.78.91' (simple IP address) or '124.56.78.0/24' (all addresses // that start with 124.56.78). @@ -402,6 +434,12 @@ type MHSMPrivateEndpointConnection struct { // MHSMPrivateEndpointConnectionItem - Private endpoint connection item. type MHSMPrivateEndpointConnectionItem struct { + // Modified whenever there is a change in the state of private endpoint connection. + Etag *string `json:"etag,omitempty"` + + // Id of private endpoint connection. + ID *string `json:"id,omitempty"` + // Private endpoint connection properties. Properties *MHSMPrivateEndpointConnectionProperties `json:"properties,omitempty"` } @@ -515,12 +553,36 @@ type MHSMPrivateLinkServiceConnectionState struct { Status *PrivateEndpointServiceConnectionStatus `json:"status,omitempty"` } +// MHSMRegionsClientListByResourceOptions contains the optional parameters for the MHSMRegionsClient.NewListByResourcePager +// method. +type MHSMRegionsClientListByResourceOptions struct { + // placeholder for future optional parameters +} + +// MHSMRegionsListResult - List of regions associated with a managed HSM Pools +type MHSMRegionsListResult struct { + // The URL to get the next set of managed HSM Pools. + NextLink *string `json:"nextLink,omitempty"` + + // The region associated with a managed HSM Pools. + Value []*MHSMGeoReplicatedRegion `json:"value,omitempty"` +} + // MHSMVirtualNetworkRule - A rule governing the accessibility of a managed hsm pool from a specific virtual network. type MHSMVirtualNetworkRule struct { // REQUIRED; Full resource id of a vnet subnet, such as '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'. ID *string `json:"id,omitempty"` } +// ManagedHSMSecurityDomainProperties - The security domain properties of the managed hsm. +type ManagedHSMSecurityDomainProperties struct { + // READ-ONLY; Activation Status + ActivationStatus *ActivationStatus `json:"activationStatus,omitempty" azure:"ro"` + + // READ-ONLY; Activation Status Message. + ActivationStatusMessage *string `json:"activationStatusMessage,omitempty" azure:"ro"` +} + // ManagedHsm - Resource information with extended details. type ManagedHsm struct { // The supported Azure location where the managed HSM Pool should be created. @@ -548,12 +610,161 @@ type ManagedHsm struct { Type *string `json:"type,omitempty" azure:"ro"` } +type ManagedHsmAction struct { + // The type of action. + Type *KeyRotationPolicyActionType `json:"type,omitempty"` +} + // ManagedHsmError - The error exception. type ManagedHsmError struct { // READ-ONLY; The server error. Error *Error `json:"error,omitempty" azure:"ro"` } +// ManagedHsmKey - The key resource. +type ManagedHsmKey struct { + // REQUIRED; The properties of the key. + Properties *ManagedHsmKeyProperties `json:"properties,omitempty"` + + // Resource tags. + Tags map[string]*string `json:"tags,omitempty"` + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string `json:"id,omitempty" azure:"ro"` + + // READ-ONLY; The name of the resource + Name *string `json:"name,omitempty" azure:"ro"` + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string `json:"type,omitempty" azure:"ro"` +} + +// ManagedHsmKeyAttributes - The object attributes managed by the Azure Key Vault service. +type ManagedHsmKeyAttributes struct { + // Determines whether or not the object is enabled. + Enabled *bool `json:"enabled,omitempty"` + + // Expiry date in seconds since 1970-01-01T00:00:00Z. + Expires *int64 `json:"exp,omitempty"` + + // Indicates if the private key can be exported. + Exportable *bool `json:"exportable,omitempty"` + + // Not before date in seconds since 1970-01-01T00:00:00Z. + NotBefore *int64 `json:"nbf,omitempty"` + + // READ-ONLY; Creation time in seconds since 1970-01-01T00:00:00Z. + Created *int64 `json:"created,omitempty" azure:"ro"` + + // READ-ONLY; The deletion recovery level currently in effect for the object. If it contains 'Purgeable', then the object + // can be permanently deleted by a privileged user; otherwise, only the system can purge the + // object at the end of the retention interval. + RecoveryLevel *DeletionRecoveryLevel `json:"recoveryLevel,omitempty" azure:"ro"` + + // READ-ONLY; Last updated time in seconds since 1970-01-01T00:00:00Z. + Updated *int64 `json:"updated,omitempty" azure:"ro"` +} + +// ManagedHsmKeyCreateParameters - The parameters used to create a key. +type ManagedHsmKeyCreateParameters struct { + // REQUIRED; The properties of the key to be created. + Properties *ManagedHsmKeyProperties `json:"properties,omitempty"` + + // The tags that will be assigned to the key. + Tags map[string]*string `json:"tags,omitempty"` +} + +// ManagedHsmKeyListResult - The page of keys. +type ManagedHsmKeyListResult struct { + // The URL to get the next page of keys. + NextLink *string `json:"nextLink,omitempty"` + + // The key resources. + Value []*ManagedHsmKey `json:"value,omitempty"` +} + +// ManagedHsmKeyProperties - The properties of the key. +type ManagedHsmKeyProperties struct { + // The attributes of the key. + Attributes *ManagedHsmKeyAttributes `json:"attributes,omitempty"` + + // The elliptic curve name. For valid values, see JsonWebKeyCurveName. + CurveName *JSONWebKeyCurveName `json:"curveName,omitempty"` + KeyOps []*JSONWebKeyOperation `json:"keyOps,omitempty"` + + // The key size in bits. For example: 2048, 3072, or 4096 for RSA. + KeySize *int32 `json:"keySize,omitempty"` + + // The type of the key. For valid values, see JsonWebKeyType. + Kty *JSONWebKeyType `json:"kty,omitempty"` + + // Key release policy in response. It will be used for both output and input. Omitted if empty + ReleasePolicy *ManagedHsmKeyReleasePolicy `json:"release_policy,omitempty"` + + // Key rotation policy in response. It will be used for both output and input. Omitted if empty + RotationPolicy *ManagedHsmRotationPolicy `json:"rotationPolicy,omitempty"` + + // READ-ONLY; The URI to retrieve the current version of the key. + KeyURI *string `json:"keyUri,omitempty" azure:"ro"` + + // READ-ONLY; The URI to retrieve the specific version of the key. + KeyURIWithVersion *string `json:"keyUriWithVersion,omitempty" azure:"ro"` +} + +type ManagedHsmKeyReleasePolicy struct { + // Content type and version of key release policy + ContentType *string `json:"contentType,omitempty"` + + // Blob encoding the policy rules under which the key can be released. + Data []byte `json:"data,omitempty"` +} + +type ManagedHsmKeyRotationPolicyAttributes struct { + // The expiration time for the new key version. It should be in ISO8601 format. Eg: 'P90D', 'P1Y'. + ExpiryTime *string `json:"expiryTime,omitempty"` + + // READ-ONLY; Creation time in seconds since 1970-01-01T00:00:00Z. + Created *int64 `json:"created,omitempty" azure:"ro"` + + // READ-ONLY; Last updated time in seconds since 1970-01-01T00:00:00Z. + Updated *int64 `json:"updated,omitempty" azure:"ro"` +} + +// ManagedHsmKeysClientCreateIfNotExistOptions contains the optional parameters for the ManagedHsmKeysClient.CreateIfNotExist +// method. +type ManagedHsmKeysClientCreateIfNotExistOptions struct { + // placeholder for future optional parameters +} + +// ManagedHsmKeysClientGetOptions contains the optional parameters for the ManagedHsmKeysClient.Get method. +type ManagedHsmKeysClientGetOptions struct { + // placeholder for future optional parameters +} + +// ManagedHsmKeysClientGetVersionOptions contains the optional parameters for the ManagedHsmKeysClient.GetVersion method. +type ManagedHsmKeysClientGetVersionOptions struct { + // placeholder for future optional parameters +} + +// ManagedHsmKeysClientListOptions contains the optional parameters for the ManagedHsmKeysClient.NewListPager method. +type ManagedHsmKeysClientListOptions struct { + // placeholder for future optional parameters +} + +// ManagedHsmKeysClientListVersionsOptions contains the optional parameters for the ManagedHsmKeysClient.NewListVersionsPager +// method. +type ManagedHsmKeysClientListVersionsOptions struct { + // placeholder for future optional parameters +} + +type ManagedHsmLifetimeAction struct { + // The action of key rotation policy lifetimeAction. + Action *ManagedHsmAction `json:"action,omitempty"` + + // The trigger of key rotation policy lifetimeAction. + Trigger *ManagedHsmTrigger `json:"trigger,omitempty"` +} + // ManagedHsmListResult - List of managed HSM Pools type ManagedHsmListResult struct { // The URL to get the next set of managed HSM Pools. @@ -570,13 +781,11 @@ type ManagedHsmProperties struct { // Property specifying whether protection against purge is enabled for this managed HSM pool. Setting this property to true // activates protection against purge for this managed HSM pool and its content - - // only the Managed HSM service may initiate a hard, irrecoverable deletion. The setting is effective only if soft delete - // is also enabled. Enabling this functionality is irreversible. + // only the Managed HSM service may initiate a hard, irrecoverable deletion. Enabling this functionality is irreversible. EnablePurgeProtection *bool `json:"enablePurgeProtection,omitempty"` - // Property to specify whether the 'soft delete' functionality is enabled for this managed HSM pool. If it's not set to any - // value(true or false) when creating new managed HSM pool, it will be set to true - // by default. Once set to true, it cannot be reverted to false. + // Property to specify whether the 'soft delete' functionality is enabled for this managed HSM pool. Soft delete is enabled + // by default for all managed HSMs and is immutable. EnableSoftDelete *bool `json:"enableSoftDelete,omitempty"` // Array of initial administrators object ids for this managed hsm pool. @@ -585,10 +794,15 @@ type ManagedHsmProperties struct { // Rules governing the accessibility of the key vault from specific network locations. NetworkACLs *MHSMNetworkRuleSet `json:"networkAcls,omitempty"` - // Control permission for data plane traffic coming from public networks while private endpoint is enabled. + // Control permission to the managed HSM from public networks. PublicNetworkAccess *PublicNetworkAccess `json:"publicNetworkAccess,omitempty"` - // softDelete data retention days. It accepts >=7 and <=90. + // List of all regions associated with the managed hsm pool. + Regions []*MHSMGeoReplicatedRegion `json:"regions,omitempty"` + + // Soft deleted data retention days. When you delete an HSM or a key, it will remain recoverable for the configured retention + // period or for a default period of 90 days. It accepts values between 7 and + // 90. SoftDeleteRetentionInDays *int32 `json:"softDeleteRetentionInDays,omitempty"` // The Azure Active Directory tenant ID that should be used for authenticating requests to the managed HSM pool. @@ -606,6 +820,9 @@ type ManagedHsmProperties struct { // READ-ONLY; The scheduled purge date in UTC. ScheduledPurgeDate *time.Time `json:"scheduledPurgeDate,omitempty" azure:"ro"` + // READ-ONLY; Managed HSM security domain properties. + SecurityDomainProperties *ManagedHSMSecurityDomainProperties `json:"securityDomainProperties,omitempty" azure:"ro"` + // READ-ONLY; Resource Status Message. StatusMessage *string `json:"statusMessage,omitempty" azure:"ro"` } @@ -634,6 +851,14 @@ type ManagedHsmResource struct { Type *string `json:"type,omitempty" azure:"ro"` } +type ManagedHsmRotationPolicy struct { + // The attributes of key rotation policy. + Attributes *ManagedHsmKeyRotationPolicyAttributes `json:"attributes,omitempty"` + + // The lifetimeActions for key rotation action. + LifetimeActions []*ManagedHsmLifetimeAction `json:"lifetimeActions,omitempty"` +} + // ManagedHsmSKU - SKU details type ManagedHsmSKU struct { // REQUIRED; SKU Family of the managed HSM Pool @@ -643,6 +868,15 @@ type ManagedHsmSKU struct { Name *ManagedHsmSKUName `json:"name,omitempty"` } +type ManagedHsmTrigger struct { + // The time duration after key creation to rotate the key. It only applies to rotate. It will be in ISO 8601 duration format. + // Eg: 'P90D', 'P1Y'. + TimeAfterCreate *string `json:"timeAfterCreate,omitempty"` + + // The time duration before key expiring to rotate or notify. It will be in ISO 8601 duration format. Eg: 'P90D', 'P1Y'. + TimeBeforeExpiry *string `json:"timeBeforeExpiry,omitempty"` +} + // ManagedHsmsClientBeginCreateOrUpdateOptions contains the optional parameters for the ManagedHsmsClient.BeginCreateOrUpdate // method. type ManagedHsmsClientBeginCreateOrUpdateOptions struct { @@ -669,6 +903,12 @@ type ManagedHsmsClientBeginUpdateOptions struct { ResumeToken string } +// ManagedHsmsClientCheckMhsmNameAvailabilityOptions contains the optional parameters for the ManagedHsmsClient.CheckMhsmNameAvailability +// method. +type ManagedHsmsClientCheckMhsmNameAvailabilityOptions struct { + // placeholder for future optional parameters +} + // ManagedHsmsClientGetDeletedOptions contains the optional parameters for the ManagedHsmsClient.GetDeleted method. type ManagedHsmsClientGetDeletedOptions struct { // placeholder for future optional parameters @@ -964,6 +1204,21 @@ type PrivateLinkServiceConnectionState struct { Status *PrivateEndpointServiceConnectionStatus `json:"status,omitempty"` } +// ProxyResourceWithoutSystemData - Common fields that are returned in the response for all Azure Resource Manager resources +type ProxyResourceWithoutSystemData struct { + // Resource tags. + Tags map[string]*string `json:"tags,omitempty"` + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string `json:"id,omitempty" azure:"ro"` + + // READ-ONLY; The name of the resource + Name *string `json:"name,omitempty" azure:"ro"` + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string `json:"type,omitempty" azure:"ro"` +} + // Resource - Key Vault resource type Resource struct { // READ-ONLY; Fully qualified identifier of the key vault resource. @@ -1273,9 +1528,9 @@ type VaultPatchProperties struct { // Property that controls how data actions are authorized. When true, the key vault will use Role Based Access Control (RBAC) // for authorization of data actions, and the access policies specified in vault - // properties will be ignored (warning: this is a preview feature). When false, the key vault will use the access policies - // specified in vault properties, and any policy stored on Azure Resource Manager - // will be ignored. If null or not specified, the value of this property will not change. + // properties will be ignored. When false, the key vault will use the access policies specified in vault properties, and any + // policy stored on Azure Resource Manager will be ignored. If null or not + // specified, the value of this property will not change. EnableRbacAuthorization *bool `json:"enableRbacAuthorization,omitempty"` // Property to specify whether the 'soft delete' functionality is enabled for this key vault. Once set to true, it cannot @@ -1336,10 +1591,10 @@ type VaultProperties struct { // Property that controls how data actions are authorized. When true, the key vault will use Role Based Access Control (RBAC) // for authorization of data actions, and the access policies specified in vault - // properties will be ignored (warning: this is a preview feature). When false, the key vault will use the access policies - // specified in vault properties, and any policy stored on Azure Resource Manager - // will be ignored. If null or not specified, the vault is created with the default value of false. Note that management actions - // are always authorized with RBAC. + // properties will be ignored. When false, the key vault will use the access policies specified in vault properties, and any + // policy stored on Azure Resource Manager will be ignored. If null or not + // specified, the vault is created with the default value of false. Note that management actions are always authorized with + // RBAC. EnableRbacAuthorization *bool `json:"enableRbacAuthorization,omitempty"` // Property to specify whether the 'soft delete' functionality is enabled for this key vault. If it's not set to any value(true diff --git a/sdk/resourcemanager/keyvault/armkeyvault/models_serde.go b/sdk/resourcemanager/keyvault/armkeyvault/models_serde.go index cf11571f7499..7f7a5e10c31d 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/models_serde.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/models_serde.go @@ -127,6 +127,68 @@ func (a *Attributes) UnmarshalJSON(data []byte) error { return nil } +// MarshalJSON implements the json.Marshaller interface for type CheckMhsmNameAvailabilityParameters. +func (c CheckMhsmNameAvailabilityParameters) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "name", c.Name) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CheckMhsmNameAvailabilityParameters. +func (c *CheckMhsmNameAvailabilityParameters) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", c, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "name": + err = unpopulate(val, "Name", &c.Name) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", c, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type CheckMhsmNameAvailabilityResult. +func (c CheckMhsmNameAvailabilityResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "message", c.Message) + populate(objectMap, "nameAvailable", c.NameAvailable) + populate(objectMap, "reason", c.Reason) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CheckMhsmNameAvailabilityResult. +func (c *CheckMhsmNameAvailabilityResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", c, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "message": + err = unpopulate(val, "Message", &c.Message) + delete(rawMsg, key) + case "nameAvailable": + err = unpopulate(val, "NameAvailable", &c.NameAvailable) + delete(rawMsg, key) + case "reason": + err = unpopulate(val, "Reason", &c.Reason) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", c, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityResult. func (c CheckNameAvailabilityResult) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) @@ -844,6 +906,41 @@ func (l *LogSpecification) UnmarshalJSON(data []byte) error { return nil } +// MarshalJSON implements the json.Marshaller interface for type MHSMGeoReplicatedRegion. +func (m MHSMGeoReplicatedRegion) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "isPrimary", m.IsPrimary) + populate(objectMap, "name", m.Name) + populate(objectMap, "provisioningState", m.ProvisioningState) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type MHSMGeoReplicatedRegion. +func (m *MHSMGeoReplicatedRegion) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "isPrimary": + err = unpopulate(val, "IsPrimary", &m.IsPrimary) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &m.Name) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &m.ProvisioningState) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type MHSMIPRule. func (m MHSMIPRule) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) @@ -999,6 +1096,8 @@ func (m *MHSMPrivateEndpointConnection) UnmarshalJSON(data []byte) error { // MarshalJSON implements the json.Marshaller interface for type MHSMPrivateEndpointConnectionItem. func (m MHSMPrivateEndpointConnectionItem) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) + populate(objectMap, "etag", m.Etag) + populate(objectMap, "id", m.ID) populate(objectMap, "properties", m.Properties) return json.Marshal(objectMap) } @@ -1012,6 +1111,12 @@ func (m *MHSMPrivateEndpointConnectionItem) UnmarshalJSON(data []byte) error { for key, val := range rawMsg { var err error switch key { + case "etag": + err = unpopulate(val, "Etag", &m.Etag) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &m.ID) + delete(rawMsg, key) case "properties": err = unpopulate(val, "Properties", &m.Properties) delete(rawMsg, key) @@ -1241,6 +1346,37 @@ func (m *MHSMPrivateLinkServiceConnectionState) UnmarshalJSON(data []byte) error return nil } +// MarshalJSON implements the json.Marshaller interface for type MHSMRegionsListResult. +func (m MHSMRegionsListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", m.NextLink) + populate(objectMap, "value", m.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type MHSMRegionsListResult. +func (m *MHSMRegionsListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &m.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &m.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type MHSMVirtualNetworkRule. func (m MHSMVirtualNetworkRule) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) @@ -1268,6 +1404,37 @@ func (m *MHSMVirtualNetworkRule) UnmarshalJSON(data []byte) error { return nil } +// MarshalJSON implements the json.Marshaller interface for type ManagedHSMSecurityDomainProperties. +func (m ManagedHSMSecurityDomainProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "activationStatus", m.ActivationStatus) + populate(objectMap, "activationStatusMessage", m.ActivationStatusMessage) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHSMSecurityDomainProperties. +func (m *ManagedHSMSecurityDomainProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "activationStatus": + err = unpopulate(val, "ActivationStatus", &m.ActivationStatus) + delete(rawMsg, key) + case "activationStatusMessage": + err = unpopulate(val, "ActivationStatusMessage", &m.ActivationStatusMessage) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type ManagedHsm. func (m ManagedHsm) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) @@ -1323,6 +1490,33 @@ func (m *ManagedHsm) UnmarshalJSON(data []byte) error { return nil } +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmAction. +func (m ManagedHsmAction) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "type", m.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmAction. +func (m *ManagedHsmAction) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "type": + err = unpopulate(val, "Type", &m.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type ManagedHsmError. func (m ManagedHsmError) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) @@ -1350,6 +1544,318 @@ func (m *ManagedHsmError) UnmarshalJSON(data []byte) error { return nil } +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmKey. +func (m ManagedHsmKey) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", m.ID) + populate(objectMap, "name", m.Name) + populate(objectMap, "properties", m.Properties) + populate(objectMap, "tags", m.Tags) + populate(objectMap, "type", m.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmKey. +func (m *ManagedHsmKey) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &m.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &m.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &m.Properties) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &m.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &m.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmKeyAttributes. +func (m ManagedHsmKeyAttributes) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "created", m.Created) + populate(objectMap, "enabled", m.Enabled) + populate(objectMap, "exp", m.Expires) + populate(objectMap, "exportable", m.Exportable) + populate(objectMap, "nbf", m.NotBefore) + populate(objectMap, "recoveryLevel", m.RecoveryLevel) + populate(objectMap, "updated", m.Updated) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmKeyAttributes. +func (m *ManagedHsmKeyAttributes) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "created": + err = unpopulate(val, "Created", &m.Created) + delete(rawMsg, key) + case "enabled": + err = unpopulate(val, "Enabled", &m.Enabled) + delete(rawMsg, key) + case "exp": + err = unpopulate(val, "Expires", &m.Expires) + delete(rawMsg, key) + case "exportable": + err = unpopulate(val, "Exportable", &m.Exportable) + delete(rawMsg, key) + case "nbf": + err = unpopulate(val, "NotBefore", &m.NotBefore) + delete(rawMsg, key) + case "recoveryLevel": + err = unpopulate(val, "RecoveryLevel", &m.RecoveryLevel) + delete(rawMsg, key) + case "updated": + err = unpopulate(val, "Updated", &m.Updated) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmKeyCreateParameters. +func (m ManagedHsmKeyCreateParameters) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "properties", m.Properties) + populate(objectMap, "tags", m.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmKeyCreateParameters. +func (m *ManagedHsmKeyCreateParameters) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &m.Properties) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &m.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmKeyListResult. +func (m ManagedHsmKeyListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", m.NextLink) + populate(objectMap, "value", m.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmKeyListResult. +func (m *ManagedHsmKeyListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &m.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &m.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmKeyProperties. +func (m ManagedHsmKeyProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "attributes", m.Attributes) + populate(objectMap, "curveName", m.CurveName) + populate(objectMap, "keyOps", m.KeyOps) + populate(objectMap, "keySize", m.KeySize) + populate(objectMap, "keyUri", m.KeyURI) + populate(objectMap, "keyUriWithVersion", m.KeyURIWithVersion) + populate(objectMap, "kty", m.Kty) + populate(objectMap, "release_policy", m.ReleasePolicy) + populate(objectMap, "rotationPolicy", m.RotationPolicy) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmKeyProperties. +func (m *ManagedHsmKeyProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "attributes": + err = unpopulate(val, "Attributes", &m.Attributes) + delete(rawMsg, key) + case "curveName": + err = unpopulate(val, "CurveName", &m.CurveName) + delete(rawMsg, key) + case "keyOps": + err = unpopulate(val, "KeyOps", &m.KeyOps) + delete(rawMsg, key) + case "keySize": + err = unpopulate(val, "KeySize", &m.KeySize) + delete(rawMsg, key) + case "keyUri": + err = unpopulate(val, "KeyURI", &m.KeyURI) + delete(rawMsg, key) + case "keyUriWithVersion": + err = unpopulate(val, "KeyURIWithVersion", &m.KeyURIWithVersion) + delete(rawMsg, key) + case "kty": + err = unpopulate(val, "Kty", &m.Kty) + delete(rawMsg, key) + case "release_policy": + err = unpopulate(val, "ReleasePolicy", &m.ReleasePolicy) + delete(rawMsg, key) + case "rotationPolicy": + err = unpopulate(val, "RotationPolicy", &m.RotationPolicy) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmKeyReleasePolicy. +func (m ManagedHsmKeyReleasePolicy) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "contentType", m.ContentType) + populateByteArray(objectMap, "data", m.Data, runtime.Base64URLFormat) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmKeyReleasePolicy. +func (m *ManagedHsmKeyReleasePolicy) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "contentType": + err = unpopulate(val, "ContentType", &m.ContentType) + delete(rawMsg, key) + case "data": + err = runtime.DecodeByteArray(string(val), &m.Data, runtime.Base64URLFormat) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmKeyRotationPolicyAttributes. +func (m ManagedHsmKeyRotationPolicyAttributes) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "created", m.Created) + populate(objectMap, "expiryTime", m.ExpiryTime) + populate(objectMap, "updated", m.Updated) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmKeyRotationPolicyAttributes. +func (m *ManagedHsmKeyRotationPolicyAttributes) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "created": + err = unpopulate(val, "Created", &m.Created) + delete(rawMsg, key) + case "expiryTime": + err = unpopulate(val, "ExpiryTime", &m.ExpiryTime) + delete(rawMsg, key) + case "updated": + err = unpopulate(val, "Updated", &m.Updated) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmLifetimeAction. +func (m ManagedHsmLifetimeAction) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "action", m.Action) + populate(objectMap, "trigger", m.Trigger) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmLifetimeAction. +func (m *ManagedHsmLifetimeAction) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "action": + err = unpopulate(val, "Action", &m.Action) + delete(rawMsg, key) + case "trigger": + err = unpopulate(val, "Trigger", &m.Trigger) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type ManagedHsmListResult. func (m ManagedHsmListResult) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) @@ -1393,7 +1899,9 @@ func (m ManagedHsmProperties) MarshalJSON() ([]byte, error) { populate(objectMap, "privateEndpointConnections", m.PrivateEndpointConnections) populate(objectMap, "provisioningState", m.ProvisioningState) populate(objectMap, "publicNetworkAccess", m.PublicNetworkAccess) + populate(objectMap, "regions", m.Regions) populateTimeRFC3339(objectMap, "scheduledPurgeDate", m.ScheduledPurgeDate) + populate(objectMap, "securityDomainProperties", m.SecurityDomainProperties) populate(objectMap, "softDeleteRetentionInDays", m.SoftDeleteRetentionInDays) populate(objectMap, "statusMessage", m.StatusMessage) populate(objectMap, "tenantId", m.TenantID) @@ -1436,9 +1944,15 @@ func (m *ManagedHsmProperties) UnmarshalJSON(data []byte) error { case "publicNetworkAccess": err = unpopulate(val, "PublicNetworkAccess", &m.PublicNetworkAccess) delete(rawMsg, key) + case "regions": + err = unpopulate(val, "Regions", &m.Regions) + delete(rawMsg, key) case "scheduledPurgeDate": err = unpopulateTimeRFC3339(val, "ScheduledPurgeDate", &m.ScheduledPurgeDate) delete(rawMsg, key) + case "securityDomainProperties": + err = unpopulate(val, "SecurityDomainProperties", &m.SecurityDomainProperties) + delete(rawMsg, key) case "softDeleteRetentionInDays": err = unpopulate(val, "SoftDeleteRetentionInDays", &m.SoftDeleteRetentionInDays) delete(rawMsg, key) @@ -1507,6 +2021,37 @@ func (m *ManagedHsmResource) UnmarshalJSON(data []byte) error { return nil } +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmRotationPolicy. +func (m ManagedHsmRotationPolicy) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "attributes", m.Attributes) + populate(objectMap, "lifetimeActions", m.LifetimeActions) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmRotationPolicy. +func (m *ManagedHsmRotationPolicy) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "attributes": + err = unpopulate(val, "Attributes", &m.Attributes) + delete(rawMsg, key) + case "lifetimeActions": + err = unpopulate(val, "LifetimeActions", &m.LifetimeActions) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type ManagedHsmSKU. func (m ManagedHsmSKU) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) @@ -1541,6 +2086,37 @@ func (m *ManagedHsmSKU) UnmarshalJSON(data []byte) error { return nil } +// MarshalJSON implements the json.Marshaller interface for type ManagedHsmTrigger. +func (m ManagedHsmTrigger) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "timeAfterCreate", m.TimeAfterCreate) + populate(objectMap, "timeBeforeExpiry", m.TimeBeforeExpiry) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedHsmTrigger. +func (m *ManagedHsmTrigger) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "timeAfterCreate": + err = unpopulate(val, "TimeAfterCreate", &m.TimeAfterCreate) + delete(rawMsg, key) + case "timeBeforeExpiry": + err = unpopulate(val, "TimeBeforeExpiry", &m.TimeBeforeExpiry) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type MetricSpecification. func (m MetricSpecification) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) @@ -2149,6 +2725,45 @@ func (p *PrivateLinkServiceConnectionState) UnmarshalJSON(data []byte) error { return nil } +// MarshalJSON implements the json.Marshaller interface for type ProxyResourceWithoutSystemData. +func (p ProxyResourceWithoutSystemData) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", p.ID) + populate(objectMap, "name", p.Name) + populate(objectMap, "tags", p.Tags) + populate(objectMap, "type", p.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ProxyResourceWithoutSystemData. +func (p *ProxyResourceWithoutSystemData) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &p.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &p.Name) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &p.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &p.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + // MarshalJSON implements the json.Marshaller interface for type Resource. func (r Resource) MarshalJSON() ([]byte, error) { objectMap := make(map[string]any) diff --git a/sdk/resourcemanager/keyvault/armkeyvault/operations_client.go b/sdk/resourcemanager/keyvault/armkeyvault/operations_client.go index baa6464f9d75..3b7216f1d5bd 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/operations_client.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/operations_client.go @@ -40,7 +40,7 @@ func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientO // NewListPager - Lists all of the available Key Vault Rest API operations. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method. func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse] { return runtime.NewPager(runtime.PagingHandler[OperationsClientListResponse]{ @@ -78,7 +78,7 @@ func (client *OperationsClient) listCreateRequest(ctx context.Context, options * return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil diff --git a/sdk/resourcemanager/keyvault/armkeyvault/operations_client_example_test.go b/sdk/resourcemanager/keyvault/armkeyvault/operations_client_example_test.go deleted file mode 100644 index 3828c461fbd3..000000000000 --- a/sdk/resourcemanager/keyvault/armkeyvault/operations_client_example_test.go +++ /dev/null @@ -1,361 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armkeyvault_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/listOperations.json -func ExampleOperationsClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewOperationsClient().NewListPager(nil) - for pager.More() { - page, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range page.Value { - // You could use page here. We use blank identifier for just demo purposes. - _ = v - } - // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. - // page.OperationListResult = armkeyvault.OperationListResult{ - // Value: []*armkeyvault.Operation{ - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("View the properties of a key vault"), - // Operation: to.Ptr("View Key Vault"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Key Vault"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/write"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Create a new key vault or update the properties of an existing key vault"), - // Operation: to.Ptr("Update Key Vault"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Key Vault"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/delete"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Delete a key vault"), - // Operation: to.Ptr("Delete Key Vault"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Key Vault"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/deploy/action"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Enables access to secrets in a key vault when deploying Azure resources"), - // Operation: to.Ptr("Use Vault for Azure Deployments"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Key Vault"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/secrets/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("View the properties of a secret, but not its value"), - // Operation: to.Ptr("View Secret Properties"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Secret"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/secrets/write"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Create a new secret or update the value of an existing secret"), - // Operation: to.Ptr("Update Secret"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Secret"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/accessPolicies/write"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Update an existing access policy by merging or replacing, or add a new access policy to a vault."), - // Operation: to.Ptr("Update Access Policy"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Access Policy"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/providers/Microsoft.Insights/logDefinitions/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Gets the available logs for a key vault"), - // Operation: to.Ptr("Read log definition"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Key Vault Log Definition"), - // }, - // IsDataAction: to.Ptr(false), - // Origin: to.Ptr("system"), - // OperationProperties: &armkeyvault.OperationProperties{ - // ServiceSpecification: &armkeyvault.ServiceSpecification{ - // LogSpecifications: []*armkeyvault.LogSpecification{ - // { - // Name: to.Ptr("AuditEvent"), - // BlobDuration: to.Ptr("PT1H"), - // DisplayName: to.Ptr("Audit Logs"), - // }}, - // MetricSpecifications: []*armkeyvault.MetricSpecification{ - // { - // Name: to.Ptr("ServiceApiHit"), - // AggregationType: to.Ptr(""), - // Dimensions: []*armkeyvault.DimensionProperties{ - // { - // Name: to.Ptr("ActivityType"), - // DisplayName: to.Ptr(""), - // ToBeExportedForShoebox: to.Ptr(true), - // }, - // { - // Name: to.Ptr("ActivityName"), - // DisplayName: to.Ptr(""), - // ToBeExportedForShoebox: to.Ptr(true), - // }}, - // DisplayDescription: to.Ptr(""), - // DisplayName: to.Ptr(""), - // FillGapWithZero: to.Ptr(false), - // InternalMetricName: to.Ptr("AuditEvent"), - // LockAggregationType: to.Ptr(""), - // SupportedAggregationTypes: []*string{ - // to.Ptr("")}, - // SupportedTimeGrainTypes: []*string{ - // to.Ptr("")}, - // Unit: to.Ptr(""), - // }}, - // }, - // }, - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/providers/Microsoft.Insights/diagnosticSettings/Read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Gets the diagnostic setting for the resource"), - // Operation: to.Ptr("Read diagnostic setting"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Key Vault Diagnostic Settings"), - // }, - // IsDataAction: to.Ptr(false), - // Origin: to.Ptr("system"), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/providers/Microsoft.Insights/diagnosticSettings/Write"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Creates or updates the diagnostic setting for the resource"), - // Operation: to.Ptr("Write diagnostic setting"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Key Vault Diagnostic Settings"), - // }, - // IsDataAction: to.Ptr(false), - // Origin: to.Ptr("system"), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/register/action"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Registers a subscription"), - // Operation: to.Ptr("Register Subscription"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Subscription"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/unregister/action"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Unregisters a subscription"), - // Operation: to.Ptr("Unregister Subscription"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Subscription"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/operations/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Lists operations available on Microsoft.KeyVault resource provider"), - // Operation: to.Ptr("Available Key Vault Operations"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Operations"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/checkNameAvailability/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Checks that a key vault name is valid and is not in use"), - // Operation: to.Ptr("Check Name Availability"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Name Availability"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/deletedVaults/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("View the properties of soft deleted key vaults"), - // Operation: to.Ptr("View Soft Deleted Vaults"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Soft Deleted Key Vault"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/locations/deletedVaults/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("View the properties of a soft deleted key vault"), - // Operation: to.Ptr("View Soft Deleted Key Vault"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Soft Deleted Key Vault"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/locations/deletedVaults/purge/action"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Purge a soft deleted key vault"), - // Operation: to.Ptr("Purge Soft Deleted Key Vault"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Soft Deleted Key Vault"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/locations/operationResults/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Check the result of a long run operation"), - // Operation: to.Ptr("Check Operation Result"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Long Run Operation Result"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/hsmPools/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("View the properties of an HSM pool"), - // Operation: to.Ptr("View HSM pool"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("HSM pool"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/hsmPools/write"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Create a new HSM pool of update the properties of an existing HSM pool"), - // Operation: to.Ptr("Create or Update HSM pool"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("HSM pool"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/hsmPools/delete"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Delete an HSM pool"), - // Operation: to.Ptr("Delete HSM pool"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("HSM pool"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/hsmPools/joinVault/action"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Join a key vault to an HSM pool"), - // Operation: to.Ptr("Join KeyVault to HSM pool"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("HSM pool"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/managedHSMs/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("View the properties of a Managed HSM"), - // Operation: to.Ptr("View Managed HSM"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Managed HSM"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/managedHSMs/write"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Create a new Managed HSM of update the properties of an existing Managed HSM"), - // Operation: to.Ptr("Create or Update Managed HSM"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Managed HSM"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/managedHSMs/delete"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Delete a Managed HSM"), - // Operation: to.Ptr("Delete Managed HSM"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Managed HSM"), - // }, - // IsDataAction: to.Ptr(false), - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/vaults/providers/Microsoft.Insights/metricDefinitions/read"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Gets the available metrics for a key vault"), - // Operation: to.Ptr("Read metric definition"), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Key Vault Metric Definition"), - // }, - // IsDataAction: to.Ptr(false), - // Origin: to.Ptr("system"), - // OperationProperties: &armkeyvault.OperationProperties{ - // ServiceSpecification: &armkeyvault.ServiceSpecification{ - // }, - // }, - // }, - // { - // Name: to.Ptr("Microsoft.KeyVault/locations/deleteVirtualNetworkOrSubnets/action"), - // Display: &armkeyvault.OperationDisplay{ - // Description: to.Ptr("Notifies Microsoft.KeyVault that a virtual network or subnet is being deleted"), - // Operation: to.Ptr("Modify Network ACLs containing the deleted Vitual Network or Subnet "), - // Provider: to.Ptr("Microsoft Key Vault"), - // Resource: to.Ptr("Location"), - // }, - // IsDataAction: to.Ptr(false), - // Origin: to.Ptr("system"), - // }}, - // } - } -} diff --git a/sdk/resourcemanager/keyvault/armkeyvault/privateendpointconnections_client.go b/sdk/resourcemanager/keyvault/armkeyvault/privateendpointconnections_client.go index be52fb1e8508..5d48db74b8b7 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/privateendpointconnections_client.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/privateendpointconnections_client.go @@ -49,7 +49,7 @@ func NewPrivateEndpointConnectionsClient(subscriptionID string, credential azcor // BeginDelete - Deletes the specified private endpoint connection associated with the key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the key vault. // - vaultName - The name of the key vault. // - privateEndpointConnectionName - Name of the private endpoint connection associated with the key vault. @@ -70,7 +70,7 @@ func (client *PrivateEndpointConnectionsClient) BeginDelete(ctx context.Context, // Delete - Deletes the specified private endpoint connection associated with the key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 func (client *PrivateEndpointConnectionsClient) deleteOperation(ctx context.Context, resourceGroupName string, vaultName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientBeginDeleteOptions) (*http.Response, error) { req, err := client.deleteCreateRequest(ctx, resourceGroupName, vaultName, privateEndpointConnectionName, options) if err != nil { @@ -110,7 +110,7 @@ func (client *PrivateEndpointConnectionsClient) deleteCreateRequest(ctx context. return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -119,7 +119,7 @@ func (client *PrivateEndpointConnectionsClient) deleteCreateRequest(ctx context. // Get - Gets the specified private endpoint connection associated with the key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the key vault. // - vaultName - The name of the key vault. // - privateEndpointConnectionName - Name of the private endpoint connection associated with the key vault. @@ -164,7 +164,7 @@ func (client *PrivateEndpointConnectionsClient) getCreateRequest(ctx context.Con return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -182,7 +182,7 @@ func (client *PrivateEndpointConnectionsClient) getHandleResponse(resp *http.Res // NewListByResourcePager - The List operation gets information about the private endpoint connections associated with the // vault. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the key vault. // - vaultName - The name of the key vault. // - options - PrivateEndpointConnectionsClientListByResourceOptions contains the optional parameters for the PrivateEndpointConnectionsClient.NewListByResourcePager @@ -235,7 +235,7 @@ func (client *PrivateEndpointConnectionsClient) listByResourceCreateRequest(ctx return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -253,7 +253,7 @@ func (client *PrivateEndpointConnectionsClient) listByResourceHandleResponse(res // Put - Updates the specified private endpoint connection associated with the key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the key vault. // - vaultName - The name of the key vault. // - privateEndpointConnectionName - Name of the private endpoint connection associated with the key vault. @@ -299,7 +299,7 @@ func (client *PrivateEndpointConnectionsClient) putCreateRequest(ctx context.Con return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, properties) diff --git a/sdk/resourcemanager/keyvault/armkeyvault/privateendpointconnections_client_example_test.go b/sdk/resourcemanager/keyvault/armkeyvault/privateendpointconnections_client_example_test.go deleted file mode 100644 index a594766e99cc..000000000000 --- a/sdk/resourcemanager/keyvault/armkeyvault/privateendpointconnections_client_example_test.go +++ /dev/null @@ -1,195 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armkeyvault_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/getPrivateEndpointConnection.json -func ExamplePrivateEndpointConnectionsClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewPrivateEndpointConnectionsClient().Get(ctx, "sample-group", "sample-vault", "sample-pec", 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 = armkeyvault.PrivateEndpointConnection{ - // Name: to.Ptr("sample-pec"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/privateEndpointConnections"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/privateEndpointConnections/sample-pec"), - // Etag: to.Ptr(""), - // Properties: &armkeyvault.PrivateEndpointConnectionProperties{ - // PrivateEndpoint: &armkeyvault.PrivateEndpoint{ - // ID: to.Ptr("/subscriptions/00000000-0000-0000-1234-000000000000/resourceGroups/sample-group/providers/Microsoft.Network/privateEndpoints/sample-pe"), - // }, - // PrivateLinkServiceConnectionState: &armkeyvault.PrivateLinkServiceConnectionState{ - // Description: to.Ptr("This was automatically approved by user1234@contoso.com"), - // ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone), - // Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - // }, - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/putPrivateEndpointConnection.json -func ExamplePrivateEndpointConnectionsClient_Put() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewPrivateEndpointConnectionsClient().Put(ctx, "sample-group", "sample-vault", "sample-pec", armkeyvault.PrivateEndpointConnection{ - Etag: to.Ptr(""), - Properties: &armkeyvault.PrivateEndpointConnectionProperties{ - PrivateLinkServiceConnectionState: &armkeyvault.PrivateLinkServiceConnectionState{ - Description: to.Ptr("My name is Joe and I'm approving this."), - Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - }, - }, - }, 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 = armkeyvault.PrivateEndpointConnection{ - // Name: to.Ptr("sample-pec"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/privateEndpointConnections"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/privateEndpointConnections/sample-pec"), - // Etag: to.Ptr(""), - // Properties: &armkeyvault.PrivateEndpointConnectionProperties{ - // PrivateEndpoint: &armkeyvault.PrivateEndpoint{ - // ID: to.Ptr("/subscriptions/00000000-0000-0000-1234-000000000000/resourceGroups/sample-group/providers/Microsoft.Network/privateEndpoints/sample-pe"), - // }, - // PrivateLinkServiceConnectionState: &armkeyvault.PrivateLinkServiceConnectionState{ - // Description: to.Ptr("My name is Joe and I'm approving this."), - // ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone), - // Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - // }, - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/deletePrivateEndpointConnection.json -func ExamplePrivateEndpointConnectionsClient_BeginDelete() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewPrivateEndpointConnectionsClient().BeginDelete(ctx, "sample-group", "sample-vault", "sample-pec", 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 = armkeyvault.PrivateEndpointConnection{ - // Name: to.Ptr("sample-pec"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/privateEndpointConnections"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/privateEndpointConnections/sample-pec"), - // Properties: &armkeyvault.PrivateEndpointConnectionProperties{ - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/listPrivateEndpointConnection.json -func ExamplePrivateEndpointConnectionsClient_NewListByResourcePager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewPrivateEndpointConnectionsClient().NewListByResourcePager("sample-group", "sample-vault", 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 = armkeyvault.PrivateEndpointConnectionListResult{ - // Value: []*armkeyvault.PrivateEndpointConnection{ - // { - // Name: to.Ptr("sample-pec"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/privateEndpointConnections"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/privateEndpointConnections/sample-pec"), - // Etag: to.Ptr(""), - // Properties: &armkeyvault.PrivateEndpointConnectionProperties{ - // PrivateEndpoint: &armkeyvault.PrivateEndpoint{ - // ID: to.Ptr("/subscriptions/00000000-0000-0000-1234-000000000000/resourceGroups/sample-group/providers/Microsoft.Network/privateEndpoints/sample-pe"), - // }, - // PrivateLinkServiceConnectionState: &armkeyvault.PrivateLinkServiceConnectionState{ - // Description: to.Ptr("This was automatically approved by user1234@contoso.com"), - // ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone), - // Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - // }, - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // }, - // { - // Name: to.Ptr("sample-pec"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/privateEndpointConnections"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/privateEndpointConnections/sample-pec"), - // Etag: to.Ptr(""), - // Properties: &armkeyvault.PrivateEndpointConnectionProperties{ - // PrivateEndpoint: &armkeyvault.PrivateEndpoint{ - // ID: to.Ptr("/subscriptions/00000000-0000-0000-1234-000000000000/resourceGroups/sample-group/providers/Microsoft.Network/privateEndpoints/sample-pe"), - // }, - // PrivateLinkServiceConnectionState: &armkeyvault.PrivateLinkServiceConnectionState{ - // Description: to.Ptr("This was automatically approved by user1234@contoso.com"), - // ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone), - // Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - // }, - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // }}, - // } - } -} diff --git a/sdk/resourcemanager/keyvault/armkeyvault/privatelinkresources_client.go b/sdk/resourcemanager/keyvault/armkeyvault/privatelinkresources_client.go index 402a2e401559..731c8aa545de 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/privatelinkresources_client.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/privatelinkresources_client.go @@ -48,7 +48,7 @@ func NewPrivateLinkResourcesClient(subscriptionID string, credential azcore.Toke // ListByVault - Gets the private link resources supported for the key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - Name of the resource group that contains the key vault. // - vaultName - The name of the key vault. // - options - PrivateLinkResourcesClientListByVaultOptions contains the optional parameters for the PrivateLinkResourcesClient.ListByVault @@ -88,7 +88,7 @@ func (client *PrivateLinkResourcesClient) listByVaultCreateRequest(ctx context.C return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil diff --git a/sdk/resourcemanager/keyvault/armkeyvault/privatelinkresources_client_example_test.go b/sdk/resourcemanager/keyvault/armkeyvault/privatelinkresources_client_example_test.go deleted file mode 100644 index 888bbcc97248..000000000000 --- a/sdk/resourcemanager/keyvault/armkeyvault/privatelinkresources_client_example_test.go +++ /dev/null @@ -1,53 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armkeyvault_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/listPrivateLinkResources.json -func ExamplePrivateLinkResourcesClient_ListByVault() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewPrivateLinkResourcesClient().ListByVault(ctx, "sample-group", "sample-vault", 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.PrivateLinkResourceListResult = armkeyvault.PrivateLinkResourceListResult{ - // Value: []*armkeyvault.PrivateLinkResource{ - // { - // Name: to.Ptr("vault"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/privateLinkResources"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-resource-group/providers/Microsoft.KeyVault/vaults/sample-vault/privateLinkResources/vault"), - // Properties: &armkeyvault.PrivateLinkResourceProperties{ - // GroupID: to.Ptr("vault"), - // RequiredMembers: []*string{ - // to.Ptr("default")}, - // RequiredZoneNames: []*string{ - // to.Ptr("privatelink.vaultcore.azure.net")}, - // }, - // }}, - // } -} diff --git a/sdk/resourcemanager/keyvault/armkeyvault/response_types.go b/sdk/resourcemanager/keyvault/armkeyvault/response_types.go index 43f9c5c2ad56..a1fd185c6524 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/response_types.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/response_types.go @@ -64,6 +64,41 @@ type MHSMPrivateLinkResourcesClientListByMHSMResourceResponse struct { MHSMPrivateLinkResourceListResult } +// MHSMRegionsClientListByResourceResponse contains the response from method MHSMRegionsClient.NewListByResourcePager. +type MHSMRegionsClientListByResourceResponse struct { + MHSMRegionsListResult +} + +// ManagedHsmKeysClientCreateIfNotExistResponse contains the response from method ManagedHsmKeysClient.CreateIfNotExist. +type ManagedHsmKeysClientCreateIfNotExistResponse struct { + ManagedHsmKey +} + +// ManagedHsmKeysClientGetResponse contains the response from method ManagedHsmKeysClient.Get. +type ManagedHsmKeysClientGetResponse struct { + ManagedHsmKey +} + +// ManagedHsmKeysClientGetVersionResponse contains the response from method ManagedHsmKeysClient.GetVersion. +type ManagedHsmKeysClientGetVersionResponse struct { + ManagedHsmKey +} + +// ManagedHsmKeysClientListResponse contains the response from method ManagedHsmKeysClient.NewListPager. +type ManagedHsmKeysClientListResponse struct { + ManagedHsmKeyListResult +} + +// ManagedHsmKeysClientListVersionsResponse contains the response from method ManagedHsmKeysClient.NewListVersionsPager. +type ManagedHsmKeysClientListVersionsResponse struct { + ManagedHsmKeyListResult +} + +// ManagedHsmsClientCheckMhsmNameAvailabilityResponse contains the response from method ManagedHsmsClient.CheckMhsmNameAvailability. +type ManagedHsmsClientCheckMhsmNameAvailabilityResponse struct { + CheckMhsmNameAvailabilityResult +} + // ManagedHsmsClientCreateOrUpdateResponse contains the response from method ManagedHsmsClient.BeginCreateOrUpdate. type ManagedHsmsClientCreateOrUpdateResponse struct { ManagedHsm diff --git a/sdk/resourcemanager/keyvault/armkeyvault/secrets_client.go b/sdk/resourcemanager/keyvault/armkeyvault/secrets_client.go index 7fb30d35acd8..cf43971e133b 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/secrets_client.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/secrets_client.go @@ -51,10 +51,11 @@ func NewSecretsClient(subscriptionID string, credential azcore.TokenCredential, // with vault secrets. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the Resource Group to which the vault belongs. // - vaultName - Name of the vault -// - secretName - Name of the secret +// - secretName - Name of the secret. The value you provide may be copied globally for the purpose of running the service. The +// value provided should not include personally identifiable or sensitive information. // - parameters - Parameters to create or update the secret // - options - SecretsClientCreateOrUpdateOptions contains the optional parameters for the SecretsClient.CreateOrUpdate method. func (client *SecretsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, vaultName string, secretName string, parameters SecretCreateOrUpdateParameters, options *SecretsClientCreateOrUpdateOptions) (SecretsClientCreateOrUpdateResponse, error) { @@ -96,7 +97,7 @@ func (client *SecretsClient) createOrUpdateCreateRequest(ctx context.Context, re return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, parameters) @@ -115,7 +116,7 @@ func (client *SecretsClient) createOrUpdateHandleResponse(resp *http.Response) ( // REST service for interaction with vault secrets. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the Resource Group to which the vault belongs. // - vaultName - The name of the vault. // - secretName - The name of the secret. @@ -159,7 +160,7 @@ func (client *SecretsClient) getCreateRequest(ctx context.Context, resourceGroup return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -178,7 +179,7 @@ func (client *SecretsClient) getHandleResponse(resp *http.Response) (SecretsClie // use in ARM deployments. Users should use the data-plane REST service for interaction with // vault secrets. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the Resource Group to which the vault belongs. // - vaultName - The name of the vault. // - options - SecretsClientListOptions contains the optional parameters for the SecretsClient.NewListPager method. @@ -233,7 +234,7 @@ func (client *SecretsClient) listCreateRequest(ctx context.Context, resourceGrou if options != nil && options.Top != nil { reqQP.Set("$top", strconv.FormatInt(int64(*options.Top), 10)) } - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -252,7 +253,7 @@ func (client *SecretsClient) listHandleResponse(resp *http.Response) (SecretsCli // Users should use the data-plane REST service for interaction with vault secrets. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the Resource Group to which the vault belongs. // - vaultName - Name of the vault // - secretName - Name of the secret @@ -297,7 +298,7 @@ func (client *SecretsClient) updateCreateRequest(ctx context.Context, resourceGr return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, parameters) diff --git a/sdk/resourcemanager/keyvault/armkeyvault/secrets_client_example_test.go b/sdk/resourcemanager/keyvault/armkeyvault/secrets_client_example_test.go deleted file mode 100644 index 4ace900d27fb..000000000000 --- a/sdk/resourcemanager/keyvault/armkeyvault/secrets_client_example_test.go +++ /dev/null @@ -1,190 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armkeyvault_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/createSecret.json -func ExampleSecretsClient_CreateOrUpdate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewSecretsClient().CreateOrUpdate(ctx, "sample-group", "sample-vault", "secret-name", armkeyvault.SecretCreateOrUpdateParameters{ - Properties: &armkeyvault.SecretProperties{ - Value: to.Ptr("secret-value"), - }, - }, 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.Secret = armkeyvault.Secret{ - // Name: to.Ptr("secret-name"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/secrets"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/secrets/secret-name"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.SecretProperties{ - // Attributes: &armkeyvault.SecretAttributes{ - // Created: to.Ptr(time.Unix(1514938738, 0)), - // Enabled: to.Ptr(true), - // Updated: to.Ptr(time.Unix(1514938738, 0)), - // }, - // SecretURI: to.Ptr("https://sample-vault.vault.azure.net/secrets/secret-name"), - // SecretURIWithVersion: to.Ptr("https:/sample-vault.vault.azure.net/secrets/secret-name/baf6de32c4774c7c81345f6476cf90a4"), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/updateSecret.json -func ExampleSecretsClient_Update() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewSecretsClient().Update(ctx, "sample-group", "sample-vault", "secret-name", armkeyvault.SecretPatchParameters{ - Properties: &armkeyvault.SecretPatchProperties{ - Value: to.Ptr("secret-value2"), - }, - }, 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.Secret = armkeyvault.Secret{ - // Name: to.Ptr("secret-name"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/secrets"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/secrets/secret-name"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.SecretProperties{ - // Attributes: &armkeyvault.SecretAttributes{ - // Created: to.Ptr(time.Unix(1514940684, 0)), - // Enabled: to.Ptr(true), - // Updated: to.Ptr(time.Unix(1514940698, 0)), - // }, - // SecretURI: to.Ptr("https://sample-vault.vault.azure.net/secrets/secret-name"), - // SecretURIWithVersion: to.Ptr("https://sample-vault.vault.azure.net/secrets/secret-name/b8c802f549764f2d97885d152f92ee9d"), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/getSecret.json -func ExampleSecretsClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewSecretsClient().Get(ctx, "sample-group", "sample-vault", "secret-name", 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.Secret = armkeyvault.Secret{ - // Name: to.Ptr("secret-name"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/secrets"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/secrets/secret-name"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.SecretProperties{ - // Attributes: &armkeyvault.SecretAttributes{ - // Created: to.Ptr(time.Unix(1514940950, 0)), - // Enabled: to.Ptr(true), - // Updated: to.Ptr(time.Unix(1514940950, 0)), - // }, - // SecretURI: to.Ptr("https://sample-vault.vault.azure.net/secrets/secret-name"), - // SecretURIWithVersion: to.Ptr("https://sample-vault.vault.azure.net/secrets/secret-name/77445834f7de41bab81d0723bf996860"), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/listSecrets.json -func ExampleSecretsClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewSecretsClient().NewListPager("sample-group", "sample-vault", &armkeyvault.SecretsClientListOptions{Top: 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.SecretListResult = armkeyvault.SecretListResult{ - // Value: []*armkeyvault.Secret{ - // { - // Name: to.Ptr("secret-name"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/secrets"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/secrets/secret-name"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.SecretProperties{ - // Attributes: &armkeyvault.SecretAttributes{ - // Created: to.Ptr(time.Unix(1514941476, 0)), - // Enabled: to.Ptr(true), - // Updated: to.Ptr(time.Unix(1514941476, 0)), - // }, - // SecretURI: to.Ptr("https://sample-vault.vault.azure.net/secrets/secret-name"), - // SecretURIWithVersion: to.Ptr("https://sample-vault.vault.azure.net/secrets/secret-name/40af42fbc10047f8a756a73211492f56"), - // }, - // }, - // { - // Name: to.Ptr("secret-name2"), - // Type: to.Ptr("Microsoft.KeyVault/vaults/secrets"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/secrets/secret-name2"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.SecretProperties{ - // Attributes: &armkeyvault.SecretAttributes{ - // Created: to.Ptr(time.Unix(1514941476, 0)), - // Enabled: to.Ptr(true), - // Updated: to.Ptr(time.Unix(1514941476, 0)), - // }, - // SecretURI: to.Ptr("https://sample-vault.vault.azure.net/secrets/secret-name2"), - // SecretURIWithVersion: to.Ptr("https://sample-vault.vault.azure.net/secrets/secret-name2/cd7264a6f56c44d1b594423c80609aae"), - // }, - // }}, - // } - } -} diff --git a/sdk/resourcemanager/keyvault/armkeyvault/vaults_client.go b/sdk/resourcemanager/keyvault/armkeyvault/vaults_client.go index c13a4d2c4129..b087a90a98f4 100644 --- a/sdk/resourcemanager/keyvault/armkeyvault/vaults_client.go +++ b/sdk/resourcemanager/keyvault/armkeyvault/vaults_client.go @@ -49,7 +49,7 @@ func NewVaultsClient(subscriptionID string, credential azcore.TokenCredential, o // CheckNameAvailability - Checks that the vault name is valid and is not already in use. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - vaultName - The name of the vault. // - options - VaultsClientCheckNameAvailabilityOptions contains the optional parameters for the VaultsClient.CheckNameAvailability // method. @@ -80,7 +80,7 @@ func (client *VaultsClient) checkNameAvailabilityCreateRequest(ctx context.Conte return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, vaultName) @@ -98,7 +98,7 @@ func (client *VaultsClient) checkNameAvailabilityHandleResponse(resp *http.Respo // BeginCreateOrUpdate - Create or update a key vault in the specified subscription. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the Resource Group to which the server belongs. // - vaultName - Name of the vault // - parameters - Parameters to create or update the vault @@ -119,7 +119,7 @@ func (client *VaultsClient) BeginCreateOrUpdate(ctx context.Context, resourceGro // CreateOrUpdate - Create or update a key vault in the specified subscription. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 func (client *VaultsClient) createOrUpdate(ctx context.Context, resourceGroupName string, vaultName string, parameters VaultCreateOrUpdateParameters, options *VaultsClientBeginCreateOrUpdateOptions) (*http.Response, error) { req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, vaultName, parameters, options) if err != nil { @@ -155,7 +155,7 @@ func (client *VaultsClient) createOrUpdateCreateRequest(ctx context.Context, res return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, parameters) @@ -164,7 +164,7 @@ func (client *VaultsClient) createOrUpdateCreateRequest(ctx context.Context, res // Delete - Deletes the specified Azure key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the Resource Group to which the vault belongs. // - vaultName - The name of the vault to delete // - options - VaultsClientDeleteOptions contains the optional parameters for the VaultsClient.Delete method. @@ -203,7 +203,7 @@ func (client *VaultsClient) deleteCreateRequest(ctx context.Context, resourceGro return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -212,7 +212,7 @@ func (client *VaultsClient) deleteCreateRequest(ctx context.Context, resourceGro // Get - Gets the specified Azure key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the Resource Group to which the vault belongs. // - vaultName - The name of the vault. // - options - VaultsClientGetOptions contains the optional parameters for the VaultsClient.Get method. @@ -251,7 +251,7 @@ func (client *VaultsClient) getCreateRequest(ctx context.Context, resourceGroupN return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -269,7 +269,7 @@ func (client *VaultsClient) getHandleResponse(resp *http.Response) (VaultsClient // GetDeleted - Gets the deleted Azure key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - vaultName - The name of the vault. // - location - The location of the deleted vault. // - options - VaultsClientGetDeletedOptions contains the optional parameters for the VaultsClient.GetDeleted method. @@ -308,7 +308,7 @@ func (client *VaultsClient) getDeletedCreateRequest(ctx context.Context, vaultNa return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -325,7 +325,7 @@ func (client *VaultsClient) getDeletedHandleResponse(resp *http.Response) (Vault // NewListPager - The List operation gets information about the vaults associated with the subscription. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - options - VaultsClientListOptions contains the optional parameters for the VaultsClient.NewListPager method. func (client *VaultsClient) NewListPager(options *VaultsClientListOptions) *runtime.Pager[VaultsClientListResponse] { return runtime.NewPager(runtime.PagingHandler[VaultsClientListResponse]{ @@ -389,7 +389,7 @@ func (client *VaultsClient) listHandleResponse(resp *http.Response) (VaultsClien // NewListByResourceGroupPager - The List operation gets information about the vaults associated with the subscription and // within the specified resource group. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the Resource Group to which the vault belongs. // - options - VaultsClientListByResourceGroupOptions contains the optional parameters for the VaultsClient.NewListByResourceGroupPager // method. @@ -440,7 +440,7 @@ func (client *VaultsClient) listByResourceGroupCreateRequest(ctx context.Context if options != nil && options.Top != nil { reqQP.Set("$top", strconv.FormatInt(int64(*options.Top), 10)) } - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -457,7 +457,7 @@ func (client *VaultsClient) listByResourceGroupHandleResponse(resp *http.Respons // NewListBySubscriptionPager - The List operation gets information about the vaults associated with the subscription. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - options - VaultsClientListBySubscriptionOptions contains the optional parameters for the VaultsClient.NewListBySubscriptionPager // method. func (client *VaultsClient) NewListBySubscriptionPager(options *VaultsClientListBySubscriptionOptions) *runtime.Pager[VaultsClientListBySubscriptionResponse] { @@ -503,7 +503,7 @@ func (client *VaultsClient) listBySubscriptionCreateRequest(ctx context.Context, if options != nil && options.Top != nil { reqQP.Set("$top", strconv.FormatInt(int64(*options.Top), 10)) } - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -520,7 +520,7 @@ func (client *VaultsClient) listBySubscriptionHandleResponse(resp *http.Response // NewListDeletedPager - Gets information about the deleted vaults in a subscription. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - options - VaultsClientListDeletedOptions contains the optional parameters for the VaultsClient.NewListDeletedPager method. func (client *VaultsClient) NewListDeletedPager(options *VaultsClientListDeletedOptions) *runtime.Pager[VaultsClientListDeletedResponse] { return runtime.NewPager(runtime.PagingHandler[VaultsClientListDeletedResponse]{ @@ -562,7 +562,7 @@ func (client *VaultsClient) listDeletedCreateRequest(ctx context.Context, option return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -580,7 +580,7 @@ func (client *VaultsClient) listDeletedHandleResponse(resp *http.Response) (Vaul // BeginPurgeDeleted - Permanently deletes the specified vault. aka Purges the deleted Azure key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - vaultName - The name of the soft-deleted vault. // - location - The location of the soft-deleted vault. // - options - VaultsClientBeginPurgeDeletedOptions contains the optional parameters for the VaultsClient.BeginPurgeDeleted @@ -600,7 +600,7 @@ func (client *VaultsClient) BeginPurgeDeleted(ctx context.Context, vaultName str // PurgeDeleted - Permanently deletes the specified vault. aka Purges the deleted Azure key vault. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 func (client *VaultsClient) purgeDeleted(ctx context.Context, vaultName string, location string, options *VaultsClientBeginPurgeDeletedOptions) (*http.Response, error) { req, err := client.purgeDeletedCreateRequest(ctx, vaultName, location, options) if err != nil { @@ -636,7 +636,7 @@ func (client *VaultsClient) purgeDeletedCreateRequest(ctx context.Context, vault return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, nil @@ -645,7 +645,7 @@ func (client *VaultsClient) purgeDeletedCreateRequest(ctx context.Context, vault // Update - Update a key vault in the specified subscription. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the Resource Group to which the server belongs. // - vaultName - Name of the vault // - parameters - Parameters to patch the vault @@ -685,7 +685,7 @@ func (client *VaultsClient) updateCreateRequest(ctx context.Context, resourceGro return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, parameters) @@ -703,7 +703,7 @@ func (client *VaultsClient) updateHandleResponse(resp *http.Response) (VaultsCli // UpdateAccessPolicy - Update access policies in a key vault in the specified subscription. // If the operation fails it returns an *azcore.ResponseError type. // -// Generated from API version 2021-11-01-preview +// Generated from API version 2023-02-01 // - resourceGroupName - The name of the Resource Group to which the vault belongs. // - vaultName - Name of the vault // - operationKind - Name of the operation @@ -749,7 +749,7 @@ func (client *VaultsClient) updateAccessPolicyCreateRequest(ctx context.Context, return nil, err } reqQP := req.Raw().URL.Query() - reqQP.Set("api-version", "2021-11-01-preview") + reqQP.Set("api-version", "2023-02-01") req.Raw().URL.RawQuery = reqQP.Encode() req.Raw().Header["Accept"] = []string{"application/json"} return req, runtime.MarshalAsJSON(req, parameters) diff --git a/sdk/resourcemanager/keyvault/armkeyvault/vaults_client_example_test.go b/sdk/resourcemanager/keyvault/armkeyvault/vaults_client_example_test.go deleted file mode 100644 index bf2a8e63c01d..000000000000 --- a/sdk/resourcemanager/keyvault/armkeyvault/vaults_client_example_test.go +++ /dev/null @@ -1,1030 +0,0 @@ -//go:build go1.18 -// +build go1.18 - -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. See License.txt in the project root for license information. -// Code generated by Microsoft (R) AutoRest Code Generator. -// Changes may cause incorrect behavior and will be lost if the code is regenerated. -// DO NOT EDIT. - -package armkeyvault_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/keyvault/armkeyvault" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/createVault.json -func ExampleVaultsClient_BeginCreateOrUpdate_createANewVaultOrUpdateAnExistingVault() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewVaultsClient().BeginCreateOrUpdate(ctx, "sample-resource-group", "sample-vault", armkeyvault.VaultCreateOrUpdateParameters{ - Location: to.Ptr("westus"), - Properties: &armkeyvault.VaultProperties{ - AccessPolicies: []*armkeyvault.AccessPolicyEntry{ - { - ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"), - Permissions: &armkeyvault.Permissions{ - Certificates: []*armkeyvault.CertificatePermissions{ - to.Ptr(armkeyvault.CertificatePermissionsGet), - to.Ptr(armkeyvault.CertificatePermissionsList), - to.Ptr(armkeyvault.CertificatePermissionsDelete), - to.Ptr(armkeyvault.CertificatePermissionsCreate), - to.Ptr(armkeyvault.CertificatePermissionsImport), - to.Ptr(armkeyvault.CertificatePermissionsUpdate), - to.Ptr(armkeyvault.CertificatePermissionsManagecontacts), - to.Ptr(armkeyvault.CertificatePermissionsGetissuers), - to.Ptr(armkeyvault.CertificatePermissionsListissuers), - to.Ptr(armkeyvault.CertificatePermissionsSetissuers), - to.Ptr(armkeyvault.CertificatePermissionsDeleteissuers), - to.Ptr(armkeyvault.CertificatePermissionsManageissuers), - to.Ptr(armkeyvault.CertificatePermissionsRecover), - to.Ptr(armkeyvault.CertificatePermissionsPurge)}, - Keys: []*armkeyvault.KeyPermissions{ - to.Ptr(armkeyvault.KeyPermissionsEncrypt), - to.Ptr(armkeyvault.KeyPermissionsDecrypt), - to.Ptr(armkeyvault.KeyPermissionsWrapKey), - to.Ptr(armkeyvault.KeyPermissionsUnwrapKey), - to.Ptr(armkeyvault.KeyPermissionsSign), - to.Ptr(armkeyvault.KeyPermissionsVerify), - to.Ptr(armkeyvault.KeyPermissionsGet), - to.Ptr(armkeyvault.KeyPermissionsList), - to.Ptr(armkeyvault.KeyPermissionsCreate), - to.Ptr(armkeyvault.KeyPermissionsUpdate), - to.Ptr(armkeyvault.KeyPermissionsImport), - to.Ptr(armkeyvault.KeyPermissionsDelete), - to.Ptr(armkeyvault.KeyPermissionsBackup), - to.Ptr(armkeyvault.KeyPermissionsRestore), - to.Ptr(armkeyvault.KeyPermissionsRecover), - to.Ptr(armkeyvault.KeyPermissionsPurge)}, - Secrets: []*armkeyvault.SecretPermissions{ - to.Ptr(armkeyvault.SecretPermissionsGet), - to.Ptr(armkeyvault.SecretPermissionsList), - to.Ptr(armkeyvault.SecretPermissionsSet), - to.Ptr(armkeyvault.SecretPermissionsDelete), - to.Ptr(armkeyvault.SecretPermissionsBackup), - to.Ptr(armkeyvault.SecretPermissionsRestore), - to.Ptr(armkeyvault.SecretPermissionsRecover), - to.Ptr(armkeyvault.SecretPermissionsPurge)}, - }, - TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - }}, - EnabledForDeployment: to.Ptr(true), - EnabledForDiskEncryption: to.Ptr(true), - EnabledForTemplateDeployment: to.Ptr(true), - PublicNetworkAccess: to.Ptr("Enabled"), - SKU: &armkeyvault.SKU{ - Name: to.Ptr(armkeyvault.SKUNameStandard), - Family: to.Ptr(armkeyvault.SKUFamilyA), - }, - TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - }, - }, 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.Vault = armkeyvault.Vault{ - // Name: to.Ptr("sample-vault"), - // Type: to.Ptr("Microsoft.KeyVault/vaults"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-resource-group/providers/Microsoft.KeyVault/vaults/sample-vault"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.VaultProperties{ - // AccessPolicies: []*armkeyvault.AccessPolicyEntry{ - // { - // ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // Permissions: &armkeyvault.Permissions{ - // Certificates: []*armkeyvault.CertificatePermissions{ - // to.Ptr(armkeyvault.CertificatePermissionsGet), - // to.Ptr(armkeyvault.CertificatePermissionsList), - // to.Ptr(armkeyvault.CertificatePermissionsDelete), - // to.Ptr(armkeyvault.CertificatePermissionsCreate), - // to.Ptr(armkeyvault.CertificatePermissionsImport), - // to.Ptr(armkeyvault.CertificatePermissionsUpdate), - // to.Ptr(armkeyvault.CertificatePermissionsManagecontacts), - // to.Ptr(armkeyvault.CertificatePermissionsGetissuers), - // to.Ptr(armkeyvault.CertificatePermissionsListissuers), - // to.Ptr(armkeyvault.CertificatePermissionsSetissuers), - // to.Ptr(armkeyvault.CertificatePermissionsDeleteissuers), - // to.Ptr(armkeyvault.CertificatePermissionsManageissuers), - // to.Ptr(armkeyvault.CertificatePermissionsRecover), - // to.Ptr(armkeyvault.CertificatePermissionsPurge)}, - // Keys: []*armkeyvault.KeyPermissions{ - // to.Ptr(armkeyvault.KeyPermissionsEncrypt), - // to.Ptr(armkeyvault.KeyPermissionsDecrypt), - // to.Ptr(armkeyvault.KeyPermissionsWrapKey), - // to.Ptr(armkeyvault.KeyPermissionsUnwrapKey), - // to.Ptr(armkeyvault.KeyPermissionsSign), - // to.Ptr(armkeyvault.KeyPermissionsVerify), - // to.Ptr(armkeyvault.KeyPermissionsGet), - // to.Ptr(armkeyvault.KeyPermissionsList), - // to.Ptr(armkeyvault.KeyPermissionsCreate), - // to.Ptr(armkeyvault.KeyPermissionsUpdate), - // to.Ptr(armkeyvault.KeyPermissionsImport), - // to.Ptr(armkeyvault.KeyPermissionsDelete), - // to.Ptr(armkeyvault.KeyPermissionsBackup), - // to.Ptr(armkeyvault.KeyPermissionsRestore), - // to.Ptr(armkeyvault.KeyPermissionsRecover), - // to.Ptr(armkeyvault.KeyPermissionsPurge)}, - // Secrets: []*armkeyvault.SecretPermissions{ - // to.Ptr(armkeyvault.SecretPermissionsGet), - // to.Ptr(armkeyvault.SecretPermissionsList), - // to.Ptr(armkeyvault.SecretPermissionsSet), - // to.Ptr(armkeyvault.SecretPermissionsDelete), - // to.Ptr(armkeyvault.SecretPermissionsBackup), - // to.Ptr(armkeyvault.SecretPermissionsRestore), - // to.Ptr(armkeyvault.SecretPermissionsRecover), - // to.Ptr(armkeyvault.SecretPermissionsPurge)}, - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }}, - // EnabledForDeployment: to.Ptr(true), - // EnabledForDiskEncryption: to.Ptr(true), - // EnabledForTemplateDeployment: to.Ptr(true), - // HsmPoolResourceID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // NetworkACLs: &armkeyvault.NetworkRuleSet{ - // Bypass: to.Ptr(armkeyvault.NetworkRuleBypassOptionsAzureServices), - // DefaultAction: to.Ptr(armkeyvault.NetworkRuleActionDeny), - // IPRules: []*armkeyvault.IPRule{ - // { - // Value: to.Ptr(""), - // }}, - // VirtualNetworkRules: []*armkeyvault.VirtualNetworkRule{ - // { - // ID: to.Ptr(""), - // IgnoreMissingVnetServiceEndpoint: to.Ptr(false), - // }}, - // }, - // PrivateEndpointConnections: []*armkeyvault.PrivateEndpointConnectionItem{ - // { - // Etag: to.Ptr(""), - // ID: to.Ptr(""), - // Properties: &armkeyvault.PrivateEndpointConnectionProperties{ - // PrivateEndpoint: &armkeyvault.PrivateEndpoint{ - // ID: to.Ptr(""), - // }, - // PrivateLinkServiceConnectionState: &armkeyvault.PrivateLinkServiceConnectionState{ - // ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone), - // Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - // }, - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // }}, - // ProvisioningState: to.Ptr(armkeyvault.VaultProvisioningStateSucceeded), - // PublicNetworkAccess: to.Ptr("Enabled"), - // SKU: &armkeyvault.SKU{ - // Name: to.Ptr(armkeyvault.SKUNameStandard), - // Family: to.Ptr(armkeyvault.SKUFamilyA), - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // VaultURI: to.Ptr("https://sample-vault.vault.azure.net"), - // }, - // SystemData: &armkeyvault.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // CreatedBy: to.Ptr("keyVaultUser1"), - // CreatedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // LastModifiedBy: to.Ptr("keyVaultUser2"), - // LastModifiedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // }, - // Tags: map[string]*string{ - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/createVaultWithNetworkAcls.json -func ExampleVaultsClient_BeginCreateOrUpdate_createOrUpdateAVaultWithNetworkAcls() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewVaultsClient().BeginCreateOrUpdate(ctx, "sample-resource-group", "sample-vault", armkeyvault.VaultCreateOrUpdateParameters{ - Location: to.Ptr("westus"), - Properties: &armkeyvault.VaultProperties{ - EnabledForDeployment: to.Ptr(true), - EnabledForDiskEncryption: to.Ptr(true), - EnabledForTemplateDeployment: to.Ptr(true), - NetworkACLs: &armkeyvault.NetworkRuleSet{ - Bypass: to.Ptr(armkeyvault.NetworkRuleBypassOptionsAzureServices), - DefaultAction: to.Ptr(armkeyvault.NetworkRuleActionDeny), - IPRules: []*armkeyvault.IPRule{ - { - Value: to.Ptr("124.56.78.91"), - }, - { - Value: to.Ptr("'10.91.4.0/24'"), - }}, - VirtualNetworkRules: []*armkeyvault.VirtualNetworkRule{ - { - ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1"), - }}, - }, - SKU: &armkeyvault.SKU{ - Name: to.Ptr(armkeyvault.SKUNameStandard), - Family: to.Ptr(armkeyvault.SKUFamilyA), - }, - TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - }, - }, 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.Vault = armkeyvault.Vault{ - // Name: to.Ptr("sample-vault"), - // Type: to.Ptr("Microsoft.KeyVault/vaults"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-resource-group/providers/Microsoft.KeyVault/vaults/sample-vault"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.VaultProperties{ - // EnabledForDeployment: to.Ptr(true), - // EnabledForDiskEncryption: to.Ptr(true), - // EnabledForTemplateDeployment: to.Ptr(true), - // HsmPoolResourceID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // NetworkACLs: &armkeyvault.NetworkRuleSet{ - // Bypass: to.Ptr(armkeyvault.NetworkRuleBypassOptionsAzureServices), - // DefaultAction: to.Ptr(armkeyvault.NetworkRuleActionDeny), - // IPRules: []*armkeyvault.IPRule{ - // { - // Value: to.Ptr("124.56.78.91/32"), - // }, - // { - // Value: to.Ptr("'10.91.4.0/24'"), - // }}, - // VirtualNetworkRules: []*armkeyvault.VirtualNetworkRule{ - // { - // ID: to.Ptr("/subscriptions/subid/resourcegroups/rg1/providers/microsoft.network/virtualnetworks/test-vnet/subnets/subnet1"), - // }}, - // }, - // SKU: &armkeyvault.SKU{ - // Name: to.Ptr(armkeyvault.SKUNameStandard), - // Family: to.Ptr(armkeyvault.SKUFamilyA), - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // VaultURI: to.Ptr("https://sample-vault.vault.azure.net"), - // }, - // SystemData: &armkeyvault.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // CreatedBy: to.Ptr("keyVaultUser1"), - // CreatedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // LastModifiedBy: to.Ptr("keyVaultUser2"), - // LastModifiedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // }, - // Tags: map[string]*string{ - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/updateVault.json -func ExampleVaultsClient_Update() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewVaultsClient().Update(ctx, "sample-resource-group", "sample-vault", armkeyvault.VaultPatchParameters{ - Properties: &armkeyvault.VaultPatchProperties{ - AccessPolicies: []*armkeyvault.AccessPolicyEntry{ - { - ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"), - Permissions: &armkeyvault.Permissions{ - Certificates: []*armkeyvault.CertificatePermissions{ - to.Ptr(armkeyvault.CertificatePermissionsGet), - to.Ptr(armkeyvault.CertificatePermissionsList), - to.Ptr(armkeyvault.CertificatePermissionsDelete), - to.Ptr(armkeyvault.CertificatePermissionsCreate), - to.Ptr(armkeyvault.CertificatePermissionsImport), - to.Ptr(armkeyvault.CertificatePermissionsUpdate), - to.Ptr(armkeyvault.CertificatePermissionsManagecontacts), - to.Ptr(armkeyvault.CertificatePermissionsGetissuers), - to.Ptr(armkeyvault.CertificatePermissionsListissuers), - to.Ptr(armkeyvault.CertificatePermissionsSetissuers), - to.Ptr(armkeyvault.CertificatePermissionsDeleteissuers), - to.Ptr(armkeyvault.CertificatePermissionsManageissuers), - to.Ptr(armkeyvault.CertificatePermissionsRecover), - to.Ptr(armkeyvault.CertificatePermissionsPurge)}, - Keys: []*armkeyvault.KeyPermissions{ - to.Ptr(armkeyvault.KeyPermissionsEncrypt), - to.Ptr(armkeyvault.KeyPermissionsDecrypt), - to.Ptr(armkeyvault.KeyPermissionsWrapKey), - to.Ptr(armkeyvault.KeyPermissionsUnwrapKey), - to.Ptr(armkeyvault.KeyPermissionsSign), - to.Ptr(armkeyvault.KeyPermissionsVerify), - to.Ptr(armkeyvault.KeyPermissionsGet), - to.Ptr(armkeyvault.KeyPermissionsList), - to.Ptr(armkeyvault.KeyPermissionsCreate), - to.Ptr(armkeyvault.KeyPermissionsUpdate), - to.Ptr(armkeyvault.KeyPermissionsImport), - to.Ptr(armkeyvault.KeyPermissionsDelete), - to.Ptr(armkeyvault.KeyPermissionsBackup), - to.Ptr(armkeyvault.KeyPermissionsRestore), - to.Ptr(armkeyvault.KeyPermissionsRecover), - to.Ptr(armkeyvault.KeyPermissionsPurge)}, - Secrets: []*armkeyvault.SecretPermissions{ - to.Ptr(armkeyvault.SecretPermissionsGet), - to.Ptr(armkeyvault.SecretPermissionsList), - to.Ptr(armkeyvault.SecretPermissionsSet), - to.Ptr(armkeyvault.SecretPermissionsDelete), - to.Ptr(armkeyvault.SecretPermissionsBackup), - to.Ptr(armkeyvault.SecretPermissionsRestore), - to.Ptr(armkeyvault.SecretPermissionsRecover), - to.Ptr(armkeyvault.SecretPermissionsPurge)}, - }, - TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - }}, - EnabledForDeployment: to.Ptr(true), - EnabledForDiskEncryption: to.Ptr(true), - EnabledForTemplateDeployment: to.Ptr(true), - PublicNetworkAccess: to.Ptr("Enabled"), - SKU: &armkeyvault.SKU{ - Name: to.Ptr(armkeyvault.SKUNameStandard), - Family: to.Ptr(armkeyvault.SKUFamilyA), - }, - TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - }, - }, 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.Vault = armkeyvault.Vault{ - // Name: to.Ptr("sample-vault"), - // Type: to.Ptr("Microsoft.KeyVault/vaults"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-resource-group/providers/Microsoft.KeyVault/vaults/sample-vault"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.VaultProperties{ - // AccessPolicies: []*armkeyvault.AccessPolicyEntry{ - // { - // ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // Permissions: &armkeyvault.Permissions{ - // Certificates: []*armkeyvault.CertificatePermissions{ - // to.Ptr(armkeyvault.CertificatePermissionsGet), - // to.Ptr(armkeyvault.CertificatePermissionsList), - // to.Ptr(armkeyvault.CertificatePermissionsDelete), - // to.Ptr(armkeyvault.CertificatePermissionsCreate), - // to.Ptr(armkeyvault.CertificatePermissionsImport), - // to.Ptr(armkeyvault.CertificatePermissionsUpdate), - // to.Ptr(armkeyvault.CertificatePermissionsManagecontacts), - // to.Ptr(armkeyvault.CertificatePermissionsGetissuers), - // to.Ptr(armkeyvault.CertificatePermissionsListissuers), - // to.Ptr(armkeyvault.CertificatePermissionsSetissuers), - // to.Ptr(armkeyvault.CertificatePermissionsDeleteissuers), - // to.Ptr(armkeyvault.CertificatePermissionsManageissuers), - // to.Ptr(armkeyvault.CertificatePermissionsRecover), - // to.Ptr(armkeyvault.CertificatePermissionsPurge)}, - // Keys: []*armkeyvault.KeyPermissions{ - // to.Ptr(armkeyvault.KeyPermissionsEncrypt), - // to.Ptr(armkeyvault.KeyPermissionsDecrypt), - // to.Ptr(armkeyvault.KeyPermissionsWrapKey), - // to.Ptr(armkeyvault.KeyPermissionsUnwrapKey), - // to.Ptr(armkeyvault.KeyPermissionsSign), - // to.Ptr(armkeyvault.KeyPermissionsVerify), - // to.Ptr(armkeyvault.KeyPermissionsGet), - // to.Ptr(armkeyvault.KeyPermissionsList), - // to.Ptr(armkeyvault.KeyPermissionsCreate), - // to.Ptr(armkeyvault.KeyPermissionsUpdate), - // to.Ptr(armkeyvault.KeyPermissionsImport), - // to.Ptr(armkeyvault.KeyPermissionsDelete), - // to.Ptr(armkeyvault.KeyPermissionsBackup), - // to.Ptr(armkeyvault.KeyPermissionsRestore), - // to.Ptr(armkeyvault.KeyPermissionsRecover), - // to.Ptr(armkeyvault.KeyPermissionsPurge)}, - // Secrets: []*armkeyvault.SecretPermissions{ - // to.Ptr(armkeyvault.SecretPermissionsGet), - // to.Ptr(armkeyvault.SecretPermissionsList), - // to.Ptr(armkeyvault.SecretPermissionsSet), - // to.Ptr(armkeyvault.SecretPermissionsDelete), - // to.Ptr(armkeyvault.SecretPermissionsBackup), - // to.Ptr(armkeyvault.SecretPermissionsRestore), - // to.Ptr(armkeyvault.SecretPermissionsRecover), - // to.Ptr(armkeyvault.SecretPermissionsPurge)}, - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }}, - // EnabledForDeployment: to.Ptr(true), - // EnabledForDiskEncryption: to.Ptr(true), - // EnabledForTemplateDeployment: to.Ptr(true), - // HsmPoolResourceID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // NetworkACLs: &armkeyvault.NetworkRuleSet{ - // Bypass: to.Ptr(armkeyvault.NetworkRuleBypassOptionsAzureServices), - // DefaultAction: to.Ptr(armkeyvault.NetworkRuleActionDeny), - // IPRules: []*armkeyvault.IPRule{ - // { - // Value: to.Ptr(""), - // }}, - // VirtualNetworkRules: []*armkeyvault.VirtualNetworkRule{ - // { - // ID: to.Ptr(""), - // IgnoreMissingVnetServiceEndpoint: to.Ptr(false), - // }}, - // }, - // PrivateEndpointConnections: []*armkeyvault.PrivateEndpointConnectionItem{ - // { - // ID: to.Ptr(""), - // Properties: &armkeyvault.PrivateEndpointConnectionProperties{ - // PrivateEndpoint: &armkeyvault.PrivateEndpoint{ - // ID: to.Ptr(""), - // }, - // PrivateLinkServiceConnectionState: &armkeyvault.PrivateLinkServiceConnectionState{ - // ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone), - // Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved), - // }, - // ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded), - // }, - // }}, - // ProvisioningState: to.Ptr(armkeyvault.VaultProvisioningStateSucceeded), - // PublicNetworkAccess: to.Ptr("Enabled"), - // SKU: &armkeyvault.SKU{ - // Name: to.Ptr(armkeyvault.SKUNameStandard), - // Family: to.Ptr(armkeyvault.SKUFamilyA), - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // VaultURI: to.Ptr("https://sample-vault.vault.azure.net"), - // }, - // SystemData: &armkeyvault.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // CreatedBy: to.Ptr("keyVaultUser1"), - // CreatedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // LastModifiedBy: to.Ptr("keyVaultUser2"), - // LastModifiedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // }, - // Tags: map[string]*string{ - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/deleteVault.json -func ExampleVaultsClient_Delete() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - _, err = clientFactory.NewVaultsClient().Delete(ctx, "sample-resource-group", "sample-vault", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/getVault.json -func ExampleVaultsClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewVaultsClient().Get(ctx, "sample-resource-group", "sample-vault", 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.Vault = armkeyvault.Vault{ - // Name: to.Ptr("sample-vault"), - // Type: to.Ptr("Microsoft.KeyVault/vaults"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-resource-group/providers/Microsoft.KeyVault/vaults/sample-vault"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.VaultProperties{ - // AccessPolicies: []*armkeyvault.AccessPolicyEntry{ - // { - // ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // Permissions: &armkeyvault.Permissions{ - // Certificates: []*armkeyvault.CertificatePermissions{ - // to.Ptr(armkeyvault.CertificatePermissionsGet), - // to.Ptr(armkeyvault.CertificatePermissionsList), - // to.Ptr(armkeyvault.CertificatePermissionsDelete), - // to.Ptr(armkeyvault.CertificatePermissionsCreate), - // to.Ptr(armkeyvault.CertificatePermissionsImport), - // to.Ptr(armkeyvault.CertificatePermissionsUpdate), - // to.Ptr(armkeyvault.CertificatePermissionsManagecontacts), - // to.Ptr(armkeyvault.CertificatePermissionsGetissuers), - // to.Ptr(armkeyvault.CertificatePermissionsListissuers), - // to.Ptr(armkeyvault.CertificatePermissionsSetissuers), - // to.Ptr(armkeyvault.CertificatePermissionsDeleteissuers), - // to.Ptr(armkeyvault.CertificatePermissionsManageissuers), - // to.Ptr(armkeyvault.CertificatePermissionsRecover), - // to.Ptr(armkeyvault.CertificatePermissionsPurge)}, - // Keys: []*armkeyvault.KeyPermissions{ - // to.Ptr(armkeyvault.KeyPermissionsEncrypt), - // to.Ptr(armkeyvault.KeyPermissionsDecrypt), - // to.Ptr(armkeyvault.KeyPermissionsWrapKey), - // to.Ptr(armkeyvault.KeyPermissionsUnwrapKey), - // to.Ptr(armkeyvault.KeyPermissionsSign), - // to.Ptr(armkeyvault.KeyPermissionsVerify), - // to.Ptr(armkeyvault.KeyPermissionsGet), - // to.Ptr(armkeyvault.KeyPermissionsList), - // to.Ptr(armkeyvault.KeyPermissionsCreate), - // to.Ptr(armkeyvault.KeyPermissionsUpdate), - // to.Ptr(armkeyvault.KeyPermissionsImport), - // to.Ptr(armkeyvault.KeyPermissionsDelete), - // to.Ptr(armkeyvault.KeyPermissionsBackup), - // to.Ptr(armkeyvault.KeyPermissionsRestore), - // to.Ptr(armkeyvault.KeyPermissionsRecover), - // to.Ptr(armkeyvault.KeyPermissionsPurge)}, - // Secrets: []*armkeyvault.SecretPermissions{ - // to.Ptr(armkeyvault.SecretPermissionsGet), - // to.Ptr(armkeyvault.SecretPermissionsList), - // to.Ptr(armkeyvault.SecretPermissionsSet), - // to.Ptr(armkeyvault.SecretPermissionsDelete), - // to.Ptr(armkeyvault.SecretPermissionsBackup), - // to.Ptr(armkeyvault.SecretPermissionsRestore), - // to.Ptr(armkeyvault.SecretPermissionsRecover), - // to.Ptr(armkeyvault.SecretPermissionsPurge)}, - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }}, - // EnabledForDeployment: to.Ptr(true), - // EnabledForDiskEncryption: to.Ptr(true), - // EnabledForTemplateDeployment: to.Ptr(true), - // HsmPoolResourceID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // ProvisioningState: to.Ptr(armkeyvault.VaultProvisioningStateSucceeded), - // PublicNetworkAccess: to.Ptr("Enabled"), - // SKU: &armkeyvault.SKU{ - // Name: to.Ptr(armkeyvault.SKUNameStandard), - // Family: to.Ptr(armkeyvault.SKUFamilyA), - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // VaultURI: to.Ptr("https://sample-vault.vault.azure.net"), - // }, - // SystemData: &armkeyvault.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // CreatedBy: to.Ptr("keyVaultUser1"), - // CreatedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // LastModifiedBy: to.Ptr("keyVaultUser2"), - // LastModifiedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // }, - // Tags: map[string]*string{ - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/updateAccessPoliciesAdd.json -func ExampleVaultsClient_UpdateAccessPolicy() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewVaultsClient().UpdateAccessPolicy(ctx, "sample-group", "sample-vault", armkeyvault.AccessPolicyUpdateKindAdd, armkeyvault.VaultAccessPolicyParameters{ - Properties: &armkeyvault.VaultAccessPolicyProperties{ - AccessPolicies: []*armkeyvault.AccessPolicyEntry{ - { - ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"), - Permissions: &armkeyvault.Permissions{ - Certificates: []*armkeyvault.CertificatePermissions{ - to.Ptr(armkeyvault.CertificatePermissionsGet)}, - Keys: []*armkeyvault.KeyPermissions{ - to.Ptr(armkeyvault.KeyPermissionsEncrypt)}, - Secrets: []*armkeyvault.SecretPermissions{ - to.Ptr(armkeyvault.SecretPermissionsGet)}, - }, - TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - }}, - }, - }, 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.VaultAccessPolicyParameters = armkeyvault.VaultAccessPolicyParameters{ - // Type: to.Ptr("Microsoft.KeyVault/vaults/accessPolicies"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/accessPolicies/"), - // Properties: &armkeyvault.VaultAccessPolicyProperties{ - // AccessPolicies: []*armkeyvault.AccessPolicyEntry{ - // { - // ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // Permissions: &armkeyvault.Permissions{ - // Certificates: []*armkeyvault.CertificatePermissions{ - // to.Ptr(armkeyvault.CertificatePermissionsGet)}, - // Keys: []*armkeyvault.KeyPermissions{ - // to.Ptr(armkeyvault.KeyPermissionsEncrypt)}, - // Secrets: []*armkeyvault.SecretPermissions{ - // to.Ptr(armkeyvault.SecretPermissionsGet)}, - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }}, - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/listVaultByResourceGroup.json -func ExampleVaultsClient_NewListByResourceGroupPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewVaultsClient().NewListByResourceGroupPager("sample-group", &armkeyvault.VaultsClientListByResourceGroupOptions{Top: to.Ptr[int32](1)}) - 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.VaultListResult = armkeyvault.VaultListResult{ - // Value: []*armkeyvault.Vault{ - // { - // Name: to.Ptr("sample-vault"), - // Type: to.Ptr("Microsoft.KeyVault/vaults"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.VaultProperties{ - // AccessPolicies: []*armkeyvault.AccessPolicyEntry{ - // { - // ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // Permissions: &armkeyvault.Permissions{ - // Certificates: []*armkeyvault.CertificatePermissions{ - // to.Ptr(armkeyvault.CertificatePermissionsGet), - // to.Ptr(armkeyvault.CertificatePermissionsList), - // to.Ptr(armkeyvault.CertificatePermissionsDelete), - // to.Ptr(armkeyvault.CertificatePermissionsCreate), - // to.Ptr(armkeyvault.CertificatePermissionsImport), - // to.Ptr(armkeyvault.CertificatePermissionsUpdate), - // to.Ptr(armkeyvault.CertificatePermissionsManagecontacts), - // to.Ptr(armkeyvault.CertificatePermissionsGetissuers), - // to.Ptr(armkeyvault.CertificatePermissionsListissuers), - // to.Ptr(armkeyvault.CertificatePermissionsSetissuers), - // to.Ptr(armkeyvault.CertificatePermissionsDeleteissuers), - // to.Ptr(armkeyvault.CertificatePermissionsManageissuers), - // to.Ptr(armkeyvault.CertificatePermissionsRecover), - // to.Ptr(armkeyvault.CertificatePermissionsPurge)}, - // Keys: []*armkeyvault.KeyPermissions{ - // to.Ptr(armkeyvault.KeyPermissionsEncrypt), - // to.Ptr(armkeyvault.KeyPermissionsDecrypt), - // to.Ptr(armkeyvault.KeyPermissionsWrapKey), - // to.Ptr(armkeyvault.KeyPermissionsUnwrapKey), - // to.Ptr(armkeyvault.KeyPermissionsSign), - // to.Ptr(armkeyvault.KeyPermissionsVerify), - // to.Ptr(armkeyvault.KeyPermissionsGet), - // to.Ptr(armkeyvault.KeyPermissionsList), - // to.Ptr(armkeyvault.KeyPermissionsCreate), - // to.Ptr(armkeyvault.KeyPermissionsUpdate), - // to.Ptr(armkeyvault.KeyPermissionsImport), - // to.Ptr(armkeyvault.KeyPermissionsDelete), - // to.Ptr(armkeyvault.KeyPermissionsBackup), - // to.Ptr(armkeyvault.KeyPermissionsRestore), - // to.Ptr(armkeyvault.KeyPermissionsRecover), - // to.Ptr(armkeyvault.KeyPermissionsPurge)}, - // Secrets: []*armkeyvault.SecretPermissions{ - // to.Ptr(armkeyvault.SecretPermissionsGet), - // to.Ptr(armkeyvault.SecretPermissionsList), - // to.Ptr(armkeyvault.SecretPermissionsSet), - // to.Ptr(armkeyvault.SecretPermissionsDelete), - // to.Ptr(armkeyvault.SecretPermissionsBackup), - // to.Ptr(armkeyvault.SecretPermissionsRestore), - // to.Ptr(armkeyvault.SecretPermissionsRecover), - // to.Ptr(armkeyvault.SecretPermissionsPurge)}, - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }}, - // EnableSoftDelete: to.Ptr(true), - // EnabledForDeployment: to.Ptr(true), - // EnabledForDiskEncryption: to.Ptr(true), - // EnabledForTemplateDeployment: to.Ptr(true), - // HsmPoolResourceID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // ProvisioningState: to.Ptr(armkeyvault.VaultProvisioningStateSucceeded), - // SKU: &armkeyvault.SKU{ - // Name: to.Ptr(armkeyvault.SKUNamePremium), - // Family: to.Ptr(armkeyvault.SKUFamilyA), - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // VaultURI: to.Ptr("https://sample-vault.vault.azure.net/"), - // }, - // SystemData: &armkeyvault.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // CreatedBy: to.Ptr("keyVaultUser1"), - // CreatedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // LastModifiedBy: to.Ptr("keyVaultUser2"), - // LastModifiedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // }, - // Tags: map[string]*string{ - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/listVaultBySubscription.json -func ExampleVaultsClient_NewListBySubscriptionPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewVaultsClient().NewListBySubscriptionPager(&armkeyvault.VaultsClientListBySubscriptionOptions{Top: to.Ptr[int32](1)}) - 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.VaultListResult = armkeyvault.VaultListResult{ - // Value: []*armkeyvault.Vault{ - // { - // Name: to.Ptr("sample-vault"), - // Type: to.Ptr("Microsoft.KeyVault/vaults"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault"), - // Location: to.Ptr("westus"), - // Properties: &armkeyvault.VaultProperties{ - // AccessPolicies: []*armkeyvault.AccessPolicyEntry{ - // { - // ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // Permissions: &armkeyvault.Permissions{ - // Certificates: []*armkeyvault.CertificatePermissions{ - // to.Ptr(armkeyvault.CertificatePermissionsGet), - // to.Ptr(armkeyvault.CertificatePermissionsList), - // to.Ptr(armkeyvault.CertificatePermissionsDelete), - // to.Ptr(armkeyvault.CertificatePermissionsCreate), - // to.Ptr(armkeyvault.CertificatePermissionsImport), - // to.Ptr(armkeyvault.CertificatePermissionsUpdate), - // to.Ptr(armkeyvault.CertificatePermissionsManagecontacts), - // to.Ptr(armkeyvault.CertificatePermissionsGetissuers), - // to.Ptr(armkeyvault.CertificatePermissionsListissuers), - // to.Ptr(armkeyvault.CertificatePermissionsSetissuers), - // to.Ptr(armkeyvault.CertificatePermissionsDeleteissuers), - // to.Ptr(armkeyvault.CertificatePermissionsManageissuers), - // to.Ptr(armkeyvault.CertificatePermissionsRecover), - // to.Ptr(armkeyvault.CertificatePermissionsPurge)}, - // Keys: []*armkeyvault.KeyPermissions{ - // to.Ptr(armkeyvault.KeyPermissionsEncrypt), - // to.Ptr(armkeyvault.KeyPermissionsDecrypt), - // to.Ptr(armkeyvault.KeyPermissionsWrapKey), - // to.Ptr(armkeyvault.KeyPermissionsUnwrapKey), - // to.Ptr(armkeyvault.KeyPermissionsSign), - // to.Ptr(armkeyvault.KeyPermissionsVerify), - // to.Ptr(armkeyvault.KeyPermissionsGet), - // to.Ptr(armkeyvault.KeyPermissionsList), - // to.Ptr(armkeyvault.KeyPermissionsCreate), - // to.Ptr(armkeyvault.KeyPermissionsUpdate), - // to.Ptr(armkeyvault.KeyPermissionsImport), - // to.Ptr(armkeyvault.KeyPermissionsDelete), - // to.Ptr(armkeyvault.KeyPermissionsBackup), - // to.Ptr(armkeyvault.KeyPermissionsRestore), - // to.Ptr(armkeyvault.KeyPermissionsRecover), - // to.Ptr(armkeyvault.KeyPermissionsPurge)}, - // Secrets: []*armkeyvault.SecretPermissions{ - // to.Ptr(armkeyvault.SecretPermissionsGet), - // to.Ptr(armkeyvault.SecretPermissionsList), - // to.Ptr(armkeyvault.SecretPermissionsSet), - // to.Ptr(armkeyvault.SecretPermissionsDelete), - // to.Ptr(armkeyvault.SecretPermissionsBackup), - // to.Ptr(armkeyvault.SecretPermissionsRestore), - // to.Ptr(armkeyvault.SecretPermissionsRecover), - // to.Ptr(armkeyvault.SecretPermissionsPurge)}, - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // }}, - // EnableSoftDelete: to.Ptr(true), - // EnabledForDeployment: to.Ptr(true), - // EnabledForDiskEncryption: to.Ptr(true), - // EnabledForTemplateDeployment: to.Ptr(true), - // HsmPoolResourceID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // ProvisioningState: to.Ptr(armkeyvault.VaultProvisioningStateSucceeded), - // SKU: &armkeyvault.SKU{ - // Name: to.Ptr(armkeyvault.SKUNamePremium), - // Family: to.Ptr(armkeyvault.SKUFamilyA), - // }, - // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), - // VaultURI: to.Ptr("https://sample-vault.vault.azure.net/"), - // }, - // SystemData: &armkeyvault.SystemData{ - // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // CreatedBy: to.Ptr("keyVaultUser1"), - // CreatedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.0000000Z"); return t}()), - // LastModifiedBy: to.Ptr("keyVaultUser2"), - // LastModifiedByType: to.Ptr(armkeyvault.IdentityTypeUser), - // }, - // Tags: map[string]*string{ - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/listDeletedVaults.json -func ExampleVaultsClient_NewListDeletedPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewVaultsClient().NewListDeletedPager(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.DeletedVaultListResult = armkeyvault.DeletedVaultListResult{ - // Value: []*armkeyvault.DeletedVault{ - // { - // Name: to.Ptr("vault-agile-drawer-6404"), - // Type: to.Ptr("Microsoft.KeyVault/deletedVaults"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.KeyVault/locations/westus/deletedVaults/sample-vault"), - // Properties: &armkeyvault.DeletedVaultProperties{ - // DeletionDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-01-01T00:00:59Z"); return t}()), - // Location: to.Ptr("westus"), - // PurgeProtectionEnabled: to.Ptr(true), - // ScheduledPurgeDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-01T00:00:59Z"); return t}()), - // Tags: map[string]*string{ - // }, - // VaultID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault"), - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/getDeletedVault.json -func ExampleVaultsClient_GetDeleted() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewVaultsClient().GetDeleted(ctx, "sample-vault", "westus", 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.DeletedVault = armkeyvault.DeletedVault{ - // Name: to.Ptr("sample-vault"), - // Type: to.Ptr("Microsoft.KeyVault/deletedVaults"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.KeyVault/locations/westus/deletedVaults/sample-vault"), - // Properties: &armkeyvault.DeletedVaultProperties{ - // DeletionDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-01-01T00:00:59Z"); return t}()), - // Location: to.Ptr("westus"), - // PurgeProtectionEnabled: to.Ptr(true), - // ScheduledPurgeDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-01T00:00:59Z"); return t}()), - // Tags: map[string]*string{ - // }, - // VaultID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault"), - // }, - // } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/purgeDeletedVault.json -func ExampleVaultsClient_BeginPurgeDeleted() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := clientFactory.NewVaultsClient().BeginPurgeDeleted(ctx, "sample-vault", "westus", nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - _, err = poller.PollUntilDone(ctx, nil) - if err != nil { - log.Fatalf("failed to pull the result: %v", err) - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/listVault.json -func ExampleVaultsClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := clientFactory.NewVaultsClient().NewListPager(&armkeyvault.VaultsClientListOptions{Top: to.Ptr[int32](1)}) - 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.ResourceListResult = armkeyvault.ResourceListResult{ - // Value: []*armkeyvault.Resource{ - // { - // Name: to.Ptr("sample-vault"), - // Type: to.Ptr("Microsoft.KeyVault/vaults"), - // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault"), - // Location: to.Ptr("westus"), - // Tags: map[string]*string{ - // }, - // }}, - // } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/2f2b633d940230cbbd5bcf1339a2e1c48674e4a2/specification/keyvault/resource-manager/Microsoft.KeyVault/preview/2021-11-01-preview/examples/checkVaultNameAvailability.json -func ExampleVaultsClient_CheckNameAvailability() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - clientFactory, err := armkeyvault.NewClientFactory("", cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := clientFactory.NewVaultsClient().CheckNameAvailability(ctx, armkeyvault.VaultCheckNameAvailabilityParameters{ - Name: to.Ptr("sample-vault"), - Type: to.Ptr("Microsoft.KeyVault/vaults"), - }, 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.CheckNameAvailabilityResult = armkeyvault.CheckNameAvailabilityResult{ - // NameAvailable: to.Ptr(true), - // } -}