From c9941debabed2d7e0cc890e8f19b7e3e42818583 Mon Sep 17 00:00:00 2001 From: SDKAuto Date: Thu, 11 Aug 2022 02:15:42 +0000 Subject: [PATCH] CodeGen from PR 20130 in Azure/azure-rest-api-specs Merge fd3740520302f8432b55a6b6727082bdafc31607 into 80065490402157d0df0dd37ab347c651b22eb576 --- .../reservations/armreservations/CHANGELOG.md | 4 + .../reservations/armreservations/autorest.md | 6 +- ...lient.go => azurereservationapi_client.go} | 1 + ..._client.go => calculateexchange_client.go} | 1 + ...zz_generated_constants.go => constants.go} | 3 +- ...zz_generated_date_type.go => date_type.go} | 1 + ..._exchange_client.go => exchange_client.go} | 1 + .../reservations/armreservations/go.mod | 14 +- .../reservations/armreservations/go.sum | 24 +- .../{zz_generated_models.go => models.go} | 1 + .../armreservations/models_serde.go | 3499 +++++++++++++++++ ...peration_client.go => operation_client.go} | 1 + ...erated_quota_client.go => quota_client.go} | 1 + ...client.go => quotarequeststatus_client.go} | 1 + ...vation_client.go => reservation_client.go} | 1 + ...r_client.go => reservationorder_client.go} | 1 + ...ed_response_types.go => response_types.go} | 1 + ...erated_time_rfc3339.go => time_rfc3339.go} | 1 + ...example_azurereservationapi_client_test.go | 65 - ...d_example_calculateexchange_client_test.go | 71 - ..._generated_example_exchange_client_test.go | 47 - ...generated_example_operation_client_test.go | 41 - .../ze_generated_example_quota_client_test.go | 143 - ..._example_quotarequeststatus_client_test.go | 71 - ...nerated_example_reservation_client_test.go | 250 -- ...ed_example_reservationorder_client_test.go | 169 - .../zz_generated_models_serde.go | 428 -- 27 files changed, 3526 insertions(+), 1321 deletions(-) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_azurereservationapi_client.go => azurereservationapi_client.go} (99%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_calculateexchange_client.go => calculateexchange_client.go} (99%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_constants.go => constants.go} (99%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_date_type.go => date_type.go} (98%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_exchange_client.go => exchange_client.go} (99%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_models.go => models.go} (99%) create mode 100644 sdk/resourcemanager/reservations/armreservations/models_serde.go rename sdk/resourcemanager/reservations/armreservations/{zz_generated_operation_client.go => operation_client.go} (99%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_quota_client.go => quota_client.go} (99%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_quotarequeststatus_client.go => quotarequeststatus_client.go} (99%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_reservation_client.go => reservation_client.go} (99%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_reservationorder_client.go => reservationorder_client.go} (99%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_response_types.go => response_types.go} (99%) rename sdk/resourcemanager/reservations/armreservations/{zz_generated_time_rfc3339.go => time_rfc3339.go} (99%) delete mode 100644 sdk/resourcemanager/reservations/armreservations/ze_generated_example_azurereservationapi_client_test.go delete mode 100644 sdk/resourcemanager/reservations/armreservations/ze_generated_example_calculateexchange_client_test.go delete mode 100644 sdk/resourcemanager/reservations/armreservations/ze_generated_example_exchange_client_test.go delete mode 100644 sdk/resourcemanager/reservations/armreservations/ze_generated_example_operation_client_test.go delete mode 100644 sdk/resourcemanager/reservations/armreservations/ze_generated_example_quota_client_test.go delete mode 100644 sdk/resourcemanager/reservations/armreservations/ze_generated_example_quotarequeststatus_client_test.go delete mode 100644 sdk/resourcemanager/reservations/armreservations/ze_generated_example_reservation_client_test.go delete mode 100644 sdk/resourcemanager/reservations/armreservations/ze_generated_example_reservationorder_client_test.go delete mode 100644 sdk/resourcemanager/reservations/armreservations/zz_generated_models_serde.go diff --git a/sdk/resourcemanager/reservations/armreservations/CHANGELOG.md b/sdk/resourcemanager/reservations/armreservations/CHANGELOG.md index c47ad513fc59..ebd7800248fa 100644 --- a/sdk/resourcemanager/reservations/armreservations/CHANGELOG.md +++ b/sdk/resourcemanager/reservations/armreservations/CHANGELOG.md @@ -1,5 +1,9 @@ # Release History +## 1.0.1 (2022-08-11) +### Other Changes + + ## 1.0.0 (2022-05-18) The package of `github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/reservations/armreservations` is using our [next generation design principles](https://azure.github.io/azure-sdk/general_introduction.html) since version 1.0.0, which contains breaking changes. diff --git a/sdk/resourcemanager/reservations/armreservations/autorest.md b/sdk/resourcemanager/reservations/armreservations/autorest.md index c4dfd5bfa804..6c719733b86e 100644 --- a/sdk/resourcemanager/reservations/armreservations/autorest.md +++ b/sdk/resourcemanager/reservations/armreservations/autorest.md @@ -5,9 +5,9 @@ ``` yaml azure-arm: true require: -- https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/reservations/resource-manager/readme.md -- https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/reservations/resource-manager/readme.go.md +- /mnt/vss/_work/1/s/azure-rest-api-specs/specification/reservations/resource-manager/readme.md +- /mnt/vss/_work/1/s/azure-rest-api-specs/specification/reservations/resource-manager/readme.go.md license-header: MICROSOFT_MIT_NO_VERSION -module-version: 1.0.0 +module-version: 1.0.1 ``` \ No newline at end of file diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_azurereservationapi_client.go b/sdk/resourcemanager/reservations/armreservations/azurereservationapi_client.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_azurereservationapi_client.go rename to sdk/resourcemanager/reservations/armreservations/azurereservationapi_client.go index 6da6bed59ee1..3f2e6950939e 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_azurereservationapi_client.go +++ b/sdk/resourcemanager/reservations/armreservations/azurereservationapi_client.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_calculateexchange_client.go b/sdk/resourcemanager/reservations/armreservations/calculateexchange_client.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_calculateexchange_client.go rename to sdk/resourcemanager/reservations/armreservations/calculateexchange_client.go index 625bd89681ec..8bc2907980a0 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_calculateexchange_client.go +++ b/sdk/resourcemanager/reservations/armreservations/calculateexchange_client.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_constants.go b/sdk/resourcemanager/reservations/armreservations/constants.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_constants.go rename to sdk/resourcemanager/reservations/armreservations/constants.go index 7b93946e5087..bf19d060fde9 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_constants.go +++ b/sdk/resourcemanager/reservations/armreservations/constants.go @@ -5,12 +5,13 @@ // 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 armreservations const ( moduleName = "armreservations" - moduleVersion = "v1.0.0" + moduleVersion = "v1.0.1" ) // AppliedScopeType - Type of the Applied Scope. diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_date_type.go b/sdk/resourcemanager/reservations/armreservations/date_type.go similarity index 98% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_date_type.go rename to sdk/resourcemanager/reservations/armreservations/date_type.go index 89af3164c022..eb58bfe3d9e0 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_date_type.go +++ b/sdk/resourcemanager/reservations/armreservations/date_type.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_exchange_client.go b/sdk/resourcemanager/reservations/armreservations/exchange_client.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_exchange_client.go rename to sdk/resourcemanager/reservations/armreservations/exchange_client.go index fc3884140b66..cd1b8890cd3d 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_exchange_client.go +++ b/sdk/resourcemanager/reservations/armreservations/exchange_client.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/go.mod b/sdk/resourcemanager/reservations/armreservations/go.mod index b6aba293d704..a40734cab130 100644 --- a/sdk/resourcemanager/reservations/armreservations/go.mod +++ b/sdk/resourcemanager/reservations/armreservations/go.mod @@ -2,20 +2,12 @@ module github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/reservations/armres go 1.18 -require ( - github.com/Azure/azure-sdk-for-go/sdk/azcore v1.0.0 - github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.0.0 -) +require github.com/Azure/azure-sdk-for-go/sdk/azcore v1.0.0 require ( github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0 // indirect - github.com/AzureAD/microsoft-authentication-library-for-go v0.4.0 // indirect - github.com/golang-jwt/jwt v3.2.1+incompatible // indirect - github.com/google/uuid v1.1.1 // indirect - github.com/kylelemons/godebug v1.1.0 // indirect - github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4 // indirect - golang.org/x/crypto v0.0.0-20220511200225-c6db032c6c88 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4 // indirect - golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e // indirect golang.org/x/text v0.3.7 // indirect + gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect ) diff --git a/sdk/resourcemanager/reservations/armreservations/go.sum b/sdk/resourcemanager/reservations/armreservations/go.sum index ed5b814680ee..3afb578030a5 100644 --- a/sdk/resourcemanager/reservations/armreservations/go.sum +++ b/sdk/resourcemanager/reservations/armreservations/go.sum @@ -1,33 +1,15 @@ github.com/Azure/azure-sdk-for-go/sdk/azcore v1.0.0 h1:sVPhtT2qjO86rTUaWMr4WoES4TkjGnzcioXcnHV9s5k= github.com/Azure/azure-sdk-for-go/sdk/azcore v1.0.0/go.mod h1:uGG2W01BaETf0Ozp+QxxKJdMBNRWPdstHG0Fmdwn1/U= -github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.0.0 h1:Yoicul8bnVdQrhDMTHxdEckRGX01XvwXDHUT9zYZ3k0= -github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.0.0/go.mod h1:+6sju8gk8FRmSajX3Oz4G5Gm7P+mbqE9FVaXXFYTkCM= github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0 h1:jp0dGvZ7ZK0mgqnTSClMxa5xuRL7NZgHameVYF6BurY= github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0/go.mod h1:eWRD7oawr1Mu1sLCawqVc0CUiF43ia3qQMxLscsKQ9w= -github.com/AzureAD/microsoft-authentication-library-for-go v0.4.0 h1:WVsrXCnHlDDX8ls+tootqRE87/hL9S/g4ewig9RsD/c= -github.com/AzureAD/microsoft-authentication-library-for-go v0.4.0/go.mod h1:Vt9sXTKwMyGcOxSmLDMnGPgqsUg7m8pe215qMLrDXw4= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/dnaeon/go-vcr v1.1.0 h1:ReYa/UBrRyQdant9B4fNHGoCNKw6qh6P0fsdGmZpR7c= -github.com/golang-jwt/jwt v3.2.1+incompatible h1:73Z+4BJcrTC+KczS6WvTPvRGOp1WmfEP4Q1lOd9Z/+c= -github.com/golang-jwt/jwt v3.2.1+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= -github.com/golang-jwt/jwt/v4 v4.2.0 h1:besgBTC8w8HjP6NzQdxwKH9Z5oQMZ24ThTrHp3cZ8eU= -github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY= -github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/montanaflynn/stats v0.6.6/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow= -github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4 h1:Qj1ukM4GlMWXNdMBuXcXfz/Kw9s1qm0CLY32QxuSImI= -github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4/go.mod h1:N6UoU20jOqggOuDwUaBQpluzLNDqif3kq9z2wpdYEfQ= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= -golang.org/x/crypto v0.0.0-20220511200225-c6db032c6c88 h1:Tgea0cVUD0ivh5ADBX4WwuI12DUd2to3nCYe2eayMIw= -golang.org/x/crypto v0.0.0-20220511200225-c6db032c6c88/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4 h1:HVyaeDAYux4pnY+D/SiwmLOR36ewZ4iGQIIrtnuCjFA= golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= -golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM= -golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_models.go b/sdk/resourcemanager/reservations/armreservations/models.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_models.go rename to sdk/resourcemanager/reservations/armreservations/models.go index 0766c18d2a30..4bda21656803 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_models.go +++ b/sdk/resourcemanager/reservations/armreservations/models.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/models_serde.go b/sdk/resourcemanager/reservations/armreservations/models_serde.go new file mode 100644 index 000000000000..501b81f76b10 --- /dev/null +++ b/sdk/resourcemanager/reservations/armreservations/models_serde.go @@ -0,0 +1,3499 @@ +//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 armreservations + +import ( + "encoding/json" + "fmt" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "reflect" +) + +// MarshalJSON implements the json.Marshaller interface for type AppliedReservationList. +func (a AppliedReservationList) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "nextLink", a.NextLink) + populate(objectMap, "value", a.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppliedReservationList. +func (a *AppliedReservationList) 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", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &a.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &a.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AppliedReservations. +func (a AppliedReservations) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "id", a.ID) + populate(objectMap, "name", a.Name) + populate(objectMap, "properties", a.Properties) + populate(objectMap, "type", a.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppliedReservations. +func (a *AppliedReservations) 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", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &a.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &a.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &a.Properties) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &a.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AppliedReservationsProperties. +func (a AppliedReservationsProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "reservationOrderIds", a.ReservationOrderIDs) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppliedReservationsProperties. +func (a *AppliedReservationsProperties) 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", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "reservationOrderIds": + err = unpopulate(val, "ReservationOrderIDs", &a.ReservationOrderIDs) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AvailableScopeProperties. +func (a AvailableScopeProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "properties", a.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailableScopeProperties. +func (a *AvailableScopeProperties) 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", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &a.Properties) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AvailableScopeRequest. +func (a AvailableScopeRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "properties", a.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailableScopeRequest. +func (a *AvailableScopeRequest) 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", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &a.Properties) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AvailableScopeRequestProperties. +func (a AvailableScopeRequestProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "scopes", a.Scopes) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailableScopeRequestProperties. +func (a *AvailableScopeRequestProperties) 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", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "scopes": + err = unpopulate(val, "Scopes", &a.Scopes) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type BillingInformation. +func (b BillingInformation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "billingCurrencyProratedAmount", b.BillingCurrencyProratedAmount) + populate(objectMap, "billingCurrencyRemainingCommitmentAmount", b.BillingCurrencyRemainingCommitmentAmount) + populate(objectMap, "billingCurrencyTotalPaidAmount", b.BillingCurrencyTotalPaidAmount) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type BillingInformation. +func (b *BillingInformation) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", b, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "billingCurrencyProratedAmount": + err = unpopulate(val, "BillingCurrencyProratedAmount", &b.BillingCurrencyProratedAmount) + delete(rawMsg, key) + case "billingCurrencyRemainingCommitmentAmount": + err = unpopulate(val, "BillingCurrencyRemainingCommitmentAmount", &b.BillingCurrencyRemainingCommitmentAmount) + delete(rawMsg, key) + case "billingCurrencyTotalPaidAmount": + err = unpopulate(val, "BillingCurrencyTotalPaidAmount", &b.BillingCurrencyTotalPaidAmount) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", b, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type CalculateExchangeOperationResultResponse. +func (c CalculateExchangeOperationResultResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "error", c.Error) + populate(objectMap, "id", c.ID) + populate(objectMap, "name", c.Name) + populate(objectMap, "properties", c.Properties) + populate(objectMap, "status", c.Status) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CalculateExchangeOperationResultResponse. +func (c *CalculateExchangeOperationResultResponse) 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 "error": + err = unpopulate(val, "Error", &c.Error) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &c.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &c.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &c.Properties) + delete(rawMsg, key) + case "status": + err = unpopulate(val, "Status", &c.Status) + 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 CalculateExchangeRequest. +func (c CalculateExchangeRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "properties", c.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CalculateExchangeRequest. +func (c *CalculateExchangeRequest) 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 "properties": + err = unpopulate(val, "Properties", &c.Properties) + 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 CalculateExchangeRequestProperties. +func (c CalculateExchangeRequestProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "reservationsToExchange", c.ReservationsToExchange) + populate(objectMap, "reservationsToPurchase", c.ReservationsToPurchase) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CalculateExchangeRequestProperties. +func (c *CalculateExchangeRequestProperties) 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 "reservationsToExchange": + err = unpopulate(val, "ReservationsToExchange", &c.ReservationsToExchange) + delete(rawMsg, key) + case "reservationsToPurchase": + err = unpopulate(val, "ReservationsToPurchase", &c.ReservationsToPurchase) + 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 CalculateExchangeResponseProperties. +func (c CalculateExchangeResponseProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "netPayable", c.NetPayable) + populate(objectMap, "policyResult", c.PolicyResult) + populate(objectMap, "purchasesTotal", c.PurchasesTotal) + populate(objectMap, "refundsTotal", c.RefundsTotal) + populate(objectMap, "reservationsToExchange", c.ReservationsToExchange) + populate(objectMap, "reservationsToPurchase", c.ReservationsToPurchase) + populate(objectMap, "sessionId", c.SessionID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CalculateExchangeResponseProperties. +func (c *CalculateExchangeResponseProperties) 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 "netPayable": + err = unpopulate(val, "NetPayable", &c.NetPayable) + delete(rawMsg, key) + case "policyResult": + err = unpopulate(val, "PolicyResult", &c.PolicyResult) + delete(rawMsg, key) + case "purchasesTotal": + err = unpopulate(val, "PurchasesTotal", &c.PurchasesTotal) + delete(rawMsg, key) + case "refundsTotal": + err = unpopulate(val, "RefundsTotal", &c.RefundsTotal) + delete(rawMsg, key) + case "reservationsToExchange": + err = unpopulate(val, "ReservationsToExchange", &c.ReservationsToExchange) + delete(rawMsg, key) + case "reservationsToPurchase": + err = unpopulate(val, "ReservationsToPurchase", &c.ReservationsToPurchase) + delete(rawMsg, key) + case "sessionId": + err = unpopulate(val, "SessionID", &c.SessionID) + 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 CalculatePriceResponse. +func (c CalculatePriceResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "properties", c.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CalculatePriceResponse. +func (c *CalculatePriceResponse) 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 "properties": + err = unpopulate(val, "Properties", &c.Properties) + 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 CalculatePriceResponseProperties. +func (c CalculatePriceResponseProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "billingCurrencyTotal", c.BillingCurrencyTotal) + populate(objectMap, "grandTotal", c.GrandTotal) + populate(objectMap, "isBillingPartnerManaged", c.IsBillingPartnerManaged) + populate(objectMap, "isTaxIncluded", c.IsTaxIncluded) + populate(objectMap, "netTotal", c.NetTotal) + populate(objectMap, "paymentSchedule", c.PaymentSchedule) + populate(objectMap, "pricingCurrencyTotal", c.PricingCurrencyTotal) + populate(objectMap, "reservationOrderId", c.ReservationOrderID) + populate(objectMap, "skuDescription", c.SKUDescription) + populate(objectMap, "skuTitle", c.SKUTitle) + populate(objectMap, "taxTotal", c.TaxTotal) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CalculatePriceResponseProperties. +func (c *CalculatePriceResponseProperties) 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 "billingCurrencyTotal": + err = unpopulate(val, "BillingCurrencyTotal", &c.BillingCurrencyTotal) + delete(rawMsg, key) + case "grandTotal": + err = unpopulate(val, "GrandTotal", &c.GrandTotal) + delete(rawMsg, key) + case "isBillingPartnerManaged": + err = unpopulate(val, "IsBillingPartnerManaged", &c.IsBillingPartnerManaged) + delete(rawMsg, key) + case "isTaxIncluded": + err = unpopulate(val, "IsTaxIncluded", &c.IsTaxIncluded) + delete(rawMsg, key) + case "netTotal": + err = unpopulate(val, "NetTotal", &c.NetTotal) + delete(rawMsg, key) + case "paymentSchedule": + err = unpopulate(val, "PaymentSchedule", &c.PaymentSchedule) + delete(rawMsg, key) + case "pricingCurrencyTotal": + err = unpopulate(val, "PricingCurrencyTotal", &c.PricingCurrencyTotal) + delete(rawMsg, key) + case "reservationOrderId": + err = unpopulate(val, "ReservationOrderID", &c.ReservationOrderID) + delete(rawMsg, key) + case "skuDescription": + err = unpopulate(val, "SKUDescription", &c.SKUDescription) + delete(rawMsg, key) + case "skuTitle": + err = unpopulate(val, "SKUTitle", &c.SKUTitle) + delete(rawMsg, key) + case "taxTotal": + err = unpopulate(val, "TaxTotal", &c.TaxTotal) + 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 CalculatePriceResponsePropertiesBillingCurrencyTotal. +func (c CalculatePriceResponsePropertiesBillingCurrencyTotal) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "amount", c.Amount) + populate(objectMap, "currencyCode", c.CurrencyCode) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CalculatePriceResponsePropertiesBillingCurrencyTotal. +func (c *CalculatePriceResponsePropertiesBillingCurrencyTotal) 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 "amount": + err = unpopulate(val, "Amount", &c.Amount) + delete(rawMsg, key) + case "currencyCode": + err = unpopulate(val, "CurrencyCode", &c.CurrencyCode) + 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 CalculatePriceResponsePropertiesPricingCurrencyTotal. +func (c CalculatePriceResponsePropertiesPricingCurrencyTotal) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "amount", c.Amount) + populate(objectMap, "currencyCode", c.CurrencyCode) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CalculatePriceResponsePropertiesPricingCurrencyTotal. +func (c *CalculatePriceResponsePropertiesPricingCurrencyTotal) 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 "amount": + err = unpopulate(val, "Amount", &c.Amount) + delete(rawMsg, key) + case "currencyCode": + err = unpopulate(val, "CurrencyCode", &c.CurrencyCode) + 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 Catalog. +func (c Catalog) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "billingPlans", c.BillingPlans) + populate(objectMap, "capabilities", c.Capabilities) + populate(objectMap, "locations", c.Locations) + populate(objectMap, "msrp", c.Msrp) + populate(objectMap, "name", c.Name) + populate(objectMap, "resourceType", c.ResourceType) + populate(objectMap, "restrictions", c.Restrictions) + populate(objectMap, "skuProperties", c.SKUProperties) + populate(objectMap, "size", c.Size) + populate(objectMap, "terms", c.Terms) + populate(objectMap, "tier", c.Tier) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Catalog. +func (c *Catalog) 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 "billingPlans": + err = unpopulate(val, "BillingPlans", &c.BillingPlans) + delete(rawMsg, key) + case "capabilities": + err = unpopulate(val, "Capabilities", &c.Capabilities) + delete(rawMsg, key) + case "locations": + err = unpopulate(val, "Locations", &c.Locations) + delete(rawMsg, key) + case "msrp": + err = unpopulate(val, "Msrp", &c.Msrp) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &c.Name) + delete(rawMsg, key) + case "resourceType": + err = unpopulate(val, "ResourceType", &c.ResourceType) + delete(rawMsg, key) + case "restrictions": + err = unpopulate(val, "Restrictions", &c.Restrictions) + delete(rawMsg, key) + case "skuProperties": + err = unpopulate(val, "SKUProperties", &c.SKUProperties) + delete(rawMsg, key) + case "size": + err = unpopulate(val, "Size", &c.Size) + delete(rawMsg, key) + case "terms": + err = unpopulate(val, "Terms", &c.Terms) + delete(rawMsg, key) + case "tier": + err = unpopulate(val, "Tier", &c.Tier) + 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 CatalogMsrp. +func (c CatalogMsrp) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "p1Y", c.P1Y) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CatalogMsrp. +func (c *CatalogMsrp) 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 "p1Y": + err = unpopulate(val, "P1Y", &c.P1Y) + 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 ChangeDirectoryRequest. +func (c ChangeDirectoryRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "destinationTenantId", c.DestinationTenantID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ChangeDirectoryRequest. +func (c *ChangeDirectoryRequest) 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 "destinationTenantId": + err = unpopulate(val, "DestinationTenantID", &c.DestinationTenantID) + 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 ChangeDirectoryResponse. +func (c ChangeDirectoryResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "reservationOrder", c.ReservationOrder) + populate(objectMap, "reservations", c.Reservations) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ChangeDirectoryResponse. +func (c *ChangeDirectoryResponse) 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 "reservationOrder": + err = unpopulate(val, "ReservationOrder", &c.ReservationOrder) + delete(rawMsg, key) + case "reservations": + err = unpopulate(val, "Reservations", &c.Reservations) + 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 ChangeDirectoryResult. +func (c ChangeDirectoryResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "error", c.Error) + populate(objectMap, "id", c.ID) + populate(objectMap, "isSucceeded", c.IsSucceeded) + populate(objectMap, "name", c.Name) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ChangeDirectoryResult. +func (c *ChangeDirectoryResult) 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 "error": + err = unpopulate(val, "Error", &c.Error) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &c.ID) + delete(rawMsg, key) + case "isSucceeded": + err = unpopulate(val, "IsSucceeded", &c.IsSucceeded) + delete(rawMsg, 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 CreateGenericQuotaRequestParameters. +func (c CreateGenericQuotaRequestParameters) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "value", c.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CreateGenericQuotaRequestParameters. +func (c *CreateGenericQuotaRequestParameters) 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 "value": + err = unpopulate(val, "Value", &c.Value) + 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 CurrentQuotaLimit. +func (c CurrentQuotaLimit) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "properties", c.Properties) + populate(objectMap, "quotaInformation", c.QuotaInformation) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CurrentQuotaLimit. +func (c *CurrentQuotaLimit) 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 "properties": + err = unpopulate(val, "Properties", &c.Properties) + delete(rawMsg, key) + case "quotaInformation": + err = unpopulate(val, "QuotaInformation", &c.QuotaInformation) + 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 CurrentQuotaLimitBase. +func (c CurrentQuotaLimitBase) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "id", c.ID) + populate(objectMap, "name", c.Name) + populate(objectMap, "properties", c.Properties) + populate(objectMap, "type", c.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type CurrentQuotaLimitBase. +func (c *CurrentQuotaLimitBase) 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 "id": + err = unpopulate(val, "ID", &c.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &c.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &c.Properties) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &c.Type) + 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 Error. +func (e Error) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "error", e.Error) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Error. +func (e *Error) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "error": + err = unpopulate(val, "Error", &e.Error) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ErrorDetails. +func (e ErrorDetails) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "code", e.Code) + populate(objectMap, "message", e.Message) + populate(objectMap, "target", e.Target) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetails. +func (e *ErrorDetails) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "code": + err = unpopulate(val, "Code", &e.Code) + delete(rawMsg, key) + case "message": + err = unpopulate(val, "Message", &e.Message) + delete(rawMsg, key) + case "target": + err = unpopulate(val, "Target", &e.Target) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ErrorResponse. +func (e ErrorResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "error", e.Error) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponse. +func (e *ErrorResponse) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "error": + err = unpopulate(val, "Error", &e.Error) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExceptionResponse. +func (e ExceptionResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "error", e.Error) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExceptionResponse. +func (e *ExceptionResponse) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "error": + err = unpopulate(val, "Error", &e.Error) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExchangeOperationResultResponse. +func (e ExchangeOperationResultResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "error", e.Error) + populate(objectMap, "id", e.ID) + populate(objectMap, "name", e.Name) + populate(objectMap, "properties", e.Properties) + populate(objectMap, "status", e.Status) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExchangeOperationResultResponse. +func (e *ExchangeOperationResultResponse) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "error": + err = unpopulate(val, "Error", &e.Error) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &e.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &e.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &e.Properties) + delete(rawMsg, key) + case "status": + err = unpopulate(val, "Status", &e.Status) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExchangePolicyError. +func (e ExchangePolicyError) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "code", e.Code) + populate(objectMap, "message", e.Message) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExchangePolicyError. +func (e *ExchangePolicyError) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "code": + err = unpopulate(val, "Code", &e.Code) + delete(rawMsg, key) + case "message": + err = unpopulate(val, "Message", &e.Message) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExchangePolicyErrors. +func (e ExchangePolicyErrors) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "policyErrors", e.PolicyErrors) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExchangePolicyErrors. +func (e *ExchangePolicyErrors) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "policyErrors": + err = unpopulate(val, "PolicyErrors", &e.PolicyErrors) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExchangeRequest. +func (e ExchangeRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "properties", e.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExchangeRequest. +func (e *ExchangeRequest) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &e.Properties) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExchangeRequestProperties. +func (e ExchangeRequestProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "sessionId", e.SessionID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExchangeRequestProperties. +func (e *ExchangeRequestProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "sessionId": + err = unpopulate(val, "SessionID", &e.SessionID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExchangeResponseProperties. +func (e ExchangeResponseProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "netPayable", e.NetPayable) + populate(objectMap, "policyResult", e.PolicyResult) + populate(objectMap, "purchasesTotal", e.PurchasesTotal) + populate(objectMap, "refundsTotal", e.RefundsTotal) + populate(objectMap, "reservationsToExchange", e.ReservationsToExchange) + populate(objectMap, "reservationsToPurchase", e.ReservationsToPurchase) + populate(objectMap, "sessionId", e.SessionID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExchangeResponseProperties. +func (e *ExchangeResponseProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "netPayable": + err = unpopulate(val, "NetPayable", &e.NetPayable) + delete(rawMsg, key) + case "policyResult": + err = unpopulate(val, "PolicyResult", &e.PolicyResult) + delete(rawMsg, key) + case "purchasesTotal": + err = unpopulate(val, "PurchasesTotal", &e.PurchasesTotal) + delete(rawMsg, key) + case "refundsTotal": + err = unpopulate(val, "RefundsTotal", &e.RefundsTotal) + delete(rawMsg, key) + case "reservationsToExchange": + err = unpopulate(val, "ReservationsToExchange", &e.ReservationsToExchange) + delete(rawMsg, key) + case "reservationsToPurchase": + err = unpopulate(val, "ReservationsToPurchase", &e.ReservationsToPurchase) + delete(rawMsg, key) + case "sessionId": + err = unpopulate(val, "SessionID", &e.SessionID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExtendedErrorInfo. +func (e ExtendedErrorInfo) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "code", e.Code) + populate(objectMap, "message", e.Message) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExtendedErrorInfo. +func (e *ExtendedErrorInfo) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "code": + err = unpopulate(val, "Code", &e.Code) + delete(rawMsg, key) + case "message": + err = unpopulate(val, "Message", &e.Message) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExtendedStatusInfo. +func (e ExtendedStatusInfo) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "message", e.Message) + populate(objectMap, "statusCode", e.StatusCode) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExtendedStatusInfo. +func (e *ExtendedStatusInfo) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "message": + err = unpopulate(val, "Message", &e.Message) + delete(rawMsg, key) + case "statusCode": + err = unpopulate(val, "StatusCode", &e.StatusCode) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ListResult. +func (l ListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "nextLink", l.NextLink) + populate(objectMap, "summary", l.Summary) + populate(objectMap, "value", l.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ListResult. +func (l *ListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", l, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &l.NextLink) + delete(rawMsg, key) + case "summary": + err = unpopulate(val, "Summary", &l.Summary) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &l.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", l, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type MergeProperties. +func (m MergeProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "sources", m.Sources) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type MergeProperties. +func (m *MergeProperties) 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 "sources": + err = unpopulate(val, "Sources", &m.Sources) + 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 MergeRequest. +func (m MergeRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "properties", m.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type MergeRequest. +func (m *MergeRequest) 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) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OperationDisplay. +func (o OperationDisplay) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "description", o.Description) + populate(objectMap, "operation", o.Operation) + populate(objectMap, "provider", o.Provider) + populate(objectMap, "resource", o.Resource) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay. +func (o *OperationDisplay) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "description": + err = unpopulate(val, "Description", &o.Description) + delete(rawMsg, key) + case "operation": + err = unpopulate(val, "Operation", &o.Operation) + delete(rawMsg, key) + case "provider": + err = unpopulate(val, "Provider", &o.Provider) + delete(rawMsg, key) + case "resource": + err = unpopulate(val, "Resource", &o.Resource) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OperationList. +func (o OperationList) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "nextLink", o.NextLink) + populate(objectMap, "value", o.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OperationList. +func (o *OperationList) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &o.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &o.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OperationResponse. +func (o OperationResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "display", o.Display) + populate(objectMap, "isDataAction", o.IsDataAction) + populate(objectMap, "name", o.Name) + populate(objectMap, "origin", o.Origin) + populate(objectMap, "properties", &o.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OperationResponse. +func (o *OperationResponse) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "display": + err = unpopulate(val, "Display", &o.Display) + delete(rawMsg, key) + case "isDataAction": + err = unpopulate(val, "IsDataAction", &o.IsDataAction) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &o.Name) + delete(rawMsg, key) + case "origin": + err = unpopulate(val, "Origin", &o.Origin) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &o.Properties) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OperationResultError. +func (o OperationResultError) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "code", o.Code) + populate(objectMap, "message", o.Message) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OperationResultError. +func (o *OperationResultError) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "code": + err = unpopulate(val, "Code", &o.Code) + delete(rawMsg, key) + case "message": + err = unpopulate(val, "Message", &o.Message) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type Patch. +func (p Patch) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "properties", p.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Patch. +func (p *Patch) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &p.Properties) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type PatchProperties. +func (p PatchProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "appliedScopeType", p.AppliedScopeType) + populate(objectMap, "appliedScopes", p.AppliedScopes) + populate(objectMap, "instanceFlexibility", p.InstanceFlexibility) + populate(objectMap, "name", p.Name) + populate(objectMap, "renew", p.Renew) + populate(objectMap, "renewProperties", p.RenewProperties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PatchProperties. +func (p *PatchProperties) 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 "appliedScopeType": + err = unpopulate(val, "AppliedScopeType", &p.AppliedScopeType) + delete(rawMsg, key) + case "appliedScopes": + err = unpopulate(val, "AppliedScopes", &p.AppliedScopes) + delete(rawMsg, key) + case "instanceFlexibility": + err = unpopulate(val, "InstanceFlexibility", &p.InstanceFlexibility) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &p.Name) + delete(rawMsg, key) + case "renew": + err = unpopulate(val, "Renew", &p.Renew) + delete(rawMsg, key) + case "renewProperties": + err = unpopulate(val, "RenewProperties", &p.RenewProperties) + 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 PatchPropertiesRenewProperties. +func (p PatchPropertiesRenewProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "purchaseProperties", p.PurchaseProperties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PatchPropertiesRenewProperties. +func (p *PatchPropertiesRenewProperties) 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 "purchaseProperties": + err = unpopulate(val, "PurchaseProperties", &p.PurchaseProperties) + 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 PaymentDetail. +func (p PaymentDetail) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "billingAccount", p.BillingAccount) + populate(objectMap, "billingCurrencyTotal", p.BillingCurrencyTotal) + populateDateType(objectMap, "dueDate", p.DueDate) + populate(objectMap, "extendedStatusInfo", p.ExtendedStatusInfo) + populateDateType(objectMap, "paymentDate", p.PaymentDate) + populate(objectMap, "pricingCurrencyTotal", p.PricingCurrencyTotal) + populate(objectMap, "status", p.Status) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PaymentDetail. +func (p *PaymentDetail) 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 "billingAccount": + err = unpopulate(val, "BillingAccount", &p.BillingAccount) + delete(rawMsg, key) + case "billingCurrencyTotal": + err = unpopulate(val, "BillingCurrencyTotal", &p.BillingCurrencyTotal) + delete(rawMsg, key) + case "dueDate": + err = unpopulateDateType(val, "DueDate", &p.DueDate) + delete(rawMsg, key) + case "extendedStatusInfo": + err = unpopulate(val, "ExtendedStatusInfo", &p.ExtendedStatusInfo) + delete(rawMsg, key) + case "paymentDate": + err = unpopulateDateType(val, "PaymentDate", &p.PaymentDate) + delete(rawMsg, key) + case "pricingCurrencyTotal": + err = unpopulate(val, "PricingCurrencyTotal", &p.PricingCurrencyTotal) + delete(rawMsg, key) + case "status": + err = unpopulate(val, "Status", &p.Status) + 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 Price. +func (p Price) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "amount", p.Amount) + populate(objectMap, "currencyCode", p.CurrencyCode) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Price. +func (p *Price) 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 "amount": + err = unpopulate(val, "Amount", &p.Amount) + delete(rawMsg, key) + case "currencyCode": + err = unpopulate(val, "CurrencyCode", &p.CurrencyCode) + 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 Properties. +func (p Properties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "appliedScopeType", p.AppliedScopeType) + populate(objectMap, "appliedScopes", p.AppliedScopes) + populate(objectMap, "archived", p.Archived) + populateTimeRFC3339(objectMap, "benefitStartTime", p.BenefitStartTime) + populate(objectMap, "billingPlan", p.BillingPlan) + populate(objectMap, "billingScopeId", p.BillingScopeID) + populate(objectMap, "capabilities", p.Capabilities) + populate(objectMap, "displayName", p.DisplayName) + populate(objectMap, "displayProvisioningState", p.DisplayProvisioningState) + populateTimeRFC3339(objectMap, "effectiveDateTime", p.EffectiveDateTime) + populateDateType(objectMap, "expiryDate", p.ExpiryDate) + populate(objectMap, "extendedStatusInfo", p.ExtendedStatusInfo) + populate(objectMap, "instanceFlexibility", p.InstanceFlexibility) + populateTimeRFC3339(objectMap, "lastUpdatedDateTime", p.LastUpdatedDateTime) + populate(objectMap, "mergeProperties", p.MergeProperties) + populate(objectMap, "provisioningState", p.ProvisioningState) + populate(objectMap, "provisioningSubState", p.ProvisioningSubState) + populateDateType(objectMap, "purchaseDate", p.PurchaseDate) + populate(objectMap, "quantity", p.Quantity) + populate(objectMap, "renew", p.Renew) + populate(objectMap, "renewDestination", p.RenewDestination) + populate(objectMap, "renewProperties", p.RenewProperties) + populate(objectMap, "renewSource", p.RenewSource) + populate(objectMap, "reservedResourceType", p.ReservedResourceType) + populate(objectMap, "skuDescription", p.SKUDescription) + populate(objectMap, "splitProperties", p.SplitProperties) + populate(objectMap, "term", p.Term) + populate(objectMap, "userFriendlyAppliedScopeType", p.UserFriendlyAppliedScopeType) + populate(objectMap, "userFriendlyRenewState", p.UserFriendlyRenewState) + populate(objectMap, "utilization", p.Utilization) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Properties. +func (p *Properties) 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 "appliedScopeType": + err = unpopulate(val, "AppliedScopeType", &p.AppliedScopeType) + delete(rawMsg, key) + case "appliedScopes": + err = unpopulate(val, "AppliedScopes", &p.AppliedScopes) + delete(rawMsg, key) + case "archived": + err = unpopulate(val, "Archived", &p.Archived) + delete(rawMsg, key) + case "benefitStartTime": + err = unpopulateTimeRFC3339(val, "BenefitStartTime", &p.BenefitStartTime) + delete(rawMsg, key) + case "billingPlan": + err = unpopulate(val, "BillingPlan", &p.BillingPlan) + delete(rawMsg, key) + case "billingScopeId": + err = unpopulate(val, "BillingScopeID", &p.BillingScopeID) + delete(rawMsg, key) + case "capabilities": + err = unpopulate(val, "Capabilities", &p.Capabilities) + delete(rawMsg, key) + case "displayName": + err = unpopulate(val, "DisplayName", &p.DisplayName) + delete(rawMsg, key) + case "displayProvisioningState": + err = unpopulate(val, "DisplayProvisioningState", &p.DisplayProvisioningState) + delete(rawMsg, key) + case "effectiveDateTime": + err = unpopulateTimeRFC3339(val, "EffectiveDateTime", &p.EffectiveDateTime) + delete(rawMsg, key) + case "expiryDate": + err = unpopulateDateType(val, "ExpiryDate", &p.ExpiryDate) + delete(rawMsg, key) + case "extendedStatusInfo": + err = unpopulate(val, "ExtendedStatusInfo", &p.ExtendedStatusInfo) + delete(rawMsg, key) + case "instanceFlexibility": + err = unpopulate(val, "InstanceFlexibility", &p.InstanceFlexibility) + delete(rawMsg, key) + case "lastUpdatedDateTime": + err = unpopulateTimeRFC3339(val, "LastUpdatedDateTime", &p.LastUpdatedDateTime) + delete(rawMsg, key) + case "mergeProperties": + err = unpopulate(val, "MergeProperties", &p.MergeProperties) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &p.ProvisioningState) + delete(rawMsg, key) + case "provisioningSubState": + err = unpopulate(val, "ProvisioningSubState", &p.ProvisioningSubState) + delete(rawMsg, key) + case "purchaseDate": + err = unpopulateDateType(val, "PurchaseDate", &p.PurchaseDate) + delete(rawMsg, key) + case "quantity": + err = unpopulate(val, "Quantity", &p.Quantity) + delete(rawMsg, key) + case "renew": + err = unpopulate(val, "Renew", &p.Renew) + delete(rawMsg, key) + case "renewDestination": + err = unpopulate(val, "RenewDestination", &p.RenewDestination) + delete(rawMsg, key) + case "renewProperties": + err = unpopulate(val, "RenewProperties", &p.RenewProperties) + delete(rawMsg, key) + case "renewSource": + err = unpopulate(val, "RenewSource", &p.RenewSource) + delete(rawMsg, key) + case "reservedResourceType": + err = unpopulate(val, "ReservedResourceType", &p.ReservedResourceType) + delete(rawMsg, key) + case "skuDescription": + err = unpopulate(val, "SKUDescription", &p.SKUDescription) + delete(rawMsg, key) + case "splitProperties": + err = unpopulate(val, "SplitProperties", &p.SplitProperties) + delete(rawMsg, key) + case "term": + err = unpopulate(val, "Term", &p.Term) + delete(rawMsg, key) + case "userFriendlyAppliedScopeType": + err = unpopulate(val, "UserFriendlyAppliedScopeType", &p.UserFriendlyAppliedScopeType) + delete(rawMsg, key) + case "userFriendlyRenewState": + err = unpopulate(val, "UserFriendlyRenewState", &p.UserFriendlyRenewState) + delete(rawMsg, key) + case "utilization": + err = unpopulate(val, "Utilization", &p.Utilization) + 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 PropertiesUtilization. +func (p PropertiesUtilization) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "aggregates", p.Aggregates) + populate(objectMap, "trend", p.Trend) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PropertiesUtilization. +func (p *PropertiesUtilization) 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 "aggregates": + err = unpopulate(val, "Aggregates", &p.Aggregates) + delete(rawMsg, key) + case "trend": + err = unpopulate(val, "Trend", &p.Trend) + 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 PurchaseRequest. +func (p PurchaseRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "location", p.Location) + populate(objectMap, "properties", p.Properties) + populate(objectMap, "sku", p.SKU) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PurchaseRequest. +func (p *PurchaseRequest) 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 "location": + err = unpopulate(val, "Location", &p.Location) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &p.Properties) + delete(rawMsg, key) + case "sku": + err = unpopulate(val, "SKU", &p.SKU) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type PurchaseRequestProperties. +func (p PurchaseRequestProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "appliedScopeType", p.AppliedScopeType) + populate(objectMap, "appliedScopes", p.AppliedScopes) + populate(objectMap, "billingPlan", p.BillingPlan) + populate(objectMap, "billingScopeId", p.BillingScopeID) + populate(objectMap, "displayName", p.DisplayName) + populate(objectMap, "quantity", p.Quantity) + populate(objectMap, "renew", p.Renew) + populate(objectMap, "reservedResourceProperties", p.ReservedResourceProperties) + populate(objectMap, "reservedResourceType", p.ReservedResourceType) + populate(objectMap, "term", p.Term) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PurchaseRequestProperties. +func (p *PurchaseRequestProperties) 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 "appliedScopeType": + err = unpopulate(val, "AppliedScopeType", &p.AppliedScopeType) + delete(rawMsg, key) + case "appliedScopes": + err = unpopulate(val, "AppliedScopes", &p.AppliedScopes) + delete(rawMsg, key) + case "billingPlan": + err = unpopulate(val, "BillingPlan", &p.BillingPlan) + delete(rawMsg, key) + case "billingScopeId": + err = unpopulate(val, "BillingScopeID", &p.BillingScopeID) + delete(rawMsg, key) + case "displayName": + err = unpopulate(val, "DisplayName", &p.DisplayName) + delete(rawMsg, key) + case "quantity": + err = unpopulate(val, "Quantity", &p.Quantity) + delete(rawMsg, key) + case "renew": + err = unpopulate(val, "Renew", &p.Renew) + delete(rawMsg, key) + case "reservedResourceProperties": + err = unpopulate(val, "ReservedResourceProperties", &p.ReservedResourceProperties) + delete(rawMsg, key) + case "reservedResourceType": + err = unpopulate(val, "ReservedResourceType", &p.ReservedResourceType) + delete(rawMsg, key) + case "term": + err = unpopulate(val, "Term", &p.Term) + 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 PurchaseRequestPropertiesReservedResourceProperties. +func (p PurchaseRequestPropertiesReservedResourceProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "instanceFlexibility", p.InstanceFlexibility) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PurchaseRequestPropertiesReservedResourceProperties. +func (p *PurchaseRequestPropertiesReservedResourceProperties) 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 "instanceFlexibility": + err = unpopulate(val, "InstanceFlexibility", &p.InstanceFlexibility) + 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 QuotaLimits. +func (q QuotaLimits) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "nextLink", q.NextLink) + populate(objectMap, "value", q.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaLimits. +func (q *QuotaLimits) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &q.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &q.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type QuotaLimitsResponse. +func (q QuotaLimitsResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "nextLink", q.NextLink) + populate(objectMap, "value", q.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaLimitsResponse. +func (q *QuotaLimitsResponse) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &q.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &q.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type QuotaProperties. +func (q QuotaProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "currentValue", q.CurrentValue) + populate(objectMap, "limit", q.Limit) + populate(objectMap, "name", q.Name) + populate(objectMap, "properties", &q.Properties) + populate(objectMap, "quotaPeriod", q.QuotaPeriod) + populate(objectMap, "resourceType", q.ResourceType) + populate(objectMap, "unit", q.Unit) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaProperties. +func (q *QuotaProperties) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "currentValue": + err = unpopulate(val, "CurrentValue", &q.CurrentValue) + delete(rawMsg, key) + case "limit": + err = unpopulate(val, "Limit", &q.Limit) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &q.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &q.Properties) + delete(rawMsg, key) + case "quotaPeriod": + err = unpopulate(val, "QuotaPeriod", &q.QuotaPeriod) + delete(rawMsg, key) + case "resourceType": + err = unpopulate(val, "ResourceType", &q.ResourceType) + delete(rawMsg, key) + case "unit": + err = unpopulate(val, "Unit", &q.Unit) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type QuotaRequestDetails. +func (q QuotaRequestDetails) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "id", q.ID) + populate(objectMap, "name", q.Name) + populate(objectMap, "properties", q.Properties) + populate(objectMap, "type", q.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaRequestDetails. +func (q *QuotaRequestDetails) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &q.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &q.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &q.Properties) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &q.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type QuotaRequestDetailsList. +func (q QuotaRequestDetailsList) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "nextLink", q.NextLink) + populate(objectMap, "value", q.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaRequestDetailsList. +func (q *QuotaRequestDetailsList) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &q.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &q.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type QuotaRequestOneResourceProperties. +func (q QuotaRequestOneResourceProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "message", q.Message) + populate(objectMap, "properties", q.Properties) + populate(objectMap, "provisioningState", q.ProvisioningState) + populateTimeRFC3339(objectMap, "requestSubmitTime", q.RequestSubmitTime) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaRequestOneResourceProperties. +func (q *QuotaRequestOneResourceProperties) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "message": + err = unpopulate(val, "Message", &q.Message) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &q.Properties) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &q.ProvisioningState) + delete(rawMsg, key) + case "requestSubmitTime": + err = unpopulateTimeRFC3339(val, "RequestSubmitTime", &q.RequestSubmitTime) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type QuotaRequestOneResourceSubmitResponse. +func (q QuotaRequestOneResourceSubmitResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "id", q.ID) + populate(objectMap, "name", q.Name) + populate(objectMap, "properties", q.Properties) + populate(objectMap, "type", q.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaRequestOneResourceSubmitResponse. +func (q *QuotaRequestOneResourceSubmitResponse) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &q.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &q.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &q.Properties) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &q.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type QuotaRequestProperties. +func (q QuotaRequestProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "message", q.Message) + populate(objectMap, "provisioningState", q.ProvisioningState) + populateTimeRFC3339(objectMap, "requestSubmitTime", q.RequestSubmitTime) + populate(objectMap, "value", q.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaRequestProperties. +func (q *QuotaRequestProperties) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "message": + err = unpopulate(val, "Message", &q.Message) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &q.ProvisioningState) + delete(rawMsg, key) + case "requestSubmitTime": + err = unpopulateTimeRFC3339(val, "RequestSubmitTime", &q.RequestSubmitTime) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &q.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type QuotaRequestStatusDetails. +func (q QuotaRequestStatusDetails) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "message", q.Message) + populate(objectMap, "provisioningState", q.ProvisioningState) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaRequestStatusDetails. +func (q *QuotaRequestStatusDetails) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "message": + err = unpopulate(val, "Message", &q.Message) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &q.ProvisioningState) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type QuotaRequestSubmitResponse. +func (q QuotaRequestSubmitResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "id", q.ID) + populate(objectMap, "name", q.Name) + populate(objectMap, "properties", q.Properties) + populate(objectMap, "type", q.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaRequestSubmitResponse. +func (q *QuotaRequestSubmitResponse) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &q.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &q.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &q.Properties) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &q.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type QuotaRequestSubmitResponse201. +func (q QuotaRequestSubmitResponse201) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "id", q.ID) + populate(objectMap, "name", q.Name) + populate(objectMap, "properties", q.Properties) + populate(objectMap, "type", q.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaRequestSubmitResponse201. +func (q *QuotaRequestSubmitResponse201) 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", q, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &q.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &q.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &q.Properties) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &q.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", q, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type RenewPropertiesResponse. +func (r RenewPropertiesResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "billingCurrencyTotal", r.BillingCurrencyTotal) + populate(objectMap, "pricingCurrencyTotal", r.PricingCurrencyTotal) + populate(objectMap, "purchaseProperties", r.PurchaseProperties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type RenewPropertiesResponse. +func (r *RenewPropertiesResponse) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "billingCurrencyTotal": + err = unpopulate(val, "BillingCurrencyTotal", &r.BillingCurrencyTotal) + delete(rawMsg, key) + case "pricingCurrencyTotal": + err = unpopulate(val, "PricingCurrencyTotal", &r.PricingCurrencyTotal) + delete(rawMsg, key) + case "purchaseProperties": + err = unpopulate(val, "PurchaseProperties", &r.PurchaseProperties) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type RenewPropertiesResponseBillingCurrencyTotal. +func (r RenewPropertiesResponseBillingCurrencyTotal) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "amount", r.Amount) + populate(objectMap, "currencyCode", r.CurrencyCode) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type RenewPropertiesResponseBillingCurrencyTotal. +func (r *RenewPropertiesResponseBillingCurrencyTotal) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "amount": + err = unpopulate(val, "Amount", &r.Amount) + delete(rawMsg, key) + case "currencyCode": + err = unpopulate(val, "CurrencyCode", &r.CurrencyCode) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type RenewPropertiesResponsePricingCurrencyTotal. +func (r RenewPropertiesResponsePricingCurrencyTotal) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "amount", r.Amount) + populate(objectMap, "currencyCode", r.CurrencyCode) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type RenewPropertiesResponsePricingCurrencyTotal. +func (r *RenewPropertiesResponsePricingCurrencyTotal) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "amount": + err = unpopulate(val, "Amount", &r.Amount) + delete(rawMsg, key) + case "currencyCode": + err = unpopulate(val, "CurrencyCode", &r.CurrencyCode) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationList. +func (r ReservationList) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "nextLink", r.NextLink) + populate(objectMap, "value", r.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationList. +func (r *ReservationList) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &r.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &r.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationMergeProperties. +func (r ReservationMergeProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "mergeDestination", r.MergeDestination) + populate(objectMap, "mergeSources", r.MergeSources) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationMergeProperties. +func (r *ReservationMergeProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "mergeDestination": + err = unpopulate(val, "MergeDestination", &r.MergeDestination) + delete(rawMsg, key) + case "mergeSources": + err = unpopulate(val, "MergeSources", &r.MergeSources) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationOrderBillingPlanInformation. +func (r ReservationOrderBillingPlanInformation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populateDateType(objectMap, "nextPaymentDueDate", r.NextPaymentDueDate) + populate(objectMap, "pricingCurrencyTotal", r.PricingCurrencyTotal) + populateDateType(objectMap, "startDate", r.StartDate) + populate(objectMap, "transactions", r.Transactions) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationOrderBillingPlanInformation. +func (r *ReservationOrderBillingPlanInformation) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextPaymentDueDate": + err = unpopulateDateType(val, "NextPaymentDueDate", &r.NextPaymentDueDate) + delete(rawMsg, key) + case "pricingCurrencyTotal": + err = unpopulate(val, "PricingCurrencyTotal", &r.PricingCurrencyTotal) + delete(rawMsg, key) + case "startDate": + err = unpopulateDateType(val, "StartDate", &r.StartDate) + delete(rawMsg, key) + case "transactions": + err = unpopulate(val, "Transactions", &r.Transactions) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationOrderList. +func (r ReservationOrderList) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "nextLink", r.NextLink) + populate(objectMap, "value", r.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationOrderList. +func (r *ReservationOrderList) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &r.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &r.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationOrderProperties. +func (r ReservationOrderProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populateTimeRFC3339(objectMap, "benefitStartTime", r.BenefitStartTime) + populate(objectMap, "billingPlan", r.BillingPlan) + populateTimeRFC3339(objectMap, "createdDateTime", r.CreatedDateTime) + populate(objectMap, "displayName", r.DisplayName) + populateDateType(objectMap, "expiryDate", r.ExpiryDate) + populate(objectMap, "originalQuantity", r.OriginalQuantity) + populate(objectMap, "planInformation", r.PlanInformation) + populate(objectMap, "provisioningState", r.ProvisioningState) + populateTimeRFC3339(objectMap, "requestDateTime", r.RequestDateTime) + populate(objectMap, "reservations", r.Reservations) + populate(objectMap, "term", r.Term) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationOrderProperties. +func (r *ReservationOrderProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "benefitStartTime": + err = unpopulateTimeRFC3339(val, "BenefitStartTime", &r.BenefitStartTime) + delete(rawMsg, key) + case "billingPlan": + err = unpopulate(val, "BillingPlan", &r.BillingPlan) + delete(rawMsg, key) + case "createdDateTime": + err = unpopulateTimeRFC3339(val, "CreatedDateTime", &r.CreatedDateTime) + delete(rawMsg, key) + case "displayName": + err = unpopulate(val, "DisplayName", &r.DisplayName) + delete(rawMsg, key) + case "expiryDate": + err = unpopulateDateType(val, "ExpiryDate", &r.ExpiryDate) + delete(rawMsg, key) + case "originalQuantity": + err = unpopulate(val, "OriginalQuantity", &r.OriginalQuantity) + delete(rawMsg, key) + case "planInformation": + err = unpopulate(val, "PlanInformation", &r.PlanInformation) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &r.ProvisioningState) + delete(rawMsg, key) + case "requestDateTime": + err = unpopulateTimeRFC3339(val, "RequestDateTime", &r.RequestDateTime) + delete(rawMsg, key) + case "reservations": + err = unpopulate(val, "Reservations", &r.Reservations) + delete(rawMsg, key) + case "term": + err = unpopulate(val, "Term", &r.Term) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationOrderResponse. +func (r ReservationOrderResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "etag", r.Etag) + populate(objectMap, "id", r.ID) + populate(objectMap, "name", r.Name) + populate(objectMap, "properties", r.Properties) + populate(objectMap, "systemData", r.SystemData) + populate(objectMap, "type", r.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationOrderResponse. +func (r *ReservationOrderResponse) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "etag": + err = unpopulate(val, "Etag", &r.Etag) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &r.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &r.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &r.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &r.SystemData) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &r.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationResponse. +func (r ReservationResponse) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "etag", r.Etag) + populate(objectMap, "id", r.ID) + objectMap["kind"] = "Microsoft.Compute" + populate(objectMap, "location", r.Location) + populate(objectMap, "name", r.Name) + populate(objectMap, "properties", r.Properties) + populate(objectMap, "sku", r.SKU) + populate(objectMap, "systemData", r.SystemData) + populate(objectMap, "type", r.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationResponse. +func (r *ReservationResponse) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "etag": + err = unpopulate(val, "Etag", &r.Etag) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &r.ID) + delete(rawMsg, key) + case "kind": + err = unpopulate(val, "Kind", &r.Kind) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &r.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &r.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &r.Properties) + delete(rawMsg, key) + case "sku": + err = unpopulate(val, "SKU", &r.SKU) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &r.SystemData) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &r.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationSplitProperties. +func (r ReservationSplitProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "splitDestinations", r.SplitDestinations) + populate(objectMap, "splitSource", r.SplitSource) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationSplitProperties. +func (r *ReservationSplitProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "splitDestinations": + err = unpopulate(val, "SplitDestinations", &r.SplitDestinations) + delete(rawMsg, key) + case "splitSource": + err = unpopulate(val, "SplitSource", &r.SplitSource) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationSummary. +func (r ReservationSummary) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "cancelledCount", r.CancelledCount) + populate(objectMap, "expiredCount", r.ExpiredCount) + populate(objectMap, "expiringCount", r.ExpiringCount) + populate(objectMap, "failedCount", r.FailedCount) + populate(objectMap, "pendingCount", r.PendingCount) + populate(objectMap, "processingCount", r.ProcessingCount) + populate(objectMap, "succeededCount", r.SucceededCount) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationSummary. +func (r *ReservationSummary) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "cancelledCount": + err = unpopulate(val, "CancelledCount", &r.CancelledCount) + delete(rawMsg, key) + case "expiredCount": + err = unpopulate(val, "ExpiredCount", &r.ExpiredCount) + delete(rawMsg, key) + case "expiringCount": + err = unpopulate(val, "ExpiringCount", &r.ExpiringCount) + delete(rawMsg, key) + case "failedCount": + err = unpopulate(val, "FailedCount", &r.FailedCount) + delete(rawMsg, key) + case "pendingCount": + err = unpopulate(val, "PendingCount", &r.PendingCount) + delete(rawMsg, key) + case "processingCount": + err = unpopulate(val, "ProcessingCount", &r.ProcessingCount) + delete(rawMsg, key) + case "succeededCount": + err = unpopulate(val, "SucceededCount", &r.SucceededCount) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationToExchange. +func (r ReservationToExchange) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "billingInformation", r.BillingInformation) + populate(objectMap, "billingRefundAmount", r.BillingRefundAmount) + populate(objectMap, "quantity", r.Quantity) + populate(objectMap, "reservationId", r.ReservationID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationToExchange. +func (r *ReservationToExchange) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "billingInformation": + err = unpopulate(val, "BillingInformation", &r.BillingInformation) + delete(rawMsg, key) + case "billingRefundAmount": + err = unpopulate(val, "BillingRefundAmount", &r.BillingRefundAmount) + delete(rawMsg, key) + case "quantity": + err = unpopulate(val, "Quantity", &r.Quantity) + delete(rawMsg, key) + case "reservationId": + err = unpopulate(val, "ReservationID", &r.ReservationID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationToPurchaseCalculateExchange. +func (r ReservationToPurchaseCalculateExchange) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "billingCurrencyTotal", r.BillingCurrencyTotal) + populate(objectMap, "properties", r.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationToPurchaseCalculateExchange. +func (r *ReservationToPurchaseCalculateExchange) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "billingCurrencyTotal": + err = unpopulate(val, "BillingCurrencyTotal", &r.BillingCurrencyTotal) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &r.Properties) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationToPurchaseExchange. +func (r ReservationToPurchaseExchange) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "billingCurrencyTotal", r.BillingCurrencyTotal) + populate(objectMap, "properties", r.Properties) + populate(objectMap, "reservationId", r.ReservationID) + populate(objectMap, "reservationOrderId", r.ReservationOrderID) + populate(objectMap, "status", r.Status) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationToPurchaseExchange. +func (r *ReservationToPurchaseExchange) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "billingCurrencyTotal": + err = unpopulate(val, "BillingCurrencyTotal", &r.BillingCurrencyTotal) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &r.Properties) + delete(rawMsg, key) + case "reservationId": + err = unpopulate(val, "ReservationID", &r.ReservationID) + delete(rawMsg, key) + case "reservationOrderId": + err = unpopulate(val, "ReservationOrderID", &r.ReservationOrderID) + delete(rawMsg, key) + case "status": + err = unpopulate(val, "Status", &r.Status) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationToReturn. +func (r ReservationToReturn) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "quantity", r.Quantity) + populate(objectMap, "reservationId", r.ReservationID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationToReturn. +func (r *ReservationToReturn) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "quantity": + err = unpopulate(val, "Quantity", &r.Quantity) + delete(rawMsg, key) + case "reservationId": + err = unpopulate(val, "ReservationID", &r.ReservationID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationToReturnForExchange. +func (r ReservationToReturnForExchange) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "billingInformation", r.BillingInformation) + populate(objectMap, "billingRefundAmount", r.BillingRefundAmount) + populate(objectMap, "quantity", r.Quantity) + populate(objectMap, "reservationId", r.ReservationID) + populate(objectMap, "status", r.Status) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationToReturnForExchange. +func (r *ReservationToReturnForExchange) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "billingInformation": + err = unpopulate(val, "BillingInformation", &r.BillingInformation) + delete(rawMsg, key) + case "billingRefundAmount": + err = unpopulate(val, "BillingRefundAmount", &r.BillingRefundAmount) + delete(rawMsg, key) + case "quantity": + err = unpopulate(val, "Quantity", &r.Quantity) + delete(rawMsg, key) + case "reservationId": + err = unpopulate(val, "ReservationID", &r.ReservationID) + delete(rawMsg, key) + case "status": + err = unpopulate(val, "Status", &r.Status) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReservationUtilizationAggregates. +func (r ReservationUtilizationAggregates) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "grain", r.Grain) + populate(objectMap, "grainUnit", r.GrainUnit) + populate(objectMap, "value", r.Value) + populate(objectMap, "valueUnit", r.ValueUnit) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationUtilizationAggregates. +func (r *ReservationUtilizationAggregates) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "grain": + err = unpopulate(val, "Grain", &r.Grain) + delete(rawMsg, key) + case "grainUnit": + err = unpopulate(val, "GrainUnit", &r.GrainUnit) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &r.Value) + delete(rawMsg, key) + case "valueUnit": + err = unpopulate(val, "ValueUnit", &r.ValueUnit) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ResourceName. +func (r ResourceName) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "localizedValue", r.LocalizedValue) + populate(objectMap, "value", r.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ResourceName. +func (r *ResourceName) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "localizedValue": + err = unpopulate(val, "LocalizedValue", &r.LocalizedValue) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &r.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKUCapability. +func (s SKUCapability) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "name", s.Name) + populate(objectMap, "value", s.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKUCapability. +func (s *SKUCapability) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &s.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKUName. +func (s SKUName) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "name", s.Name) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKUName. +func (s *SKUName) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKUProperty. +func (s SKUProperty) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "name", s.Name) + populate(objectMap, "value", s.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKUProperty. +func (s *SKUProperty) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &s.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SKURestriction. +func (s SKURestriction) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "reasonCode", s.ReasonCode) + populate(objectMap, "type", s.Type) + populate(objectMap, "values", s.Values) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SKURestriction. +func (s *SKURestriction) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "reasonCode": + err = unpopulate(val, "ReasonCode", &s.ReasonCode) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &s.Type) + delete(rawMsg, key) + case "values": + err = unpopulate(val, "Values", &s.Values) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ScopeProperties. +func (s ScopeProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "scope", s.Scope) + populate(objectMap, "valid", s.Valid) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ScopeProperties. +func (s *ScopeProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "scope": + err = unpopulate(val, "Scope", &s.Scope) + delete(rawMsg, key) + case "valid": + err = unpopulate(val, "Valid", &s.Valid) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ServiceError. +func (s ServiceError) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "code", s.Code) + populate(objectMap, "details", s.Details) + populate(objectMap, "message", s.Message) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ServiceError. +func (s *ServiceError) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "code": + err = unpopulate(val, "Code", &s.Code) + delete(rawMsg, key) + case "details": + err = unpopulate(val, "Details", &s.Details) + delete(rawMsg, key) + case "message": + err = unpopulate(val, "Message", &s.Message) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ServiceErrorDetail. +func (s ServiceErrorDetail) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "code", s.Code) + populate(objectMap, "message", s.Message) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ServiceErrorDetail. +func (s *ServiceErrorDetail) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "code": + err = unpopulate(val, "Code", &s.Code) + delete(rawMsg, key) + case "message": + err = unpopulate(val, "Message", &s.Message) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SplitProperties. +func (s SplitProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "quantities", s.Quantities) + populate(objectMap, "reservationId", s.ReservationID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SplitProperties. +func (s *SplitProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "quantities": + err = unpopulate(val, "Quantities", &s.Quantities) + delete(rawMsg, key) + case "reservationId": + err = unpopulate(val, "ReservationID", &s.ReservationID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SplitRequest. +func (s SplitRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "properties", s.Properties) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SplitRequest. +func (s *SplitRequest) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SubRequest. +func (s SubRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "limit", s.Limit) + populate(objectMap, "message", s.Message) + populate(objectMap, "name", s.Name) + populate(objectMap, "provisioningState", s.ProvisioningState) + populate(objectMap, "resourceType", s.ResourceType) + populate(objectMap, "subRequestId", s.SubRequestID) + populate(objectMap, "unit", s.Unit) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SubRequest. +func (s *SubRequest) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "limit": + err = unpopulate(val, "Limit", &s.Limit) + delete(rawMsg, key) + case "message": + err = unpopulate(val, "Message", &s.Message) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &s.ProvisioningState) + delete(rawMsg, key) + case "resourceType": + err = unpopulate(val, "ResourceType", &s.ResourceType) + delete(rawMsg, key) + case "subRequestId": + err = unpopulate(val, "SubRequestID", &s.SubRequestID) + delete(rawMsg, key) + case "unit": + err = unpopulate(val, "Unit", &s.Unit) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SubscriptionScopeProperties. +func (s SubscriptionScopeProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populate(objectMap, "scopes", s.Scopes) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SubscriptionScopeProperties. +func (s *SubscriptionScopeProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "scopes": + err = unpopulate(val, "Scopes", &s.Scopes) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SystemData. +func (s SystemData) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + populateTimeRFC3339(objectMap, "createdAt", s.CreatedAt) + populate(objectMap, "createdBy", s.CreatedBy) + populate(objectMap, "createdByType", s.CreatedByType) + populateTimeRFC3339(objectMap, "lastModifiedAt", s.LastModifiedAt) + populate(objectMap, "lastModifiedBy", s.LastModifiedBy) + populate(objectMap, "lastModifiedByType", s.LastModifiedByType) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SystemData. +func (s *SystemData) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "createdAt": + err = unpopulateTimeRFC3339(val, "CreatedAt", &s.CreatedAt) + delete(rawMsg, key) + case "createdBy": + err = unpopulate(val, "CreatedBy", &s.CreatedBy) + delete(rawMsg, key) + case "createdByType": + err = unpopulate(val, "CreatedByType", &s.CreatedByType) + delete(rawMsg, key) + case "lastModifiedAt": + err = unpopulateTimeRFC3339(val, "LastModifiedAt", &s.LastModifiedAt) + delete(rawMsg, key) + case "lastModifiedBy": + err = unpopulate(val, "LastModifiedBy", &s.LastModifiedBy) + delete(rawMsg, key) + case "lastModifiedByType": + err = unpopulate(val, "LastModifiedByType", &s.LastModifiedByType) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +func populate(m map[string]interface{}, k string, v interface{}) { + if v == nil { + return + } else if azcore.IsNullValue(v) { + m[k] = nil + } else if !reflect.ValueOf(v).IsNil() { + m[k] = v + } +} + +func unpopulate(data json.RawMessage, fn string, v interface{}) error { + if data == nil { + return nil + } + if err := json.Unmarshal(data, v); err != nil { + return fmt.Errorf("struct field %s: %v", fn, err) + } + return nil +} diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_operation_client.go b/sdk/resourcemanager/reservations/armreservations/operation_client.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_operation_client.go rename to sdk/resourcemanager/reservations/armreservations/operation_client.go index bd9c06cd8d5c..932f27b3108d 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_operation_client.go +++ b/sdk/resourcemanager/reservations/armreservations/operation_client.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_quota_client.go b/sdk/resourcemanager/reservations/armreservations/quota_client.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_quota_client.go rename to sdk/resourcemanager/reservations/armreservations/quota_client.go index 22fa6ad6a73d..43078e3bb8d9 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_quota_client.go +++ b/sdk/resourcemanager/reservations/armreservations/quota_client.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_quotarequeststatus_client.go b/sdk/resourcemanager/reservations/armreservations/quotarequeststatus_client.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_quotarequeststatus_client.go rename to sdk/resourcemanager/reservations/armreservations/quotarequeststatus_client.go index a10687b1c06e..a8258eebf9a7 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_quotarequeststatus_client.go +++ b/sdk/resourcemanager/reservations/armreservations/quotarequeststatus_client.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_reservation_client.go b/sdk/resourcemanager/reservations/armreservations/reservation_client.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_reservation_client.go rename to sdk/resourcemanager/reservations/armreservations/reservation_client.go index d31aaf32d249..c9111a25c12f 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_reservation_client.go +++ b/sdk/resourcemanager/reservations/armreservations/reservation_client.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_reservationorder_client.go b/sdk/resourcemanager/reservations/armreservations/reservationorder_client.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_reservationorder_client.go rename to sdk/resourcemanager/reservations/armreservations/reservationorder_client.go index ae75c4f46323..a20140b1c155 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_reservationorder_client.go +++ b/sdk/resourcemanager/reservations/armreservations/reservationorder_client.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_response_types.go b/sdk/resourcemanager/reservations/armreservations/response_types.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_response_types.go rename to sdk/resourcemanager/reservations/armreservations/response_types.go index 3e9494fd81fd..c1d61828279a 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_response_types.go +++ b/sdk/resourcemanager/reservations/armreservations/response_types.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_time_rfc3339.go b/sdk/resourcemanager/reservations/armreservations/time_rfc3339.go similarity index 99% rename from sdk/resourcemanager/reservations/armreservations/zz_generated_time_rfc3339.go rename to sdk/resourcemanager/reservations/armreservations/time_rfc3339.go index 28c96b219665..125c370e554f 100644 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_time_rfc3339.go +++ b/sdk/resourcemanager/reservations/armreservations/time_rfc3339.go @@ -5,6 +5,7 @@ // 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 armreservations diff --git a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_azurereservationapi_client_test.go b/sdk/resourcemanager/reservations/armreservations/ze_generated_example_azurereservationapi_client_test.go deleted file mode 100644 index cb76cb7d2d03..000000000000 --- a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_azurereservationapi_client_test.go +++ /dev/null @@ -1,65 +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. - -package armreservations_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/reservations/armreservations" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/GetCatalog.json -func ExampleAzureReservationAPIClient_GetCatalog() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewAzureReservationAPIClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := client.GetCatalog(ctx, - "23bc208b-083f-4901-ae85-4f98c0c3b4b6", - &armreservations.AzureReservationAPIClientGetCatalogOptions{ReservedResourceType: to.Ptr("VirtualMachines"), - Location: to.Ptr("eastus"), - PublisherID: nil, - OfferID: nil, - PlanID: nil, - }) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/GetAppliedReservations.json -func ExampleAzureReservationAPIClient_GetAppliedReservationList() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewAzureReservationAPIClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := client.GetAppliedReservationList(ctx, - "23bc208b-083f-4901-ae85-4f98c0c3b4b6", - nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // TODO: use response item - _ = res -} diff --git a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_calculateexchange_client_test.go b/sdk/resourcemanager/reservations/armreservations/ze_generated_example_calculateexchange_client_test.go deleted file mode 100644 index d2d40bef7ec6..000000000000 --- a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_calculateexchange_client_test.go +++ /dev/null @@ -1,71 +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. - -package armreservations_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/reservations/armreservations" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/CalculateExchange.json -func ExampleCalculateExchangeClient_BeginPost() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewCalculateExchangeClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := client.BeginPost(ctx, - armreservations.CalculateExchangeRequest{ - Properties: &armreservations.CalculateExchangeRequestProperties{ - ReservationsToExchange: []*armreservations.ReservationToReturn{ - { - Quantity: to.Ptr[int32](1), - ReservationID: to.Ptr("/providers/microsoft.capacity/reservationOrders/1f14354c-dc12-4c8d-8090-6f295a3a34aa/reservations/c8c926bd-fc5d-4e29-9d43-b68340ac23a6"), - }}, - ReservationsToPurchase: []*armreservations.PurchaseRequest{ - { - Location: to.Ptr("westus"), - Properties: &armreservations.PurchaseRequestProperties{ - AppliedScopeType: to.Ptr(armreservations.AppliedScopeTypeShared), - BillingPlan: to.Ptr(armreservations.ReservationBillingPlanUpfront), - BillingScopeID: to.Ptr("/subscriptions/ed3a1871-612d-abcd-a849-c2542a68be83"), - DisplayName: to.Ptr("testDisplayName"), - Quantity: to.Ptr[int32](1), - Renew: to.Ptr(false), - ReservedResourceProperties: &armreservations.PurchaseRequestPropertiesReservedResourceProperties{ - InstanceFlexibility: to.Ptr(armreservations.InstanceFlexibilityOn), - }, - ReservedResourceType: to.Ptr(armreservations.ReservedResourceTypeVirtualMachines), - Term: to.Ptr(armreservations.ReservationTermP1Y), - }, - SKU: &armreservations.SKUName{ - Name: to.Ptr("Standard_B1ls"), - }, - }}, - }, - }, - 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) - } - // TODO: use response item - _ = res -} diff --git a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_exchange_client_test.go b/sdk/resourcemanager/reservations/armreservations/ze_generated_example_exchange_client_test.go deleted file mode 100644 index 9fa93fc5e541..000000000000 --- a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_exchange_client_test.go +++ /dev/null @@ -1,47 +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. - -package armreservations_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/reservations/armreservations" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/Exchange.json -func ExampleExchangeClient_BeginPost() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewExchangeClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := client.BeginPost(ctx, - armreservations.ExchangeRequest{ - Properties: &armreservations.ExchangeRequestProperties{ - SessionID: to.Ptr("66e2ac8f-439e-4345-8235-6fef07608081"), - }, - }, - 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) - } - // TODO: use response item - _ = res -} diff --git a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_operation_client_test.go b/sdk/resourcemanager/reservations/armreservations/ze_generated_example_operation_client_test.go deleted file mode 100644 index 4081ead15252..000000000000 --- a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_operation_client_test.go +++ /dev/null @@ -1,41 +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. - -package armreservations_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/reservations/armreservations" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/GetOperations.json -func ExampleOperationClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewOperationClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := client.NewListPager(nil) - for pager.More() { - nextResult, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range nextResult.Value { - // TODO: use page item - _ = v - } - } -} diff --git a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_quota_client_test.go b/sdk/resourcemanager/reservations/armreservations/ze_generated_example_quota_client_test.go deleted file mode 100644 index 0af5d14bc15d..000000000000 --- a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_quota_client_test.go +++ /dev/null @@ -1,143 +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. - -package armreservations_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/reservations/armreservations" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2020-10-25/examples/getComputeOneSkuUsages.json -func ExampleQuotaClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewQuotaClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := client.Get(ctx, - "00000000-0000-0000-0000-000000000000", - "Microsoft.Compute", - "eastus", - "standardNDSFamily", - nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2020-10-25/examples/putComputeOneSkuQuotaRequest.json -func ExampleQuotaClient_BeginCreateOrUpdate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewQuotaClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := client.BeginCreateOrUpdate(ctx, - "D7EC67B3-7657-4966-BFFC-41EFD36BAAB3", - "Microsoft.Compute", - "eastus", - "standardFSv2Family", - armreservations.CurrentQuotaLimitBase{ - Properties: &armreservations.QuotaProperties{ - Name: &armreservations.ResourceName{ - Value: to.Ptr("standardFSv2Family"), - }, - Limit: to.Ptr[int32](200), - Unit: to.Ptr("Count"), - }, - }, - 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) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2020-10-25/examples/patchComputeQuotaRequest.json -func ExampleQuotaClient_BeginUpdate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewQuotaClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := client.BeginUpdate(ctx, - "D7EC67B3-7657-4966-BFFC-41EFD36BAAB3", - "Microsoft.Compute", - "eastus", - "standardFSv2Family", - armreservations.CurrentQuotaLimitBase{ - Properties: &armreservations.QuotaProperties{ - Name: &armreservations.ResourceName{ - Value: to.Ptr("standardFSv2Family"), - }, - Limit: to.Ptr[int32](200), - Unit: to.Ptr("Count"), - }, - }, - 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) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2020-10-25/examples/getComputeUsages.json -func ExampleQuotaClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewQuotaClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := client.NewListPager("00000000-0000-0000-0000-000000000000", - "Microsoft.Compute", - "eastus", - nil) - for pager.More() { - nextResult, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range nextResult.Value { - // TODO: use page item - _ = v - } - } -} diff --git a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_quotarequeststatus_client_test.go b/sdk/resourcemanager/reservations/armreservations/ze_generated_example_quotarequeststatus_client_test.go deleted file mode 100644 index 56fa654f683f..000000000000 --- a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_quotarequeststatus_client_test.go +++ /dev/null @@ -1,71 +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. - -package armreservations_test - -import ( - "context" - "log" - - "github.com/Azure/azure-sdk-for-go/sdk/azidentity" - "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/reservations/armreservations" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2020-10-25/examples/getQuotaRequestStatusFailed.json -func ExampleQuotaRequestStatusClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewQuotaRequestStatusClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := client.Get(ctx, - "00000000-0000-0000-0000-000000000000", - "Microsoft.Compute", - "eastus", - "2B5C8515-37D8-4B6A-879B-CD641A2CF605", - nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2020-10-25/examples/getQuotaRequestsHistory.json -func ExampleQuotaRequestStatusClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewQuotaRequestStatusClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := client.NewListPager("3f75fdf7-977e-44ad-990d-99f14f0f299f", - "Microsoft.Compute", - "eastus", - &armreservations.QuotaRequestStatusClientListOptions{Filter: nil, - Top: nil, - Skiptoken: nil, - }) - for pager.More() { - nextResult, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range nextResult.Value { - // TODO: use page item - _ = v - } - } -} diff --git a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_reservation_client_test.go b/sdk/resourcemanager/reservations/armreservations/ze_generated_example_reservation_client_test.go deleted file mode 100644 index 6996ccdeb972..000000000000 --- a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_reservation_client_test.go +++ /dev/null @@ -1,250 +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. - -package armreservations_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/reservations/armreservations" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/GetAvailableScope.json -func ExampleReservationClient_BeginAvailableScopes() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := client.BeginAvailableScopes(ctx, - "276e7ae4-84d0-4da6-ab4b-d6b94f3557da", - "356e7ae4-84d0-4da6-ab4b-d6b94f3557da", - armreservations.AvailableScopeRequest{ - Properties: &armreservations.AvailableScopeRequestProperties{ - Scopes: []*string{ - to.Ptr("/subscriptions/efc7c997-7700-4a74-b731-55aec16c15e9")}, - }, - }, - 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) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/SplitReservation.json -func ExampleReservationClient_BeginSplit() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := client.BeginSplit(ctx, - "276e7ae4-84d0-4da6-ab4b-d6b94f3557da", - armreservations.SplitRequest{ - Properties: &armreservations.SplitProperties{ - Quantities: []*int32{ - to.Ptr[int32](1), - to.Ptr[int32](2)}, - ReservationID: to.Ptr("/providers/Microsoft.Capacity/reservationOrders/276e7ae4-84d0-4da6-ab4b-d6b94f3557da/reservations/bcae77cd-3119-4766-919f-b50d36c75c7a"), - }, - }, - 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) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/MergeReservations.json -func ExampleReservationClient_BeginMerge() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := client.BeginMerge(ctx, - "276e7ae4-84d0-4da6-ab4b-d6b94f3557da", - armreservations.MergeRequest{ - Properties: &armreservations.MergeProperties{ - Sources: []*string{ - to.Ptr("/providers/Microsoft.Capacity/reservationOrders/c0565a8a-4491-4e77-b07b-5e6d66718e1c/reservations/cea04232-932e-47db-acb5-e29a945ecc73"), - to.Ptr("/providers/Microsoft.Capacity/reservationOrders/c0565a8a-4491-4e77-b07b-5e6d66718e1c/reservations/5bf54dc7-dacd-4f46-a16b-7b78f4a59799")}, - }, - }, - 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) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/GetReservationsFromOrder.json -func ExampleReservationClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := client.NewListPager("276e7ae4-84d0-4da6-ab4b-d6b94f3557da", - nil) - for pager.More() { - nextResult, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range nextResult.Value { - // TODO: use page item - _ = v - } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/GetReservationDetails.json -func ExampleReservationClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := client.Get(ctx, - "6ef59113-3482-40da-8d79-787f823e34bc", - "276e7ae4-84d0-4da6-ab4b-d6b94f3557da", - &armreservations.ReservationClientGetOptions{Expand: to.Ptr("renewProperties")}) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/UpdateReservation.json -func ExampleReservationClient_BeginUpdate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := client.BeginUpdate(ctx, - "276e7ae4-84d0-4da6-ab4b-d6b94f3557da", - "6ef59113-3482-40da-8d79-787f823e34bc", - armreservations.Patch{ - Properties: &armreservations.PatchProperties{ - AppliedScopeType: to.Ptr(armreservations.AppliedScopeTypeShared), - InstanceFlexibility: to.Ptr(armreservations.InstanceFlexibilityOff), - }, - }, - 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) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/GetReservationRevisions.json -func ExampleReservationClient_NewListRevisionsPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := client.NewListRevisionsPager("6ef59113-3482-40da-8d79-787f823e34bc", - "276e7ae4-84d0-4da6-ab4b-d6b94f3557da", - nil) - for pager.More() { - nextResult, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range nextResult.Value { - // TODO: use page item - _ = v - } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/GetReservations.json -func ExampleReservationClient_NewListAllPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := client.NewListAllPager(&armreservations.ReservationClientListAllOptions{Filter: to.Ptr("(properties%2farchived+eq+false)"), - Orderby: to.Ptr("properties/displayName asc"), - RefreshSummary: nil, - Skiptoken: to.Ptr[float32](50), - SelectedState: nil, - Take: to.Ptr[float32](1), - }) - for pager.More() { - nextResult, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range nextResult.Value { - // TODO: use page item - _ = v - } - } -} diff --git a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_reservationorder_client_test.go b/sdk/resourcemanager/reservations/armreservations/ze_generated_example_reservationorder_client_test.go deleted file mode 100644 index 7724205372ea..000000000000 --- a/sdk/resourcemanager/reservations/armreservations/ze_generated_example_reservationorder_client_test.go +++ /dev/null @@ -1,169 +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. - -package armreservations_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/reservations/armreservations" -) - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/CalculateReservationOrder.json -func ExampleReservationOrderClient_Calculate() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationOrderClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := client.Calculate(ctx, - armreservations.PurchaseRequest{ - Location: to.Ptr("westus"), - Properties: &armreservations.PurchaseRequestProperties{ - AppliedScopeType: to.Ptr(armreservations.AppliedScopeTypeShared), - BillingPlan: to.Ptr(armreservations.ReservationBillingPlanMonthly), - BillingScopeID: to.Ptr("/subscriptions/ed3a1871-612d-abcd-a849-c2542a68be83"), - DisplayName: to.Ptr("TestReservationOrder"), - Quantity: to.Ptr[int32](1), - ReservedResourceProperties: &armreservations.PurchaseRequestPropertiesReservedResourceProperties{ - InstanceFlexibility: to.Ptr(armreservations.InstanceFlexibilityOn), - }, - ReservedResourceType: to.Ptr(armreservations.ReservedResourceTypeVirtualMachines), - Term: to.Ptr(armreservations.ReservationTermP1Y), - }, - SKU: &armreservations.SKUName{ - Name: to.Ptr("standard_D1"), - }, - }, - nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/GetReservationOrders.json -func ExampleReservationOrderClient_NewListPager() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationOrderClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - pager := client.NewListPager(nil) - for pager.More() { - nextResult, err := pager.NextPage(ctx) - if err != nil { - log.Fatalf("failed to advance page: %v", err) - } - for _, v := range nextResult.Value { - // TODO: use page item - _ = v - } - } -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/PurchaseReservationOrder.json -func ExampleReservationOrderClient_BeginPurchase() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationOrderClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - poller, err := client.BeginPurchase(ctx, - "a075419f-44cc-497f-b68a-14ee811d48b9", - armreservations.PurchaseRequest{ - Location: to.Ptr("westus"), - Properties: &armreservations.PurchaseRequestProperties{ - AppliedScopeType: to.Ptr(armreservations.AppliedScopeTypeShared), - BillingPlan: to.Ptr(armreservations.ReservationBillingPlanMonthly), - BillingScopeID: to.Ptr("/subscriptions/ed3a1871-612d-abcd-a849-c2542a68be83"), - DisplayName: to.Ptr("TestReservationOrder"), - Quantity: to.Ptr[int32](1), - Renew: to.Ptr(false), - ReservedResourceProperties: &armreservations.PurchaseRequestPropertiesReservedResourceProperties{ - InstanceFlexibility: to.Ptr(armreservations.InstanceFlexibilityOn), - }, - ReservedResourceType: to.Ptr(armreservations.ReservedResourceTypeVirtualMachines), - Term: to.Ptr(armreservations.ReservationTermP1Y), - }, - SKU: &armreservations.SKUName{ - Name: to.Ptr("standard_D1"), - }, - }, - 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) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/GetReservationOrderDetails.json -func ExampleReservationOrderClient_Get() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationOrderClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := client.Get(ctx, - "a075419f-44cc-497f-b68a-14ee811d48b9", - &armreservations.ReservationOrderClientGetOptions{Expand: nil}) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // TODO: use response item - _ = res -} - -// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/reservations/resource-manager/Microsoft.Capacity/stable/2022-03-01/examples/ChangeDirectoryReservationOrder.json -func ExampleReservationOrderClient_ChangeDirectory() { - cred, err := azidentity.NewDefaultAzureCredential(nil) - if err != nil { - log.Fatalf("failed to obtain a credential: %v", err) - } - ctx := context.Background() - client, err := armreservations.NewReservationOrderClient(cred, nil) - if err != nil { - log.Fatalf("failed to create client: %v", err) - } - res, err := client.ChangeDirectory(ctx, - "a075419f-44cc-497f-b68a-14ee811d48b9", - armreservations.ChangeDirectoryRequest{ - DestinationTenantID: to.Ptr("906655ea-30be-4587-9d12-b50e077b0f32"), - }, - nil) - if err != nil { - log.Fatalf("failed to finish the request: %v", err) - } - // TODO: use response item - _ = res -} diff --git a/sdk/resourcemanager/reservations/armreservations/zz_generated_models_serde.go b/sdk/resourcemanager/reservations/armreservations/zz_generated_models_serde.go deleted file mode 100644 index 42b586e46af0..000000000000 --- a/sdk/resourcemanager/reservations/armreservations/zz_generated_models_serde.go +++ /dev/null @@ -1,428 +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. - -package armreservations - -import ( - "encoding/json" - "fmt" - "github.com/Azure/azure-sdk-for-go/sdk/azcore" - "reflect" -) - -// MarshalJSON implements the json.Marshaller interface for type AvailableScopeRequestProperties. -func (a AvailableScopeRequestProperties) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - populate(objectMap, "scopes", a.Scopes) - return json.Marshal(objectMap) -} - -// MarshalJSON implements the json.Marshaller interface for type CalculateExchangeRequestProperties. -func (c CalculateExchangeRequestProperties) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - populate(objectMap, "reservationsToExchange", c.ReservationsToExchange) - populate(objectMap, "reservationsToPurchase", c.ReservationsToPurchase) - return json.Marshal(objectMap) -} - -// MarshalJSON implements the json.Marshaller interface for type CurrentQuotaLimitBase. -func (c CurrentQuotaLimitBase) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - populate(objectMap, "id", c.ID) - populate(objectMap, "name", c.Name) - populate(objectMap, "properties", c.Properties) - populate(objectMap, "type", c.Type) - return json.Marshal(objectMap) -} - -// MarshalJSON implements the json.Marshaller interface for type MergeProperties. -func (m MergeProperties) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - populate(objectMap, "sources", m.Sources) - return json.Marshal(objectMap) -} - -// MarshalJSON implements the json.Marshaller interface for type Patch. -func (p Patch) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - populate(objectMap, "properties", p.Properties) - return json.Marshal(objectMap) -} - -// MarshalJSON implements the json.Marshaller interface for type PatchProperties. -func (p PatchProperties) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - populate(objectMap, "appliedScopeType", p.AppliedScopeType) - populate(objectMap, "appliedScopes", p.AppliedScopes) - populate(objectMap, "instanceFlexibility", p.InstanceFlexibility) - populate(objectMap, "name", p.Name) - populate(objectMap, "renew", p.Renew) - populate(objectMap, "renewProperties", p.RenewProperties) - return json.Marshal(objectMap) -} - -// UnmarshalJSON implements the json.Unmarshaller interface for type PaymentDetail. -func (p *PaymentDetail) 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 "billingAccount": - err = unpopulate(val, "BillingAccount", &p.BillingAccount) - delete(rawMsg, key) - case "billingCurrencyTotal": - err = unpopulate(val, "BillingCurrencyTotal", &p.BillingCurrencyTotal) - delete(rawMsg, key) - case "dueDate": - err = unpopulateDateType(val, "DueDate", &p.DueDate) - delete(rawMsg, key) - case "extendedStatusInfo": - err = unpopulate(val, "ExtendedStatusInfo", &p.ExtendedStatusInfo) - delete(rawMsg, key) - case "paymentDate": - err = unpopulateDateType(val, "PaymentDate", &p.PaymentDate) - delete(rawMsg, key) - case "pricingCurrencyTotal": - err = unpopulate(val, "PricingCurrencyTotal", &p.PricingCurrencyTotal) - delete(rawMsg, key) - case "status": - err = unpopulate(val, "Status", &p.Status) - delete(rawMsg, key) - } - if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", p, err) - } - } - return nil -} - -// UnmarshalJSON implements the json.Unmarshaller interface for type Properties. -func (p *Properties) 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 "appliedScopeType": - err = unpopulate(val, "AppliedScopeType", &p.AppliedScopeType) - delete(rawMsg, key) - case "appliedScopes": - err = unpopulate(val, "AppliedScopes", &p.AppliedScopes) - delete(rawMsg, key) - case "archived": - err = unpopulate(val, "Archived", &p.Archived) - delete(rawMsg, key) - case "benefitStartTime": - err = unpopulateTimeRFC3339(val, "BenefitStartTime", &p.BenefitStartTime) - delete(rawMsg, key) - case "billingPlan": - err = unpopulate(val, "BillingPlan", &p.BillingPlan) - delete(rawMsg, key) - case "billingScopeId": - err = unpopulate(val, "BillingScopeID", &p.BillingScopeID) - delete(rawMsg, key) - case "capabilities": - err = unpopulate(val, "Capabilities", &p.Capabilities) - delete(rawMsg, key) - case "displayName": - err = unpopulate(val, "DisplayName", &p.DisplayName) - delete(rawMsg, key) - case "displayProvisioningState": - err = unpopulate(val, "DisplayProvisioningState", &p.DisplayProvisioningState) - delete(rawMsg, key) - case "effectiveDateTime": - err = unpopulateTimeRFC3339(val, "EffectiveDateTime", &p.EffectiveDateTime) - delete(rawMsg, key) - case "expiryDate": - err = unpopulateDateType(val, "ExpiryDate", &p.ExpiryDate) - delete(rawMsg, key) - case "extendedStatusInfo": - err = unpopulate(val, "ExtendedStatusInfo", &p.ExtendedStatusInfo) - delete(rawMsg, key) - case "instanceFlexibility": - err = unpopulate(val, "InstanceFlexibility", &p.InstanceFlexibility) - delete(rawMsg, key) - case "lastUpdatedDateTime": - err = unpopulateTimeRFC3339(val, "LastUpdatedDateTime", &p.LastUpdatedDateTime) - delete(rawMsg, key) - case "mergeProperties": - err = unpopulate(val, "MergeProperties", &p.MergeProperties) - delete(rawMsg, key) - case "provisioningState": - err = unpopulate(val, "ProvisioningState", &p.ProvisioningState) - delete(rawMsg, key) - case "provisioningSubState": - err = unpopulate(val, "ProvisioningSubState", &p.ProvisioningSubState) - delete(rawMsg, key) - case "purchaseDate": - err = unpopulateDateType(val, "PurchaseDate", &p.PurchaseDate) - delete(rawMsg, key) - case "quantity": - err = unpopulate(val, "Quantity", &p.Quantity) - delete(rawMsg, key) - case "renew": - err = unpopulate(val, "Renew", &p.Renew) - delete(rawMsg, key) - case "renewDestination": - err = unpopulate(val, "RenewDestination", &p.RenewDestination) - delete(rawMsg, key) - case "renewProperties": - err = unpopulate(val, "RenewProperties", &p.RenewProperties) - delete(rawMsg, key) - case "renewSource": - err = unpopulate(val, "RenewSource", &p.RenewSource) - delete(rawMsg, key) - case "reservedResourceType": - err = unpopulate(val, "ReservedResourceType", &p.ReservedResourceType) - delete(rawMsg, key) - case "skuDescription": - err = unpopulate(val, "SKUDescription", &p.SKUDescription) - delete(rawMsg, key) - case "splitProperties": - err = unpopulate(val, "SplitProperties", &p.SplitProperties) - delete(rawMsg, key) - case "term": - err = unpopulate(val, "Term", &p.Term) - delete(rawMsg, key) - case "userFriendlyAppliedScopeType": - err = unpopulate(val, "UserFriendlyAppliedScopeType", &p.UserFriendlyAppliedScopeType) - delete(rawMsg, key) - case "userFriendlyRenewState": - err = unpopulate(val, "UserFriendlyRenewState", &p.UserFriendlyRenewState) - delete(rawMsg, key) - case "utilization": - err = unpopulate(val, "Utilization", &p.Utilization) - 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 PurchaseRequestProperties. -func (p PurchaseRequestProperties) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - populate(objectMap, "appliedScopeType", p.AppliedScopeType) - populate(objectMap, "appliedScopes", p.AppliedScopes) - populate(objectMap, "billingPlan", p.BillingPlan) - populate(objectMap, "billingScopeId", p.BillingScopeID) - populate(objectMap, "displayName", p.DisplayName) - populate(objectMap, "quantity", p.Quantity) - populate(objectMap, "renew", p.Renew) - populate(objectMap, "reservedResourceProperties", p.ReservedResourceProperties) - populate(objectMap, "reservedResourceType", p.ReservedResourceType) - populate(objectMap, "term", p.Term) - return json.Marshal(objectMap) -} - -// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaRequestOneResourceProperties. -func (q *QuotaRequestOneResourceProperties) 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", q, err) - } - for key, val := range rawMsg { - var err error - switch key { - case "message": - err = unpopulate(val, "Message", &q.Message) - delete(rawMsg, key) - case "properties": - err = unpopulate(val, "Properties", &q.Properties) - delete(rawMsg, key) - case "provisioningState": - err = unpopulate(val, "ProvisioningState", &q.ProvisioningState) - delete(rawMsg, key) - case "requestSubmitTime": - err = unpopulateTimeRFC3339(val, "RequestSubmitTime", &q.RequestSubmitTime) - delete(rawMsg, key) - } - if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", q, err) - } - } - return nil -} - -// UnmarshalJSON implements the json.Unmarshaller interface for type QuotaRequestProperties. -func (q *QuotaRequestProperties) 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", q, err) - } - for key, val := range rawMsg { - var err error - switch key { - case "message": - err = unpopulate(val, "Message", &q.Message) - delete(rawMsg, key) - case "provisioningState": - err = unpopulate(val, "ProvisioningState", &q.ProvisioningState) - delete(rawMsg, key) - case "requestSubmitTime": - err = unpopulateTimeRFC3339(val, "RequestSubmitTime", &q.RequestSubmitTime) - delete(rawMsg, key) - case "value": - err = unpopulate(val, "Value", &q.Value) - delete(rawMsg, key) - } - if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", q, err) - } - } - return nil -} - -// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationOrderBillingPlanInformation. -func (r *ReservationOrderBillingPlanInformation) UnmarshalJSON(data []byte) error { - var rawMsg map[string]json.RawMessage - if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", r, err) - } - for key, val := range rawMsg { - var err error - switch key { - case "nextPaymentDueDate": - err = unpopulateDateType(val, "NextPaymentDueDate", &r.NextPaymentDueDate) - delete(rawMsg, key) - case "pricingCurrencyTotal": - err = unpopulate(val, "PricingCurrencyTotal", &r.PricingCurrencyTotal) - delete(rawMsg, key) - case "startDate": - err = unpopulateDateType(val, "StartDate", &r.StartDate) - delete(rawMsg, key) - case "transactions": - err = unpopulate(val, "Transactions", &r.Transactions) - delete(rawMsg, key) - } - if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", r, err) - } - } - return nil -} - -// UnmarshalJSON implements the json.Unmarshaller interface for type ReservationOrderProperties. -func (r *ReservationOrderProperties) UnmarshalJSON(data []byte) error { - var rawMsg map[string]json.RawMessage - if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", r, err) - } - for key, val := range rawMsg { - var err error - switch key { - case "benefitStartTime": - err = unpopulateTimeRFC3339(val, "BenefitStartTime", &r.BenefitStartTime) - delete(rawMsg, key) - case "billingPlan": - err = unpopulate(val, "BillingPlan", &r.BillingPlan) - delete(rawMsg, key) - case "createdDateTime": - err = unpopulateTimeRFC3339(val, "CreatedDateTime", &r.CreatedDateTime) - delete(rawMsg, key) - case "displayName": - err = unpopulate(val, "DisplayName", &r.DisplayName) - delete(rawMsg, key) - case "expiryDate": - err = unpopulateDateType(val, "ExpiryDate", &r.ExpiryDate) - delete(rawMsg, key) - case "originalQuantity": - err = unpopulate(val, "OriginalQuantity", &r.OriginalQuantity) - delete(rawMsg, key) - case "planInformation": - err = unpopulate(val, "PlanInformation", &r.PlanInformation) - delete(rawMsg, key) - case "provisioningState": - err = unpopulate(val, "ProvisioningState", &r.ProvisioningState) - delete(rawMsg, key) - case "requestDateTime": - err = unpopulateTimeRFC3339(val, "RequestDateTime", &r.RequestDateTime) - delete(rawMsg, key) - case "reservations": - err = unpopulate(val, "Reservations", &r.Reservations) - delete(rawMsg, key) - case "term": - err = unpopulate(val, "Term", &r.Term) - delete(rawMsg, key) - } - if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", r, err) - } - } - return nil -} - -// MarshalJSON implements the json.Marshaller interface for type SplitProperties. -func (s SplitProperties) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - populate(objectMap, "quantities", s.Quantities) - populate(objectMap, "reservationId", s.ReservationID) - return json.Marshal(objectMap) -} - -// UnmarshalJSON implements the json.Unmarshaller interface for type SystemData. -func (s *SystemData) UnmarshalJSON(data []byte) error { - var rawMsg map[string]json.RawMessage - if err := json.Unmarshal(data, &rawMsg); err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) - } - for key, val := range rawMsg { - var err error - switch key { - case "createdAt": - err = unpopulateTimeRFC3339(val, "CreatedAt", &s.CreatedAt) - delete(rawMsg, key) - case "createdBy": - err = unpopulate(val, "CreatedBy", &s.CreatedBy) - delete(rawMsg, key) - case "createdByType": - err = unpopulate(val, "CreatedByType", &s.CreatedByType) - delete(rawMsg, key) - case "lastModifiedAt": - err = unpopulateTimeRFC3339(val, "LastModifiedAt", &s.LastModifiedAt) - delete(rawMsg, key) - case "lastModifiedBy": - err = unpopulate(val, "LastModifiedBy", &s.LastModifiedBy) - delete(rawMsg, key) - case "lastModifiedByType": - err = unpopulate(val, "LastModifiedByType", &s.LastModifiedByType) - delete(rawMsg, key) - } - if err != nil { - return fmt.Errorf("unmarshalling type %T: %v", s, err) - } - } - return nil -} - -func populate(m map[string]interface{}, k string, v interface{}) { - if v == nil { - return - } else if azcore.IsNullValue(v) { - m[k] = nil - } else if !reflect.ValueOf(v).IsNil() { - m[k] = v - } -} - -func unpopulate(data json.RawMessage, fn string, v interface{}) error { - if data == nil { - return nil - } - if err := json.Unmarshal(data, v); err != nil { - return fmt.Errorf("struct field %s: %v", fn, err) - } - return nil -}