ManagementClient.cs

// 
// Copyright (c) Microsoft.  All rights reserved.
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//   http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// 
// See the License for the specific language governing permissions and
// limitations under the License.
// 

// Warning: This code was generated by a tool.
// 
// Changes to this file may cause incorrect behavior and will be lost if the
// code is regenerated.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.Common;
using Microsoft.WindowsAzure.Common.Internals;
using Microsoft.WindowsAzure.Management;
using Microsoft.WindowsAzure.Management.Models;

namespace Microsoft.WindowsAzure.Management.Models
{
    /// <summary>
    /// Describes the capabilities associated with an affinity group.
    /// </summary>
    public static partial class AffinityGroupCapabilities
    {
        /// <summary>
        /// Indicates if the virtual machine related operations can be
        /// performed in this affinity group. If so, the string
        /// PersistentVMRole will be returned by this element. Otherwise, this
        /// element will not be present.
        /// </summary>
        public const string PersistentVMRole = "PersistentVMRole";
    }
    
    /// <summary>
    /// Parameters supplied to the Create Affinity Group operation.
    /// </summary>
    public partial class AffinityGroupCreateParameters
    {
        private string _description;
        
        /// <summary>
        /// Optional. A description for the affinity group. The description can
        /// be up to 1024 characters in length.
        /// </summary>
        public string Description
        {
            get { return this._description; }
            set { this._description = value; }
        }
        
        private string _label;
        
        /// <summary>
        /// Required. A base-64 encoded name for the affinity group. The name
        /// can be up to 100 characters in length.  Its value defaults to the
        /// Name of the affinity group if not provided.
        /// </summary>
        public string Label
        {
            get
            {
                if (this._label == null)
                {
                    return this.Name;
                }
                else
                {
                    return this._label;
                }
            }
            set { this._label = value; }
        }
        
        private string _location;
        
        /// <summary>
        /// Required. The data center location where the affinity group will be
        /// created. To list available locations, see the List Locations
        /// operation.
        /// </summary>
        public string Location
        {
            get { return this._location; }
            set { this._location = value; }
        }
        
        private string _name;
        
        /// <summary>
        /// Required. A name for the affinity group that is unique to the
        /// subscription.
        /// </summary>
        public string Name
        {
            get { return this._name; }
            set { this._name = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the AffinityGroupCreateParameters
        /// class.
        /// </summary>
        public AffinityGroupCreateParameters()
        {
        }
    }
    
    /// <summary>
    /// The Get Affinity Group operation response.
    /// </summary>
    public partial class AffinityGroupGetResponse : OperationResponse
    {
        private IList<string> _capabilities;
        
        /// <summary>
        /// Indicates if the virtual machine related operations can be
        /// performed in this affinity group. If so, the string
        /// PersistentVMRole will be returned by this element. Otherwise, this
        /// element will not be present.
        /// </summary>
        public IList<string> Capabilities
        {
            get { return this._capabilities; }
            set { this._capabilities = value; }
        }
        
        private string _description;
        
        /// <summary>
        /// The user supplied description of this affinity group.
        /// </summary>
        public string Description
        {
            get { return this._description; }
            set { this._description = value; }
        }
        
        private IList<AffinityGroupGetResponse.HostedServiceReference> _hostedServices;
        
        /// <summary>
        /// The hosted services associated with this affinity group.
        /// </summary>
        public IList<AffinityGroupGetResponse.HostedServiceReference> HostedServices
        {
            get { return this._hostedServices; }
            set { this._hostedServices = value; }
        }
        
        private string _label;
        
        /// <summary>
        /// The user supplied label of the affinity group returned as a base-64
        /// encoded string.
        /// </summary>
        public string Label
        {
            get { return this._label; }
            set { this._label = value; }
        }
        
        private string _location;
        
        /// <summary>
        /// The location of the data center that the affinity group is
        /// associated with.
        /// </summary>
        public string Location
        {
            get { return this._location; }
            set { this._location = value; }
        }
        
        private string _name;
        
        /// <summary>
        /// The user supplied name of the affinity group.
        /// </summary>
        public string Name
        {
            get { return this._name; }
            set { this._name = value; }
        }
        
        private IList<AffinityGroupGetResponse.StorageServiceReference> _storageServices;
        
        /// <summary>
        /// The storage services associated with this affinity group.
        /// </summary>
        public IList<AffinityGroupGetResponse.StorageServiceReference> StorageServices
        {
            get { return this._storageServices; }
            set { this._storageServices = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the AffinityGroupGetResponse class.
        /// </summary>
        public AffinityGroupGetResponse()
        {
            this._capabilities = new List<string>();
            this._hostedServices = new List<AffinityGroupGetResponse.HostedServiceReference>();
            this._storageServices = new List<AffinityGroupGetResponse.StorageServiceReference>();
        }
        
        /// <summary>
        /// Reference to a hosted service associated with an affinity group.
        /// </summary>
        public partial class HostedServiceReference
        {
            private string _serviceName;
            
            /// <summary>
            /// The name of the hosted service.
            /// </summary>
            public string ServiceName
            {
                get { return this._serviceName; }
                set { this._serviceName = value; }
            }
            
            private Uri _uri;
            
            /// <summary>
            /// The Service Management API request URI used to perform Get
            /// Hosted Service Properties requests against the hosted service.
            /// </summary>
            public Uri Uri
            {
                get { return this._uri; }
                set { this._uri = value; }
            }
            
            /// <summary>
            /// Initializes a new instance of the HostedServiceReference class.
            /// </summary>
            public HostedServiceReference()
            {
            }
        }
        
        /// <summary>
        /// Reference to a storage service associated with an affinity group.
        /// </summary>
        public partial class StorageServiceReference
        {
            private string _serviceName;
            
            /// <summary>
            /// The user supplied name of the storage account.
            /// </summary>
            public string ServiceName
            {
                get { return this._serviceName; }
                set { this._serviceName = value; }
            }
            
            private Uri _uri;
            
            /// <summary>
            /// The Service Management API request URI used to perform Get
            /// Storage Account Properties requests against the storage
            /// account.
            /// </summary>
            public Uri Uri
            {
                get { return this._uri; }
                set { this._uri = value; }
            }
            
            /// <summary>
            /// Initializes a new instance of the StorageServiceReference class.
            /// </summary>
            public StorageServiceReference()
            {
            }
        }
    }
    
    /// <summary>
    /// The List Affinity Groups operation response.
    /// </summary>
    public partial class AffinityGroupListResponse : OperationResponse, IEnumerable<AffinityGroupListResponse.AffinityGroup>
    {
        private IList<AffinityGroupListResponse.AffinityGroup> _affinityGroups;
        
        /// <summary>
        /// The affinity groups associated with the specified subscription.
        /// </summary>
        public IList<AffinityGroupListResponse.AffinityGroup> AffinityGroups
        {
            get { return this._affinityGroups; }
            set { this._affinityGroups = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the AffinityGroupListResponse class.
        /// </summary>
        public AffinityGroupListResponse()
        {
            this._affinityGroups = new List<AffinityGroupListResponse.AffinityGroup>();
        }
        
        /// <summary>
        /// Gets the sequence of AffinityGroups.
        /// </summary>
        public IEnumerator<AffinityGroupListResponse.AffinityGroup> GetEnumerator()
        {
            return this.AffinityGroups.GetEnumerator();
        }
        
        /// <summary>
        /// Gets the sequence of AffinityGroups.
        /// </summary>
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
        
        /// <summary>
        /// An affinity group associated with the specified subscription.
        /// </summary>
        public partial class AffinityGroup
        {
            private IList<string> _capabilities;
            
            /// <summary>
            /// Indicates if the affinity group is able to perform virtual
            /// machine related operations. If so, the string PersistentVMRole
            /// will be returned by this element. Otherwise, this element will
            /// not be present.
            /// </summary>
            public IList<string> Capabilities
            {
                get { return this._capabilities; }
                set { this._capabilities = value; }
            }
            
            private string _description;
            
            /// <summary>
            /// The user supplied description of this affinity group.
            /// </summary>
            public string Description
            {
                get { return this._description; }
                set { this._description = value; }
            }
            
            private string _label;
            
            /// <summary>
            /// The user supplied label of the affinity group returned as a
            /// base-64 encoded string.
            /// </summary>
            public string Label
            {
                get { return this._label; }
                set { this._label = value; }
            }
            
            private string _location;
            
            /// <summary>
            /// The user specified data center that this affinity groups is
            /// located in.
            /// </summary>
            public string Location
            {
                get { return this._location; }
                set { this._location = value; }
            }
            
            private string _name;
            
            /// <summary>
            /// The user supplied name of the affinity group.
            /// </summary>
            public string Name
            {
                get { return this._name; }
                set { this._name = value; }
            }
            
            /// <summary>
            /// Initializes a new instance of the AffinityGroup class.
            /// </summary>
            public AffinityGroup()
            {
                this._capabilities = new List<string>();
            }
        }
    }
    
    /// <summary>
    /// Parameters supplied to the Update Affinity Group operation.
    /// </summary>
    public partial class AffinityGroupUpdateParameters
    {
        private string _description;
        
        /// <summary>
        /// Optional. A description for the affinity group. The description can
        /// be up to 1024 characters in length.
        /// </summary>
        public string Description
        {
            get { return this._description; }
            set { this._description = value; }
        }
        
        private string _label;
        
        /// <summary>
        /// Required. A name for the affinity specified as a base-64 encoded
        /// string. The label can be up to 100 characters in length.
        /// </summary>
        public string Label
        {
            get { return this._label; }
            set { this._label = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the AffinityGroupUpdateParameters
        /// class.
        /// </summary>
        public AffinityGroupUpdateParameters()
        {
        }
    }
    
    /// <summary>
    /// Indicates the services available at a location.
    /// </summary>
    public static partial class LocationAvailableServiceNames
    {
        public const string Compute = "Compute";
        
        public const string Storage = "Storage";
        
        public const string PersistentVMRole = "PersistentVMRole";
        
        public const string HighMemory = "HighMemory";
    }
    
    /// <summary>
    /// Known location names for Windows Azure.  You can obtain a complete list
    /// of the latest locations available to your subscription from the List
    /// Locations Operation.
    /// </summary>
    public static partial class LocationNames
    {
        public const string WestEurope = "West Europe";
        
        public const string SoutheastAsia = "Southeast Asia";
        
        public const string EastAsia = "East Asia";
        
        public const string NorthCentralUS = "North Central US";
        
        public const string NorthEurope = "North Europe";
        
        public const string SouthCentralUS = "South Central US";
        
        public const string WestUS = "West US";
        
        public const string EastUS = "East US";
    }
    
    /// <summary>
    /// The List Locations operation response.
    /// </summary>
    public partial class LocationsListResponse : OperationResponse, IEnumerable<LocationsListResponse.Location>
    {
        private IList<LocationsListResponse.Location> _locations;
        
        /// <summary>
        /// The data center locations that are valid for your subscription.
        /// </summary>
        public IList<LocationsListResponse.Location> Locations
        {
            get { return this._locations; }
            set { this._locations = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the LocationsListResponse class.
        /// </summary>
        public LocationsListResponse()
        {
            this._locations = new List<LocationsListResponse.Location>();
        }
        
        /// <summary>
        /// Gets the sequence of Locations.
        /// </summary>
        public IEnumerator<LocationsListResponse.Location> GetEnumerator()
        {
            return this.Locations.GetEnumerator();
        }
        
        /// <summary>
        /// Gets the sequence of Locations.
        /// </summary>
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
        
        /// <summary>
        /// A data center location that is valid for your subscription.
        /// </summary>
        public partial class Location
        {
            private IList<string> _availableServices;
            
            /// <summary>
            /// Indicates the services available at a location.
            /// </summary>
            public IList<string> AvailableServices
            {
                get { return this._availableServices; }
                set { this._availableServices = value; }
            }
            
            private string _displayName;
            
            /// <summary>
            /// The localized name of data center location.
            /// </summary>
            public string DisplayName
            {
                get { return this._displayName; }
                set { this._displayName = value; }
            }
            
            private string _name;
            
            /// <summary>
            /// The name of a data center location that is valid for your
            /// subscription.
            /// </summary>
            public string Name
            {
                get { return this._name; }
                set { this._name = value; }
            }
            
            /// <summary>
            /// Initializes a new instance of the Location class.
            /// </summary>
            public Location()
            {
                this._availableServices = new List<string>();
            }
        }
    }
    
    /// <summary>
    /// Parameters supplied to the Create Management Certificate operation.
    /// </summary>
    public partial class ManagementCertificateCreateParameters
    {
        private byte[] _data;
        
        /// <summary>
        /// The certificate’s raw data in base-64 encoded .cer format.
        /// </summary>
        public byte[] Data
        {
            get { return this._data; }
            set { this._data = value; }
        }
        
        private byte[] _publicKey;
        
        /// <summary>
        /// A base64 representation of the management certificate public key.
        /// </summary>
        public byte[] PublicKey
        {
            get { return this._publicKey; }
            set { this._publicKey = value; }
        }
        
        private string _thumbprint;
        
        /// <summary>
        /// The thumb print that uniquely identifies the management certificate.
        /// </summary>
        public string Thumbprint
        {
            get { return this._thumbprint; }
            set { this._thumbprint = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the
        /// ManagementCertificateCreateParameters class.
        /// </summary>
        public ManagementCertificateCreateParameters()
        {
        }
    }
    
    /// <summary>
    /// The Get Management Certificate operation response.
    /// </summary>
    public partial class ManagementCertificateGetResponse : OperationResponse
    {
        private DateTime _created;
        
        /// <summary>
        /// The time that the management certificate was created, in UTC.
        /// </summary>
        public DateTime Created
        {
            get { return this._created; }
            set { this._created = value; }
        }
        
        private byte[] _data;
        
        /// <summary>
        /// A base64 representation of the raw data contained in the management
        /// certificate in .cer format.
        /// </summary>
        public byte[] Data
        {
            get { return this._data; }
            set { this._data = value; }
        }
        
        private byte[] _publicKey;
        
        /// <summary>
        /// A base64 representation of the management certificate public key.
        /// </summary>
        public byte[] PublicKey
        {
            get { return this._publicKey; }
            set { this._publicKey = value; }
        }
        
        private string _thumbprint;
        
        /// <summary>
        /// The thumb print that uniquely identifies the management
        /// certificate. This thumb print is the same value as the one
        /// specified by the request URI.
        /// </summary>
        public string Thumbprint
        {
            get { return this._thumbprint; }
            set { this._thumbprint = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the ManagementCertificateGetResponse
        /// class.
        /// </summary>
        public ManagementCertificateGetResponse()
        {
        }
    }
    
    /// <summary>
    /// The List Management Certificates operation response.
    /// </summary>
    public partial class ManagementCertificateListResponse : OperationResponse, IEnumerable<ManagementCertificateListResponse.SubscriptionCertificate>
    {
        private IList<ManagementCertificateListResponse.SubscriptionCertificate> _subscriptionCertificates;
        
        /// <summary>
        /// The management certificates that are valid for your subscription.
        /// </summary>
        public IList<ManagementCertificateListResponse.SubscriptionCertificate> SubscriptionCertificates
        {
            get { return this._subscriptionCertificates; }
            set { this._subscriptionCertificates = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the ManagementCertificateListResponse
        /// class.
        /// </summary>
        public ManagementCertificateListResponse()
        {
            this._subscriptionCertificates = new List<ManagementCertificateListResponse.SubscriptionCertificate>();
        }
        
        /// <summary>
        /// Gets the sequence of SubscriptionCertificates.
        /// </summary>
        public IEnumerator<ManagementCertificateListResponse.SubscriptionCertificate> GetEnumerator()
        {
            return this.SubscriptionCertificates.GetEnumerator();
        }
        
        /// <summary>
        /// Gets the sequence of SubscriptionCertificates.
        /// </summary>
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
        
        /// <summary>
        /// A management certificate that is valid for your subscription.
        /// </summary>
        public partial class SubscriptionCertificate
        {
            private DateTime _created;
            
            /// <summary>
            /// The time that the management certificate was created, in UTC.
            /// </summary>
            public DateTime Created
            {
                get { return this._created; }
                set { this._created = value; }
            }
            
            private byte[] _data;
            
            /// <summary>
            /// A base64 representation of the data contained in the management
            /// certificate, in .cer format.
            /// </summary>
            public byte[] Data
            {
                get { return this._data; }
                set { this._data = value; }
            }
            
            private byte[] _publicKey;
            
            /// <summary>
            /// A base64 representation of the management certificate public
            /// key.
            /// </summary>
            public byte[] PublicKey
            {
                get { return this._publicKey; }
                set { this._publicKey = value; }
            }
            
            private string _thumbprint;
            
            /// <summary>
            /// The X509 certificate thumb print property of the management
            /// certificate. This thumb print uniquely identifies the
            /// certificate.
            /// </summary>
            public string Thumbprint
            {
                get { return this._thumbprint; }
                set { this._thumbprint = value; }
            }
            
            /// <summary>
            /// Initializes a new instance of the SubscriptionCertificate class.
            /// </summary>
            public SubscriptionCertificate()
            {
            }
        }
    }
    
    /// <summary>
    /// The status of the asynchronous request.
    /// </summary>
    public enum OperationStatus
    {
        /// <summary>
        /// The asynchronous request is in progress.
        /// </summary>
        InProgress = 0,
        
        /// <summary>
        /// The asynchronous request succeeded.
        /// </summary>
        Succeeded = 1,
        
        /// <summary>
        /// The asynchronous request failed.
        /// </summary>
        Failed = 2,
    }
    
    /// <summary>
    /// The response body contains the status of the specified asynchronous
    /// operation, indicating whether it has succeeded, is inprogress, or has
    /// failed. Note that this status is distinct from the HTTP status code
    /// returned for the Get Operation Status operation itself.  If the
    /// asynchronous operation succeeded, the response body includes the HTTP
    /// status code for the successful request.  If the asynchronous operation
    /// failed, the response body includes the HTTP status code for the failed
    /// request, and also includes error information regarding the failure.
    /// </summary>
    public partial class OperationStatusResponse : OperationResponse
    {
        private OperationStatusResponse.ErrorDetails _error;
        
        /// <summary>
        /// If the asynchronous operation failed, the response body includes
        /// the HTTP status code for the failed request, and also includes
        /// error information regarding the failure.
        /// </summary>
        public OperationStatusResponse.ErrorDetails Error
        {
            get { return this._error; }
            set { this._error = value; }
        }
        
        private HttpStatusCode _httpStatusCode;
        
        /// <summary>
        /// The HTTP status code for the asynchronous request.
        /// </summary>
        public HttpStatusCode HttpStatusCode
        {
            get { return this._httpStatusCode; }
            set { this._httpStatusCode = value; }
        }
        
        private string _id;
        
        /// <summary>
        /// The request ID of the asynchronous request. This value is returned
        /// in the x-ms-request-id response header of the asynchronous request.
        /// </summary>
        public string Id
        {
            get { return this._id; }
            set { this._id = value; }
        }
        
        private OperationStatus _status;
        
        /// <summary>
        /// The status of the asynchronous request.
        /// </summary>
        public OperationStatus Status
        {
            get { return this._status; }
            set { this._status = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the OperationStatusResponse class.
        /// </summary>
        public OperationStatusResponse()
        {
        }
        
        /// <summary>
        /// If the asynchronous operation failed, the response body includes
        /// the HTTP status code for the failed request, and also includes
        /// error information regarding the failure.
        /// </summary>
        public partial class ErrorDetails
        {
            private string _code;
            
            /// <summary>
            /// The management service error code returned if the asynchronous
            /// request failed.
            /// </summary>
            public string Code
            {
                get { return this._code; }
                set { this._code = value; }
            }
            
            private string _message;
            
            /// <summary>
            /// The management service error message returned if the
            /// asynchronous request failed.
            /// </summary>
            public string Message
            {
                get { return this._message; }
                set { this._message = value; }
            }
            
            /// <summary>
            /// Initializes a new instance of the ErrorDetails class.
            /// </summary>
            public ErrorDetails()
            {
            }
        }
    }
    
    /// <summary>
    /// The Get Subscription operation response.
    /// </summary>
    public partial class SubscriptionGetResponse : OperationResponse
    {
        private string _accountAdminLiveEmailId;
        
        /// <summary>
        /// The live ID of the account administrator.
        /// </summary>
        public string AccountAdminLiveEmailId
        {
            get { return this._accountAdminLiveEmailId; }
            set { this._accountAdminLiveEmailId = value; }
        }
        
        private int _currentCoreCount;
        
        /// <summary>
        /// The number of currently allocated cores.
        /// </summary>
        public int CurrentCoreCount
        {
            get { return this._currentCoreCount; }
            set { this._currentCoreCount = value; }
        }
        
        private int _currentDnsServers;
        
        /// <summary>
        /// The current number of DNS servers allocated on this subscription.
        /// </summary>
        public int CurrentDnsServers
        {
            get { return this._currentDnsServers; }
            set { this._currentDnsServers = value; }
        }
        
        private int _currentHostedServices;
        
        /// <summary>
        /// The number of currently allocated cloud services.
        /// </summary>
        public int CurrentHostedServices
        {
            get { return this._currentHostedServices; }
            set { this._currentHostedServices = value; }
        }
        
        private int _currentLocalNetworkSites;
        
        /// <summary>
        /// The current number of local virtual network sites that are
        /// allocated on this subscription.
        /// </summary>
        public int CurrentLocalNetworkSites
        {
            get { return this._currentLocalNetworkSites; }
            set { this._currentLocalNetworkSites = value; }
        }
        
        private int _currentStorageAccounts;
        
        /// <summary>
        /// The number of currently allocated storage accounts.
        /// </summary>
        public int CurrentStorageAccounts
        {
            get { return this._currentStorageAccounts; }
            set { this._currentStorageAccounts = value; }
        }
        
        private int _currentVirtualNetworkSites;
        
        /// <summary>
        /// The number of currently allocated virtual network sites.
        /// </summary>
        public int CurrentVirtualNetworkSites
        {
            get { return this._currentVirtualNetworkSites; }
            set { this._currentVirtualNetworkSites = value; }
        }
        
        private int _maximumCoreCount;
        
        /// <summary>
        /// The maximum number of cores that can be allocated on this
        /// subscription.
        /// </summary>
        public int MaximumCoreCount
        {
            get { return this._maximumCoreCount; }
            set { this._maximumCoreCount = value; }
        }
        
        private int _maximumDnsServers;
        
        /// <summary>
        /// The maximum number of DNS servers that can be allocated on this
        /// subscription.
        /// </summary>
        public int MaximumDnsServers
        {
            get { return this._maximumDnsServers; }
            set { this._maximumDnsServers = value; }
        }
        
        private int _maximumHostedServices;
        
        /// <summary>
        /// The maximum number of cloud services that can be allocated on this
        /// subscription.
        /// </summary>
        public int MaximumHostedServices
        {
            get { return this._maximumHostedServices; }
            set { this._maximumHostedServices = value; }
        }
        
        private int _maximumLocalNetworkSites;
        
        /// <summary>
        /// The maximum number of local virtual network sites that can be
        /// allocated on this subscription.
        /// </summary>
        public int MaximumLocalNetworkSites
        {
            get { return this._maximumLocalNetworkSites; }
            set { this._maximumLocalNetworkSites = value; }
        }
        
        private int _maximumStorageAccounts;
        
        /// <summary>
        /// The maximum number of storage accounts that can be allocated on
        /// this subscription.
        /// </summary>
        public int MaximumStorageAccounts
        {
            get { return this._maximumStorageAccounts; }
            set { this._maximumStorageAccounts = value; }
        }
        
        private int _maximumVirtualNetworkSites;
        
        /// <summary>
        /// The maximum number of virtual network sites that can be allocated
        /// on this subscription.
        /// </summary>
        public int MaximumVirtualNetworkSites
        {
            get { return this._maximumVirtualNetworkSites; }
            set { this._maximumVirtualNetworkSites = value; }
        }
        
        private string _serviceAdminLiveEmailId;
        
        /// <summary>
        /// The live ID of the subscription administrator.
        /// </summary>
        public string ServiceAdminLiveEmailId
        {
            get { return this._serviceAdminLiveEmailId; }
            set { this._serviceAdminLiveEmailId = value; }
        }
        
        private string _subscriptionID;
        
        /// <summary>
        /// The subscription ID that the operation was called on.
        /// </summary>
        public string SubscriptionID
        {
            get { return this._subscriptionID; }
            set { this._subscriptionID = value; }
        }
        
        private string _subscriptionName;
        
        /// <summary>
        /// The user-supplied name of the subscription.
        /// </summary>
        public string SubscriptionName
        {
            get { return this._subscriptionName; }
            set { this._subscriptionName = value; }
        }
        
        private SubscriptionStatus _subscriptionStatus;
        
        /// <summary>
        /// The subscription status.
        /// </summary>
        public SubscriptionStatus SubscriptionStatus
        {
            get { return this._subscriptionStatus; }
            set { this._subscriptionStatus = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the SubscriptionGetResponse class.
        /// </summary>
        public SubscriptionGetResponse()
        {
        }
    }
    
    /// <summary>
    /// Parameters supplied to the List Subscription Operations operation.
    /// </summary>
    public partial class SubscriptionListOperationsParameters
    {
        private string _continuationToken;
        
        /// <summary>
        /// Optional. When there are too many operations to list, such as when
        /// the requested timeframe is very large, the response includes an
        /// incomplete list and a token that can be used to return the rest of
        /// the list. Subsequent requests must include this parameter to
        /// continue listing operations from where the last response left off.
        /// If no token is specified, a filter is not applied and the response
        /// will begin at the specified StartTime.
        /// </summary>
        public string ContinuationToken
        {
            get { return this._continuationToken; }
            set { this._continuationToken = value; }
        }
        
        private DateTime _endTime;
        
        /// <summary>
        /// Required. The end of the timeframe to begin listing subscription
        /// operations in UTC format. This parameter and the StartTime
        /// parameter indicate the timeframe to retrieve subscription
        /// operations.
        /// </summary>
        public DateTime EndTime
        {
            get { return this._endTime; }
            set { this._endTime = value; }
        }
        
        private string _objectIdFilter;
        
        /// <summary>
        /// Optional. Returns subscription operations only for the specified
        /// object type and object ID. This parameter must be set equal to the
        /// URL value for performing an HTTP GET on the object. If no object
        /// is specified, a filter is not applied.
        /// </summary>
        public string ObjectIdFilter
        {
            get { return this._objectIdFilter; }
            set { this._objectIdFilter = value; }
        }
        
        private Microsoft.WindowsAzure.Management.Models.OperationStatus? _operationStatus;
        
        /// <summary>
        /// Optional. Returns subscription operations only for thespecified
        /// result status, either Succeeded, Failed, or InProgress.This filter
        /// can be combined with the ObjectIdFilter to selectsubscription
        /// operations for an object with a specific resultstatus. If no
        /// result status is specified, a filter is not applied.
        /// </summary>
        public Microsoft.WindowsAzure.Management.Models.OperationStatus? OperationStatus
        {
            get { return this._operationStatus; }
            set { this._operationStatus = value; }
        }
        
        private DateTime _startTime;
        
        /// <summary>
        /// Required. The start of the timeframe to begin listingsubscription
        /// operations in UTC format. This parameter and theEndTime parameter
        /// indicate the timeframe to retrieve subscription operations. This
        /// parameter cannot indicate a start date of more than 90 days in the
        /// past.
        /// </summary>
        public DateTime StartTime
        {
            get { return this._startTime; }
            set { this._startTime = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the
        /// SubscriptionListOperationsParameters class.
        /// </summary>
        public SubscriptionListOperationsParameters()
        {
        }
    }
    
    /// <summary>
    /// The List Subscription Operations operation response.
    /// </summary>
    public partial class SubscriptionListOperationsResponse : OperationResponse
    {
        private string _continuationToken;
        
        /// <summary>
        /// The string that can be used to return the rest of the list.
        /// Subsequent requests must include this parameter to continue
        /// listing operations from where the last response left off. This
        /// element exists only if the complete list of subscription
        /// operations was not returned.
        /// </summary>
        public string ContinuationToken
        {
            get { return this._continuationToken; }
            set { this._continuationToken = value; }
        }
        
        private IList<SubscriptionListOperationsResponse.SubscriptionOperation> _subscriptionOperations;
        
        /// <summary>
        /// The list of operations that have been performed on the subscription
        /// during the specified timeframe.
        /// </summary>
        public IList<SubscriptionListOperationsResponse.SubscriptionOperation> SubscriptionOperations
        {
            get { return this._subscriptionOperations; }
            set { this._subscriptionOperations = value; }
        }
        
        /// <summary>
        /// Initializes a new instance of the
        /// SubscriptionListOperationsResponse class.
        /// </summary>
        public SubscriptionListOperationsResponse()
        {
            this._subscriptionOperations = new List<SubscriptionListOperationsResponse.SubscriptionOperation>();
        }
        
        /// <summary>
        /// A collection of attributes that identifies the source of the
        /// operation.
        /// </summary>
        public partial class OperationCallerDetails
        {
            private string _clientIPAddress;
            
            /// <summary>
            /// The IP address of the client computer that initiated the
            /// operation. This element is returned only if
            /// UsedServiceManagementApi is true.
            /// </summary>
            public string ClientIPAddress
            {
                get { return this._clientIPAddress; }
                set { this._clientIPAddress = value; }
            }
            
            private string _subscriptionCertificateThumbprint;
            
            /// <summary>
            /// The thumbprint of the subscription certificate used to initiate
            /// the operation.
            /// </summary>
            public string SubscriptionCertificateThumbprint
            {
                get { return this._subscriptionCertificateThumbprint; }
                set { this._subscriptionCertificateThumbprint = value; }
            }
            
            private bool _usedServiceManagementApi;
            
            /// <summary>
            /// Indicates whether the operation was initiated by using the
            /// Service Management API. False if it was initiated by another
            /// source, such as the Management Portal.
            /// </summary>
            public bool UsedServiceManagementApi
            {
                get { return this._usedServiceManagementApi; }
                set { this._usedServiceManagementApi = value; }
            }
            
            private string _userEmailAddress;
            
            /// <summary>
            /// The email associated with the Windows Live ID of the user who
            /// initiated the operation from the Management Portal. This
            /// element is returned only if UsedServiceManagementApi is false.
            /// </summary>
            public string UserEmailAddress
            {
                get { return this._userEmailAddress; }
                set { this._userEmailAddress = value; }
            }
            
            /// <summary>
            /// Initializes a new instance of the OperationCallerDetails class.
            /// </summary>
            public OperationCallerDetails()
            {
            }
        }
        
        /// <summary>
        /// An operation that has been performed on the subscription during the
        /// specified timeframe.
        /// </summary>
        public partial class SubscriptionOperation
        {
            private SubscriptionListOperationsResponse.OperationCallerDetails _operationCaller;
            
            /// <summary>
            /// A collection of attributes that identifies the source of the
            /// operation.
            /// </summary>
            public SubscriptionListOperationsResponse.OperationCallerDetails OperationCaller
            {
                get { return this._operationCaller; }
                set { this._operationCaller = value; }
            }
            
            private DateTime _operationCompletedTime;
            
            /// <summary>
            /// The time that the operation finished executing.
            /// </summary>
            public DateTime OperationCompletedTime
            {
                get { return this._operationCompletedTime; }
                set { this._operationCompletedTime = value; }
            }
            
            private string _operationId;
            
            /// <summary>
            /// The globally unique identifier (GUID) of the operation.
            /// </summary>
            public string OperationId
            {
                get { return this._operationId; }
                set { this._operationId = value; }
            }
            
            private string _operationName;
            
            /// <summary>
            /// The name of the performed operation.
            /// </summary>
            public string OperationName
            {
                get { return this._operationName; }
                set { this._operationName = value; }
            }
            
            private string _operationObjectId;
            
            /// <summary>
            /// The target object for the operation. This value is equal to the
            /// URL for performing an HTTP GET on the object, and corresponds
            /// to the same values for the ObjectIdFilter in the request.
            /// </summary>
            public string OperationObjectId
            {
                get { return this._operationObjectId; }
                set { this._operationObjectId = value; }
            }
            
            private IDictionary<string, string> _operationParameters;
            
            /// <summary>
            /// The collection of parameters for the performed operation.
            /// </summary>
            public IDictionary<string, string> OperationParameters
            {
                get { return this._operationParameters; }
                set { this._operationParameters = value; }
            }
            
            private DateTime _operationStartedTime;
            
            /// <summary>
            /// The time that the operation started to execute.
            /// </summary>
            public DateTime OperationStartedTime
            {
                get { return this._operationStartedTime; }
                set { this._operationStartedTime = value; }
            }
            
            private string _operationStatus;
            
            /// <summary>
            /// An object that contains information on the current status of
            /// the operation. The object returned has the following XML
            /// format: <OperationStatus>
            /// <ID>339c6c13-1f81-412f-9bc6-00e9c5876695</ID>
            /// <Status>Succeeded</Status>
            /// <HttpStatusCode>200</HttpStatusCode> </OperationStatus>
            /// Possible values of the Status element, whichholds the
            /// operation status, are: Succeeded, Failed, InProgress.
            /// </summary>
            public string OperationStatus
            {
                get { return this._operationStatus; }
                set { this._operationStatus = value; }
            }
            
            /// <summary>
            /// Initializes a new instance of the SubscriptionOperation class.
            /// </summary>
            public SubscriptionOperation()
            {
                this._operationParameters = new Dictionary<string, string>();
            }
        }
    }
    
    /// <summary>
    /// The name of a subscription operation.
    /// </summary>
    public static partial class SubscriptionOperationNames
    {
        public const string ActivateDomainName = "ActivateDomainName";
        
        public const string AddCertificates = "AddCertificates";
        
        public const string AddSubscriptionCertificate = "AddSubscriptionCertificate";
        
        public const string ChangeDeploymentConfiguration = "ChangeDeploymentConfiguration";
        
        public const string ChangeDeploymentConfigurationBySlot = "ChangeDeploymentConfigurationBySlot";
        
        public const string CommitImageUpload = "CommitImageUpload";
        
        public const string CreateAffinityGroup = "CreateAffinityGroup";
        
        public const string CreateDeployment = "CreateDeployment";
        
        public const string CreateDeploymentBySlot = "CreateDeploymentBySlot";
        
        public const string CreateHostedService = "CreateHostedService";
        
        public const string CreateStorageService = "CreateStorageService";
        
        public const string DeleteAffinityGroup = "DeleteAffinityGroup";
        
        public const string DeleteCertificate = "DeleteCertificate";
        
        public const string DeleteDeployment = "DeleteDeployment";
        
        public const string DeleteHostedService = "DeleteHostedService";
        
        public const string DeleteImage = "DeleteImage";
        
        public const string DeleteStorageService = "DeleteStorageService";
        
        public const string PrepareImageUpload = "PrepareImageUpload";
        
        public const string RebootDeploymentRoleInstance = "RebootDeploymentRoleInstance";
        
        public const string RebootDeploymentRoleInstanceBySlot = "RebootDeploymentRoleInstanceBySlot";
        
        public const string ReimageDeploymentRoleInstance = "ReimageDeploymentRoleInstance";
        
        public const string ReimageDeploymentRoleInstanceBySlot = "ReimageDeploymentRoleInstanceBySlot";
        
        public const string RegenerateStorageServiceKeys = "RegenerateStorageServiceKeys";
        
        public const string RegisterDomainName = "RegisterDomainName";
        
        public const string RemoveSubscriptionCertificate = "RemoveSubscriptionCertificate";
        
        public const string RollbackDeploymentUpdateOrUpgrade = "RollbackDeploymentUpdateOrUpgrade";
        
        public const string SetImageProperties = "SetImageProperties";
        
        public const string SetParentImage = "SetParentImage";
        
        public const string SwapDeployment = "SwapDeployment";
        
        public const string UnregisterDomainName = "UnregisterDomainName";
        
        public const string UpdateAffinityGroup = "UpdateAffinityGroup";
        
        public const string UpdateDeploymentStatus = "UpdateDeploymentStatus";
        
        public const string UpdateDeploymentStatusBySlot = "UpdateDeploymentStatusBySlot";
        
        public const string UpdateHostedService = "UpdateHostedService";
        
        public const string UpdateStorageService = "UpdateStorageService";
        
        public const string UpgradeDeployment = "UpgradeDeployment";
        
        public const string UpgradeDeploymentBySlot = "UpgradeDeploymentBySlot";
        
        public const string WalkUpgradeDomain = "WalkUpgradeDomain";
        
        public const string WalkUpgradeDomainBySlot = "WalkUpgradeDomainBySlot";
    }
    
    /// <summary>
    /// The subscription status.
    /// </summary>
    public enum SubscriptionStatus
    {
        Active = 0,
        
        Disabled = 1,
    }
}

namespace Microsoft.WindowsAzure.Management
{
    /// <summary>
    /// The Service Management API provides programmatic access to much of the
    /// functionality available through the Management Portal. The Service
    /// Management API is a REST API. All API operations are performed over
    /// SSL and mutually authenticated using X.509 v3 certificates.  (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460799.aspx for
    /// more information)
    /// </summary>
    public partial interface IManagementClient
    {
        /// <summary>
        /// The URI used as the base for all Service Management requests.
        /// </summary>
        Uri BaseUri
        {
            get; 
        }
        
        /// <summary>
        /// When you create a Windows Azure subscription, it is uniquely
        /// identified by a subscription ID. The subscription ID forms part of
        /// the URI for every call that you make to the Service Management
        /// API.  The Windows Azure Service ManagementAPI use mutual
        /// authentication of management certificates over SSL to ensure that
        /// a request made to the service is secure.  No anonymous requests
        /// are allowed.
        /// </summary>
        SubscriptionCloudCredentials Credentials
        {
            get; 
        }
        
        /// <summary>
        /// Operations for managing affinity groups beneath your subscription.
        /// (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460798.aspx
        /// for more information)
        /// </summary>
        IAffinityGroupOperations AffinityGroups
        {
            get; 
        }
        
        /// <summary>
        /// The Service Management API includes operations for listing the
        /// available data center locations for a hosted service in your
        /// subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441299.aspx
        /// for more information)
        /// </summary>
        ILocationOperations Locations
        {
            get; 
        }
        
        /// <summary>
        /// You can use management certificates, which are also known as
        /// subscription certificates, to authenticate clients attempting to
        /// connect to resources associated with your Windows Azure
        /// subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154124.aspx
        /// for more information)
        /// </summary>
        IManagementCertificateOperations ManagementCertificates
        {
            get; 
        }
        
        /// <summary>
        /// Operation for listing subscription operations and details.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715315.aspx
        /// for more information)
        /// </summary>
        ISubscriptionOperations Subscriptions
        {
            get; 
        }
        
        /// <summary>
        /// The Get Operation Status operation returns the status of
        /// thespecified operation. After calling an asynchronous operation,
        /// you can call Get Operation Status to determine whether the
        /// operation has succeeded, failed, or is still in progress.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460783.aspx
        /// for more information)
        /// </summary>
        /// <param name='requestId'>
        /// The request ID for the request you wish to track. The request ID is
        /// returned in the x-ms-request-id response header for every request.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The response body contains the status of the specified asynchronous
        /// operation, indicating whether it has succeeded, is inprogress, or
        /// has failed. Note that this status is distinct from the HTTP status
        /// code returned for the Get Operation Status operation itself.  If
        /// the asynchronous operation succeeded, the response body includes
        /// the HTTP status code for the successful request.  If the
        /// asynchronous operation failed, the response body includes the HTTP
        /// status code for the failed request, and also includes error
        /// information regarding the failure.
        /// </returns>
        Task<OperationStatusResponse> GetOperationStatusAsync(string requestId, CancellationToken cancellationToken);
    }
    
    /// <summary>
    /// The Service Management API provides programmatic access to much of the
    /// functionality available through the Management Portal. The Service
    /// Management API is a REST API. All API operations are performed over
    /// SSL and mutually authenticated using X.509 v3 certificates.  (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460799.aspx for
    /// more information)
    /// </summary>
    public static partial class ManagementClientExtensions
    {
        /// <summary>
        /// The Get Operation Status operation returns the status of
        /// thespecified operation. After calling an asynchronous operation,
        /// you can call Get Operation Status to determine whether the
        /// operation has succeeded, failed, or is still in progress.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460783.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IManagementClient.
        /// </param>
        /// <param name='requestId'>
        /// The request ID for the request you wish to track. The request ID is
        /// returned in the x-ms-request-id response header for every request.
        /// </param>
        /// <returns>
        /// The response body contains the status of the specified asynchronous
        /// operation, indicating whether it has succeeded, is inprogress, or
        /// has failed. Note that this status is distinct from the HTTP status
        /// code returned for the Get Operation Status operation itself.  If
        /// the asynchronous operation succeeded, the response body includes
        /// the HTTP status code for the successful request.  If the
        /// asynchronous operation failed, the response body includes the HTTP
        /// status code for the failed request, and also includes error
        /// information regarding the failure.
        /// </returns>
        public static OperationStatusResponse GetOperationStatus(this IManagementClient operations, string requestId)
        {
            try
            {
                return operations.GetOperationStatusAsync(requestId).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The Get Operation Status operation returns the status of
        /// thespecified operation. After calling an asynchronous operation,
        /// you can call Get Operation Status to determine whether the
        /// operation has succeeded, failed, or is still in progress.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460783.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IManagementClient.
        /// </param>
        /// <param name='requestId'>
        /// The request ID for the request you wish to track. The request ID is
        /// returned in the x-ms-request-id response header for every request.
        /// </param>
        /// <returns>
        /// The response body contains the status of the specified asynchronous
        /// operation, indicating whether it has succeeded, is inprogress, or
        /// has failed. Note that this status is distinct from the HTTP status
        /// code returned for the Get Operation Status operation itself.  If
        /// the asynchronous operation succeeded, the response body includes
        /// the HTTP status code for the successful request.  If the
        /// asynchronous operation failed, the response body includes the HTTP
        /// status code for the failed request, and also includes error
        /// information regarding the failure.
        /// </returns>
        public static Task<OperationStatusResponse> GetOperationStatusAsync(this IManagementClient operations, string requestId)
        {
            return operations.GetOperationStatusAsync(requestId, CancellationToken.None);
        }
    }
    
    /// <summary>
    /// The Service Management API provides programmatic access to much of the
    /// functionality available through the Management Portal. The Service
    /// Management API is a REST API. All API operations are performed over
    /// SSL and mutually authenticated using X.509 v3 certificates.  (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460799.aspx for
    /// more information)
    /// </summary>
    public partial class ManagementClient : ServiceClient<ManagementClient>, IManagementClient
    {
        private Uri _baseUri;
        
        /// <summary>
        /// The URI used as the base for all Service Management requests.
        /// </summary>
        public Uri BaseUri
        {
            get { return this._baseUri; }
        }
        
        private SubscriptionCloudCredentials _credentials;
        
        /// <summary>
        /// When you create a Windows Azure subscription, it is uniquely
        /// identified by a subscription ID. The subscription ID forms part of
        /// the URI for every call that you make to the Service Management
        /// API.  The Windows Azure Service ManagementAPI use mutual
        /// authentication of management certificates over SSL to ensure that
        /// a request made to the service is secure.  No anonymous requests
        /// are allowed.
        /// </summary>
        public SubscriptionCloudCredentials Credentials
        {
            get { return this._credentials; }
        }
        
        private IAffinityGroupOperations _affinityGroups;
        
        /// <summary>
        /// Operations for managing affinity groups beneath your subscription.
        /// (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460798.aspx
        /// for more information)
        /// </summary>
        public virtual IAffinityGroupOperations AffinityGroups
        {
            get { return this._affinityGroups; }
        }
        
        private ILocationOperations _locations;
        
        /// <summary>
        /// The Service Management API includes operations for listing the
        /// available data center locations for a hosted service in your
        /// subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441299.aspx
        /// for more information)
        /// </summary>
        public virtual ILocationOperations Locations
        {
            get { return this._locations; }
        }
        
        private IManagementCertificateOperations _managementCertificates;
        
        /// <summary>
        /// You can use management certificates, which are also known as
        /// subscription certificates, to authenticate clients attempting to
        /// connect to resources associated with your Windows Azure
        /// subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154124.aspx
        /// for more information)
        /// </summary>
        public virtual IManagementCertificateOperations ManagementCertificates
        {
            get { return this._managementCertificates; }
        }
        
        private ISubscriptionOperations _subscriptions;
        
        /// <summary>
        /// Operation for listing subscription operations and details.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715315.aspx
        /// for more information)
        /// </summary>
        public virtual ISubscriptionOperations Subscriptions
        {
            get { return this._subscriptions; }
        }
        
        /// <summary>
        /// Initializes a new instance of the ManagementClient class.
        /// </summary>
        private ManagementClient()
            : base()
        {
            this._affinityGroups = new AffinityGroupOperations(this);
            this._locations = new LocationOperations(this);
            this._managementCertificates = new ManagementCertificateOperations(this);
            this._subscriptions = new SubscriptionOperations(this);
            this.HttpClient.Timeout = TimeSpan.FromSeconds(300);
        }
        
        /// <summary>
        /// Initializes a new instance of the ManagementClient class.
        /// </summary>
        /// <param name='credentials'>
        /// When you create a Windows Azure subscription, it is uniquely
        /// identified by a subscription ID. The subscription ID forms part of
        /// the URI for every call that you make to the Service Management
        /// API.  The Windows Azure Service ManagementAPI use mutual
        /// authentication of management certificates over SSL to ensure that
        /// a request made to the service is secure.  No anonymous requests
        /// are allowed.
        /// </param>
        /// <param name='baseUri'>
        /// The URI used as the base for all Service Management requests.
        /// </param>
        public ManagementClient(SubscriptionCloudCredentials credentials, Uri baseUri)
            : this()
        {
            if (credentials == null)
            {
                throw new ArgumentNullException("credentials");
            }
            if (baseUri == null)
            {
                throw new ArgumentNullException("baseUri");
            }
            this._credentials = credentials;
            this._baseUri = baseUri;
            
            this.Credentials.InitializeServiceClient(this);
        }
        
        /// <summary>
        /// Initializes a new instance of the ManagementClient class.
        /// </summary>
        /// <param name='credentials'>
        /// When you create a Windows Azure subscription, it is uniquely
        /// identified by a subscription ID. The subscription ID forms part of
        /// the URI for every call that you make to the Service Management
        /// API.  The Windows Azure Service ManagementAPI use mutual
        /// authentication of management certificates over SSL to ensure that
        /// a request made to the service is secure.  No anonymous requests
        /// are allowed.
        /// </param>
        public ManagementClient(SubscriptionCloudCredentials credentials)
            : this()
        {
            if (credentials == null)
            {
                throw new ArgumentNullException("credentials");
            }
            this._credentials = credentials;
            this._baseUri = new Uri("https://management.core.windows.net");
            
            this.Credentials.InitializeServiceClient(this);
        }
        
        /// <summary>
        /// The Get Operation Status operation returns the status of
        /// thespecified operation. After calling an asynchronous operation,
        /// you can call Get Operation Status to determine whether the
        /// operation has succeeded, failed, or is still in progress.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460783.aspx
        /// for more information)
        /// </summary>
        /// <param name='requestId'>
        /// The request ID for the request you wish to track. The request ID is
        /// returned in the x-ms-request-id response header for every request.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The response body contains the status of the specified asynchronous
        /// operation, indicating whether it has succeeded, is inprogress, or
        /// has failed. Note that this status is distinct from the HTTP status
        /// code returned for the Get Operation Status operation itself.  If
        /// the asynchronous operation succeeded, the response body includes
        /// the HTTP status code for the successful request.  If the
        /// asynchronous operation failed, the response body includes the HTTP
        /// status code for the failed request, and also includes error
        /// information regarding the failure.
        /// </returns>
        public async Task<OperationStatusResponse> GetOperationStatusAsync(string requestId, CancellationToken cancellationToken)
        {
            // Validate
            if (requestId == null)
            {
                throw new ArgumentNullException("requestId");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("requestId", requestId);
                Tracing.Enter(invocationId, this, "GetOperationStatusAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.BaseUri + "/" + this.Credentials.SubscriptionId + "/operations/" + requestId;
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Get;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    OperationStatusResponse result = new OperationStatusResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    // Deserialize Response
                    cancellationToken.ThrowIfCancellationRequested();
                    string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    XDocument responseDoc = XDocument.Parse(responseContent);
                    
                    XElement operationElement = responseDoc.Element(XName.Get("Operation", "http://schemas.microsoft.com/windowsazure"));
                    if (operationElement != null)
                    {
                        XElement idElement = operationElement.Element(XName.Get("ID", "http://schemas.microsoft.com/windowsazure"));
                        if (idElement != null)
                        {
                            string idInstance = idElement.Value;
                            result.Id = idInstance;
                        }
                        
                        XElement statusElement = operationElement.Element(XName.Get("Status", "http://schemas.microsoft.com/windowsazure"));
                        if (statusElement != null)
                        {
                            OperationStatus statusInstance = (OperationStatus)Enum.Parse(typeof(OperationStatus), statusElement.Value, false);
                            result.Status = statusInstance;
                        }
                        
                        XElement httpStatusCodeElement = operationElement.Element(XName.Get("HttpStatusCode", "http://schemas.microsoft.com/windowsazure"));
                        if (httpStatusCodeElement != null)
                        {
                            HttpStatusCode httpStatusCodeInstance = (HttpStatusCode)Enum.Parse(typeof(HttpStatusCode), httpStatusCodeElement.Value, false);
                            result.HttpStatusCode = httpStatusCodeInstance;
                        }
                        
                        XElement errorElement = operationElement.Element(XName.Get("Error", "http://schemas.microsoft.com/windowsazure"));
                        if (errorElement != null)
                        {
                            OperationStatusResponse.ErrorDetails errorInstance = new OperationStatusResponse.ErrorDetails();
                            result.Error = errorInstance;
                            
                            XElement codeElement = errorElement.Element(XName.Get("Code", "http://schemas.microsoft.com/windowsazure"));
                            if (codeElement != null)
                            {
                                string codeInstance = codeElement.Value;
                                errorInstance.Code = codeInstance;
                            }
                            
                            XElement messageElement = errorElement.Element(XName.Get("Message", "http://schemas.microsoft.com/windowsazure"));
                            if (messageElement != null)
                            {
                                string messageInstance = messageElement.Value;
                                errorInstance.Message = messageInstance;
                            }
                        }
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
    }
    
    /// <summary>
    /// Operations for managing affinity groups beneath your subscription.
    /// (see http://msdn.microsoft.com/en-us/library/windowsazure/ee460798.aspx
    /// for more information)
    /// </summary>
    public partial interface IAffinityGroupOperations
    {
        /// <summary>
        /// The Create Affinity Group operation creates a new affinity group
        /// for the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715317.aspx
        /// for more information)
        /// </summary>
        /// <param name='parameters'>
        /// Parameters supplied to the Create Affinity Group operation.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        Task<OperationResponse> CreateAsync(AffinityGroupCreateParameters parameters, CancellationToken cancellationToken);
        
        /// <summary>
        /// The Delete Affinity Group operation deletes an affinity group in
        /// the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715314.aspx
        /// for more information)
        /// </summary>
        /// <param name='affinityGroupName'>
        /// The name of your affinity group.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        Task<OperationResponse> DeleteAsync(string affinityGroupName, CancellationToken cancellationToken);
        
        /// <summary>
        /// The Get Affinity Group Properties operation returns the system
        /// properties associated with the specified affinity group.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460789.aspx
        /// for more information)
        /// </summary>
        /// <param name='affinityGroupName'>
        /// The name of the desired affinity group as returned by the name
        /// element of the List Affinity Groups operation.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The Get Affinity Group operation response.
        /// </returns>
        Task<AffinityGroupGetResponse> GetAsync(string affinityGroupName, CancellationToken cancellationToken);
        
        /// <summary>
        /// The List Affinity Groups operation lists the affinity groups
        /// associated with the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460797.aspx
        /// for more information)
        /// </summary>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The List Affinity Groups operation response.
        /// </returns>
        Task<AffinityGroupListResponse> ListAsync(CancellationToken cancellationToken);
        
        /// <summary>
        /// The Update Affinity Group operation updates the label and/or the
        /// description for an affinity group for the specified subscription.
        /// (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715316.aspx
        /// for more information)
        /// </summary>
        /// <param name='affinityGroupName'>
        /// The name of your affinity group.
        /// </param>
        /// <param name='parameters'>
        /// Parameters supplied to the Update Affinity Group operation.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        Task<OperationResponse> UpdateAsync(string affinityGroupName, AffinityGroupUpdateParameters parameters, CancellationToken cancellationToken);
    }
    
    /// <summary>
    /// Operations for managing affinity groups beneath your subscription.
    /// (see http://msdn.microsoft.com/en-us/library/windowsazure/ee460798.aspx
    /// for more information)
    /// </summary>
    public static partial class AffinityGroupOperationsExtensions
    {
        /// <summary>
        /// The Create Affinity Group operation creates a new affinity group
        /// for the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715317.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IAffinityGroupOperations.
        /// </param>
        /// <param name='parameters'>
        /// Parameters supplied to the Create Affinity Group operation.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static OperationResponse Create(this IAffinityGroupOperations operations, AffinityGroupCreateParameters parameters)
        {
            try
            {
                return operations.CreateAsync(parameters).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The Create Affinity Group operation creates a new affinity group
        /// for the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715317.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IAffinityGroupOperations.
        /// </param>
        /// <param name='parameters'>
        /// Parameters supplied to the Create Affinity Group operation.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static Task<OperationResponse> CreateAsync(this IAffinityGroupOperations operations, AffinityGroupCreateParameters parameters)
        {
            return operations.CreateAsync(parameters, CancellationToken.None);
        }
        
        /// <summary>
        /// The Delete Affinity Group operation deletes an affinity group in
        /// the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715314.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IAffinityGroupOperations.
        /// </param>
        /// <param name='affinityGroupName'>
        /// The name of your affinity group.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static OperationResponse Delete(this IAffinityGroupOperations operations, string affinityGroupName)
        {
            try
            {
                return operations.DeleteAsync(affinityGroupName).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The Delete Affinity Group operation deletes an affinity group in
        /// the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715314.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IAffinityGroupOperations.
        /// </param>
        /// <param name='affinityGroupName'>
        /// The name of your affinity group.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static Task<OperationResponse> DeleteAsync(this IAffinityGroupOperations operations, string affinityGroupName)
        {
            return operations.DeleteAsync(affinityGroupName, CancellationToken.None);
        }
        
        /// <summary>
        /// The Get Affinity Group Properties operation returns the system
        /// properties associated with the specified affinity group.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460789.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IAffinityGroupOperations.
        /// </param>
        /// <param name='affinityGroupName'>
        /// The name of the desired affinity group as returned by the name
        /// element of the List Affinity Groups operation.
        /// </param>
        /// <returns>
        /// The Get Affinity Group operation response.
        /// </returns>
        public static AffinityGroupGetResponse Get(this IAffinityGroupOperations operations, string affinityGroupName)
        {
            try
            {
                return operations.GetAsync(affinityGroupName).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The Get Affinity Group Properties operation returns the system
        /// properties associated with the specified affinity group.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460789.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IAffinityGroupOperations.
        /// </param>
        /// <param name='affinityGroupName'>
        /// The name of the desired affinity group as returned by the name
        /// element of the List Affinity Groups operation.
        /// </param>
        /// <returns>
        /// The Get Affinity Group operation response.
        /// </returns>
        public static Task<AffinityGroupGetResponse> GetAsync(this IAffinityGroupOperations operations, string affinityGroupName)
        {
            return operations.GetAsync(affinityGroupName, CancellationToken.None);
        }
        
        /// <summary>
        /// The List Affinity Groups operation lists the affinity groups
        /// associated with the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460797.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IAffinityGroupOperations.
        /// </param>
        /// <returns>
        /// The List Affinity Groups operation response.
        /// </returns>
        public static AffinityGroupListResponse List(this IAffinityGroupOperations operations)
        {
            try
            {
                return operations.ListAsync().Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The List Affinity Groups operation lists the affinity groups
        /// associated with the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460797.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IAffinityGroupOperations.
        /// </param>
        /// <returns>
        /// The List Affinity Groups operation response.
        /// </returns>
        public static Task<AffinityGroupListResponse> ListAsync(this IAffinityGroupOperations operations)
        {
            return operations.ListAsync(CancellationToken.None);
        }
        
        /// <summary>
        /// The Update Affinity Group operation updates the label and/or the
        /// description for an affinity group for the specified subscription.
        /// (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715316.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IAffinityGroupOperations.
        /// </param>
        /// <param name='affinityGroupName'>
        /// The name of your affinity group.
        /// </param>
        /// <param name='parameters'>
        /// Parameters supplied to the Update Affinity Group operation.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static OperationResponse Update(this IAffinityGroupOperations operations, string affinityGroupName, AffinityGroupUpdateParameters parameters)
        {
            try
            {
                return operations.UpdateAsync(affinityGroupName, parameters).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The Update Affinity Group operation updates the label and/or the
        /// description for an affinity group for the specified subscription.
        /// (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715316.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IAffinityGroupOperations.
        /// </param>
        /// <param name='affinityGroupName'>
        /// The name of your affinity group.
        /// </param>
        /// <param name='parameters'>
        /// Parameters supplied to the Update Affinity Group operation.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static Task<OperationResponse> UpdateAsync(this IAffinityGroupOperations operations, string affinityGroupName, AffinityGroupUpdateParameters parameters)
        {
            return operations.UpdateAsync(affinityGroupName, parameters, CancellationToken.None);
        }
    }
    
    /// <summary>
    /// Operations for managing affinity groups beneath your subscription.
    /// (see http://msdn.microsoft.com/en-us/library/windowsazure/ee460798.aspx
    /// for more information)
    /// </summary>
    internal partial class AffinityGroupOperations : IServiceOperations<ManagementClient>, IAffinityGroupOperations
    {
        /// <summary>
        /// Initializes a new instance of the AffinityGroupOperations class.
        /// </summary>
        /// <param name='client'>
        /// Reference to the service client.
        /// </param>
        internal AffinityGroupOperations(ManagementClient client)
        {
            this._client = client;
        }
        
        private ManagementClient _client;
        
        /// <summary>
        /// Gets a reference to the
        /// Microsoft.WindowsAzure.Management.ManagementClient.
        /// </summary>
        public ManagementClient Client
        {
            get { return this._client; }
        }
        
        /// <summary>
        /// The Create Affinity Group operation creates a new affinity group
        /// for the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715317.aspx
        /// for more information)
        /// </summary>
        /// <param name='parameters'>
        /// Parameters supplied to the Create Affinity Group operation.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public async Task<OperationResponse> CreateAsync(AffinityGroupCreateParameters parameters, CancellationToken cancellationToken)
        {
            // Validate
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }
            if (parameters.Description != null && parameters.Description.Length > 1024)
            {
                throw new ArgumentOutOfRangeException("parameters.Description");
            }
            if (parameters.Label == null)
            {
                throw new ArgumentNullException("parameters.Label");
            }
            if (parameters.Label.Length > 100)
            {
                throw new ArgumentOutOfRangeException("parameters.Label");
            }
            if (parameters.Location == null)
            {
                throw new ArgumentNullException("parameters.Location");
            }
            if (parameters.Name == null)
            {
                throw new ArgumentNullException("parameters.Name");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("parameters", parameters);
                Tracing.Enter(invocationId, this, "CreateAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/affinitygroups";
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Post;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Serialize Request
                string requestContent = null;
                XDocument requestDoc = new XDocument();
                
                XElement createAffinityGroupElement = new XElement(XName.Get("CreateAffinityGroup", "http://schemas.microsoft.com/windowsazure"));
                requestDoc.Add(createAffinityGroupElement);
                
                XElement nameElement = new XElement(XName.Get("Name", "http://schemas.microsoft.com/windowsazure"));
                nameElement.Value = parameters.Name;
                createAffinityGroupElement.Add(nameElement);
                
                XElement labelElement = new XElement(XName.Get("Label", "http://schemas.microsoft.com/windowsazure"));
                labelElement.Value = TypeConversion.ToBase64String(parameters.Label);
                createAffinityGroupElement.Add(labelElement);
                
                if (parameters.Description != null)
                {
                    XElement descriptionElement = new XElement(XName.Get("Description", "http://schemas.microsoft.com/windowsazure"));
                    descriptionElement.Value = parameters.Description;
                    createAffinityGroupElement.Add(descriptionElement);
                }
                
                XElement locationElement = new XElement(XName.Get("Location", "http://schemas.microsoft.com/windowsazure"));
                locationElement.Value = parameters.Location;
                createAffinityGroupElement.Add(locationElement);
                
                requestContent = requestDoc.ToString();
                httpRequest.Content = new StringContent(requestContent, Encoding.UTF8);
                httpRequest.Content.Headers.ContentType = new MediaTypeHeaderValue("application/xml");
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.Created)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, requestContent, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    OperationResponse result = new OperationResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
        
        /// <summary>
        /// The Delete Affinity Group operation deletes an affinity group in
        /// the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715314.aspx
        /// for more information)
        /// </summary>
        /// <param name='affinityGroupName'>
        /// The name of your affinity group.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public async Task<OperationResponse> DeleteAsync(string affinityGroupName, CancellationToken cancellationToken)
        {
            // Validate
            if (affinityGroupName == null)
            {
                throw new ArgumentNullException("affinityGroupName");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("affinityGroupName", affinityGroupName);
                Tracing.Enter(invocationId, this, "DeleteAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/affinitygroups/" + affinityGroupName;
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Delete;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    OperationResponse result = new OperationResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
        
        /// <summary>
        /// The Get Affinity Group Properties operation returns the system
        /// properties associated with the specified affinity group.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460789.aspx
        /// for more information)
        /// </summary>
        /// <param name='affinityGroupName'>
        /// The name of the desired affinity group as returned by the name
        /// element of the List Affinity Groups operation.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The Get Affinity Group operation response.
        /// </returns>
        public async Task<AffinityGroupGetResponse> GetAsync(string affinityGroupName, CancellationToken cancellationToken)
        {
            // Validate
            if (affinityGroupName == null)
            {
                throw new ArgumentNullException("affinityGroupName");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("affinityGroupName", affinityGroupName);
                Tracing.Enter(invocationId, this, "GetAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/affinitygroups/" + affinityGroupName;
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Get;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    AffinityGroupGetResponse result = new AffinityGroupGetResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    // Deserialize Response
                    cancellationToken.ThrowIfCancellationRequested();
                    string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    XDocument responseDoc = XDocument.Parse(responseContent);
                    
                    XElement affinityGroupElement = responseDoc.Element(XName.Get("AffinityGroup", "http://schemas.microsoft.com/windowsazure"));
                    if (affinityGroupElement != null)
                    {
                        XElement nameElement = affinityGroupElement.Element(XName.Get("Name", "http://schemas.microsoft.com/windowsazure"));
                        if (nameElement != null)
                        {
                            string nameInstance = nameElement.Value;
                            result.Name = nameInstance;
                        }
                        
                        XElement labelElement = affinityGroupElement.Element(XName.Get("Label", "http://schemas.microsoft.com/windowsazure"));
                        if (labelElement != null)
                        {
                            string labelInstance = TypeConversion.FromBase64String(labelElement.Value);
                            result.Label = labelInstance;
                        }
                        
                        XElement descriptionElement = affinityGroupElement.Element(XName.Get("Description", "http://schemas.microsoft.com/windowsazure"));
                        if (descriptionElement != null)
                        {
                            string descriptionInstance = descriptionElement.Value;
                            result.Description = descriptionInstance;
                        }
                        
                        XElement locationElement = affinityGroupElement.Element(XName.Get("Location", "http://schemas.microsoft.com/windowsazure"));
                        if (locationElement != null)
                        {
                            string locationInstance = locationElement.Value;
                            result.Location = locationInstance;
                        }
                        
                        XElement hostedServicesSequenceElement = affinityGroupElement.Element(XName.Get("HostedServices", "http://schemas.microsoft.com/windowsazure"));
                        if (hostedServicesSequenceElement != null)
                        {
                            foreach (XElement hostedServicesElement in hostedServicesSequenceElement.Elements(XName.Get("HostedService", "http://schemas.microsoft.com/windowsazure")))
                            {
                                AffinityGroupGetResponse.HostedServiceReference hostedServiceInstance = new AffinityGroupGetResponse.HostedServiceReference();
                                result.HostedServices.Add(hostedServiceInstance);
                                
                                XElement urlElement = hostedServicesElement.Element(XName.Get("Url", "http://schemas.microsoft.com/windowsazure"));
                                if (urlElement != null)
                                {
                                    Uri urlInstance = TypeConversion.TryParseUri(urlElement.Value);
                                    hostedServiceInstance.Uri = urlInstance;
                                }
                                
                                XElement serviceNameElement = hostedServicesElement.Element(XName.Get("ServiceName", "http://schemas.microsoft.com/windowsazure"));
                                if (serviceNameElement != null)
                                {
                                    string serviceNameInstance = serviceNameElement.Value;
                                    hostedServiceInstance.ServiceName = serviceNameInstance;
                                }
                            }
                        }
                        
                        XElement storageServicesSequenceElement = affinityGroupElement.Element(XName.Get("StorageServices", "http://schemas.microsoft.com/windowsazure"));
                        if (storageServicesSequenceElement != null)
                        {
                            foreach (XElement storageServicesElement in storageServicesSequenceElement.Elements(XName.Get("StorageService", "http://schemas.microsoft.com/windowsazure")))
                            {
                                AffinityGroupGetResponse.StorageServiceReference storageServiceInstance = new AffinityGroupGetResponse.StorageServiceReference();
                                result.StorageServices.Add(storageServiceInstance);
                                
                                XElement urlElement2 = storageServicesElement.Element(XName.Get("Url", "http://schemas.microsoft.com/windowsazure"));
                                if (urlElement2 != null)
                                {
                                    Uri urlInstance2 = TypeConversion.TryParseUri(urlElement2.Value);
                                    storageServiceInstance.Uri = urlInstance2;
                                }
                                
                                XElement serviceNameElement2 = storageServicesElement.Element(XName.Get("ServiceName", "http://schemas.microsoft.com/windowsazure"));
                                if (serviceNameElement2 != null)
                                {
                                    string serviceNameInstance2 = serviceNameElement2.Value;
                                    storageServiceInstance.ServiceName = serviceNameInstance2;
                                }
                            }
                        }
                        
                        XElement capabilitiesSequenceElement = affinityGroupElement.Element(XName.Get("Capabilities", "http://schemas.microsoft.com/windowsazure"));
                        if (capabilitiesSequenceElement != null)
                        {
                            foreach (XElement capabilitiesElement in capabilitiesSequenceElement.Elements(XName.Get("Capability", "http://schemas.microsoft.com/windowsazure")))
                            {
                                result.Capabilities.Add(capabilitiesElement.Value);
                            }
                        }
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
        
        /// <summary>
        /// The List Affinity Groups operation lists the affinity groups
        /// associated with the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/ee460797.aspx
        /// for more information)
        /// </summary>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The List Affinity Groups operation response.
        /// </returns>
        public async Task<AffinityGroupListResponse> ListAsync(CancellationToken cancellationToken)
        {
            // Validate
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                Tracing.Enter(invocationId, this, "ListAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/affinitygroups";
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Get;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    AffinityGroupListResponse result = new AffinityGroupListResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    // Deserialize Response
                    cancellationToken.ThrowIfCancellationRequested();
                    string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    XDocument responseDoc = XDocument.Parse(responseContent);
                    
                    XElement affinityGroupsSequenceElement = responseDoc.Element(XName.Get("AffinityGroups", "http://schemas.microsoft.com/windowsazure"));
                    if (affinityGroupsSequenceElement != null)
                    {
                        foreach (XElement affinityGroupsElement in affinityGroupsSequenceElement.Elements(XName.Get("AffinityGroup", "http://schemas.microsoft.com/windowsazure")))
                        {
                            AffinityGroupListResponse.AffinityGroup affinityGroupInstance = new AffinityGroupListResponse.AffinityGroup();
                            result.AffinityGroups.Add(affinityGroupInstance);
                            
                            XElement nameElement = affinityGroupsElement.Element(XName.Get("Name", "http://schemas.microsoft.com/windowsazure"));
                            if (nameElement != null)
                            {
                                string nameInstance = nameElement.Value;
                                affinityGroupInstance.Name = nameInstance;
                            }
                            
                            XElement labelElement = affinityGroupsElement.Element(XName.Get("Label", "http://schemas.microsoft.com/windowsazure"));
                            if (labelElement != null)
                            {
                                string labelInstance = TypeConversion.FromBase64String(labelElement.Value);
                                affinityGroupInstance.Label = labelInstance;
                            }
                            
                            XElement descriptionElement = affinityGroupsElement.Element(XName.Get("Description", "http://schemas.microsoft.com/windowsazure"));
                            if (descriptionElement != null)
                            {
                                string descriptionInstance = descriptionElement.Value;
                                affinityGroupInstance.Description = descriptionInstance;
                            }
                            
                            XElement locationElement = affinityGroupsElement.Element(XName.Get("Location", "http://schemas.microsoft.com/windowsazure"));
                            if (locationElement != null)
                            {
                                string locationInstance = locationElement.Value;
                                affinityGroupInstance.Location = locationInstance;
                            }
                            
                            XElement capabilitiesSequenceElement = affinityGroupsElement.Element(XName.Get("Capabilities", "http://schemas.microsoft.com/windowsazure"));
                            if (capabilitiesSequenceElement != null)
                            {
                                foreach (XElement capabilitiesElement in capabilitiesSequenceElement.Elements(XName.Get("Capability", "http://schemas.microsoft.com/windowsazure")))
                                {
                                    affinityGroupInstance.Capabilities.Add(capabilitiesElement.Value);
                                }
                            }
                        }
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
        
        /// <summary>
        /// The Update Affinity Group operation updates the label and/or the
        /// description for an affinity group for the specified subscription.
        /// (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715316.aspx
        /// for more information)
        /// </summary>
        /// <param name='affinityGroupName'>
        /// The name of your affinity group.
        /// </param>
        /// <param name='parameters'>
        /// Parameters supplied to the Update Affinity Group operation.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public async Task<OperationResponse> UpdateAsync(string affinityGroupName, AffinityGroupUpdateParameters parameters, CancellationToken cancellationToken)
        {
            // Validate
            if (affinityGroupName == null)
            {
                throw new ArgumentNullException("affinityGroupName");
            }
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }
            if (parameters.Description != null && parameters.Description.Length > 1024)
            {
                throw new ArgumentOutOfRangeException("parameters.Description");
            }
            if (parameters.Label == null)
            {
                throw new ArgumentNullException("parameters.Label");
            }
            if (parameters.Label.Length > 100)
            {
                throw new ArgumentOutOfRangeException("parameters.Label");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("affinityGroupName", affinityGroupName);
                tracingParameters.Add("parameters", parameters);
                Tracing.Enter(invocationId, this, "UpdateAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/affinitygroups/" + affinityGroupName;
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Put;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Serialize Request
                string requestContent = null;
                XDocument requestDoc = new XDocument();
                
                XElement updateAffinityGroupElement = new XElement(XName.Get("UpdateAffinityGroup", "http://schemas.microsoft.com/windowsazure"));
                requestDoc.Add(updateAffinityGroupElement);
                
                XElement labelElement = new XElement(XName.Get("Label", "http://schemas.microsoft.com/windowsazure"));
                labelElement.Value = TypeConversion.ToBase64String(parameters.Label);
                updateAffinityGroupElement.Add(labelElement);
                
                if (parameters.Description != null)
                {
                    XElement descriptionElement = new XElement(XName.Get("Description", "http://schemas.microsoft.com/windowsazure"));
                    descriptionElement.Value = parameters.Description;
                    updateAffinityGroupElement.Add(descriptionElement);
                }
                
                requestContent = requestDoc.ToString();
                httpRequest.Content = new StringContent(requestContent, Encoding.UTF8);
                httpRequest.Content.Headers.ContentType = new MediaTypeHeaderValue("application/xml");
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, requestContent, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    OperationResponse result = new OperationResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
    }
    
    /// <summary>
    /// The Service Management API includes operations for listing the
    /// available data center locations for a hosted service in your
    /// subscription.  (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441299.aspx for
    /// more information)
    /// </summary>
    public partial interface ILocationOperations
    {
        /// <summary>
        /// The List Locations operation lists all of the data center locations
        /// that are valid for your subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441293.aspx
        /// for more information)
        /// </summary>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The List Locations operation response.
        /// </returns>
        Task<LocationsListResponse> ListAsync(CancellationToken cancellationToken);
    }
    
    /// <summary>
    /// The Service Management API includes operations for listing the
    /// available data center locations for a hosted service in your
    /// subscription.  (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441299.aspx for
    /// more information)
    /// </summary>
    public static partial class LocationOperationsExtensions
    {
        /// <summary>
        /// The List Locations operation lists all of the data center locations
        /// that are valid for your subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441293.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.ILocationOperations.
        /// </param>
        /// <returns>
        /// The List Locations operation response.
        /// </returns>
        public static LocationsListResponse List(this ILocationOperations operations)
        {
            try
            {
                return operations.ListAsync().Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The List Locations operation lists all of the data center locations
        /// that are valid for your subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441293.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.ILocationOperations.
        /// </param>
        /// <returns>
        /// The List Locations operation response.
        /// </returns>
        public static Task<LocationsListResponse> ListAsync(this ILocationOperations operations)
        {
            return operations.ListAsync(CancellationToken.None);
        }
    }
    
    /// <summary>
    /// The Service Management API includes operations for listing the
    /// available data center locations for a hosted service in your
    /// subscription.  (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441299.aspx for
    /// more information)
    /// </summary>
    internal partial class LocationOperations : IServiceOperations<ManagementClient>, ILocationOperations
    {
        /// <summary>
        /// Initializes a new instance of the LocationOperations class.
        /// </summary>
        /// <param name='client'>
        /// Reference to the service client.
        /// </param>
        internal LocationOperations(ManagementClient client)
        {
            this._client = client;
        }
        
        private ManagementClient _client;
        
        /// <summary>
        /// Gets a reference to the
        /// Microsoft.WindowsAzure.Management.ManagementClient.
        /// </summary>
        public ManagementClient Client
        {
            get { return this._client; }
        }
        
        /// <summary>
        /// The List Locations operation lists all of the data center locations
        /// that are valid for your subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg441293.aspx
        /// for more information)
        /// </summary>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The List Locations operation response.
        /// </returns>
        public async Task<LocationsListResponse> ListAsync(CancellationToken cancellationToken)
        {
            // Validate
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                Tracing.Enter(invocationId, this, "ListAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/locations";
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Get;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    LocationsListResponse result = new LocationsListResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    // Deserialize Response
                    cancellationToken.ThrowIfCancellationRequested();
                    string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    XDocument responseDoc = XDocument.Parse(responseContent);
                    
                    XElement locationsSequenceElement = responseDoc.Element(XName.Get("Locations", "http://schemas.microsoft.com/windowsazure"));
                    if (locationsSequenceElement != null)
                    {
                        foreach (XElement locationsElement in locationsSequenceElement.Elements(XName.Get("Location", "http://schemas.microsoft.com/windowsazure")))
                        {
                            LocationsListResponse.Location locationInstance = new LocationsListResponse.Location();
                            result.Locations.Add(locationInstance);
                            
                            XElement nameElement = locationsElement.Element(XName.Get("Name", "http://schemas.microsoft.com/windowsazure"));
                            if (nameElement != null)
                            {
                                string nameInstance = nameElement.Value;
                                locationInstance.Name = nameInstance;
                            }
                            
                            XElement displayNameElement = locationsElement.Element(XName.Get("DisplayName", "http://schemas.microsoft.com/windowsazure"));
                            if (displayNameElement != null)
                            {
                                string displayNameInstance = displayNameElement.Value;
                                locationInstance.DisplayName = displayNameInstance;
                            }
                            
                            XElement availableServicesSequenceElement = locationsElement.Element(XName.Get("AvailableServices", "http://schemas.microsoft.com/windowsazure"));
                            if (availableServicesSequenceElement != null)
                            {
                                foreach (XElement availableServicesElement in availableServicesSequenceElement.Elements(XName.Get("AvailableService", "http://schemas.microsoft.com/windowsazure")))
                                {
                                    locationInstance.AvailableServices.Add(availableServicesElement.Value);
                                }
                            }
                        }
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
    }
    
    /// <summary>
    /// You can use management certificates, which are also known as
    /// subscription certificates, to authenticate clients attempting to
    /// connect to resources associated with your Windows Azure subscription.
    /// (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154124.aspx for
    /// more information)
    /// </summary>
    public partial interface IManagementCertificateOperations
    {
        /// <summary>
        /// The Add Management Certificate operation adds a certificate to the
        /// list of management certificates. Management certificates, which
        /// are also known as subscription certificates, authenticate clients
        /// attempting to connect to resources associated with your Windows
        /// Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154123.aspx
        /// for more information)
        /// </summary>
        /// <param name='parameters'>
        /// Parameters supplied to the Create Management Certificate operation.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        Task<OperationResponse> CreateAsync(ManagementCertificateCreateParameters parameters, CancellationToken cancellationToken);
        
        /// <summary>
        /// The Delete Management Certificate operation deletes a certificate
        /// from the list of management certificates. Management certificates,
        /// which are also known as subscription certificates, authenticate
        /// clients attempting to connect to resources associated with your
        /// Windows Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154127.aspx
        /// for more information)
        /// </summary>
        /// <param name='thumbprint'>
        /// the thumbprint value of the certificate to delete.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        Task<OperationResponse> DeleteAsync(string thumbprint, CancellationToken cancellationToken);
        
        /// <summary>
        /// The Get Management Certificate operation retrieves information
        /// about the management certificate with the specified thumbprint.
        /// Management certificates, which are also known as subscription
        /// certificates, authenticate clients attempting to connect to
        /// resources associated with your Windows Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154131.aspx
        /// for more information)
        /// </summary>
        /// <param name='thumbprint'>
        /// The thumbprint value of the certificate to retrieve information
        /// about.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The Get Management Certificate operation response.
        /// </returns>
        Task<ManagementCertificateGetResponse> GetAsync(string thumbprint, CancellationToken cancellationToken);
        
        /// <summary>
        /// The List Management Certificates operation lists and returns basic
        /// information about all of the management certificates associated
        /// with the specified subscription. Management certificates, which
        /// are also known as subscription certificates, authenticate clients
        /// attempting to connect to resources associated with your Windows
        /// Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154105.aspx
        /// for more information)
        /// </summary>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The List Management Certificates operation response.
        /// </returns>
        Task<ManagementCertificateListResponse> ListAsync(CancellationToken cancellationToken);
    }
    
    /// <summary>
    /// You can use management certificates, which are also known as
    /// subscription certificates, to authenticate clients attempting to
    /// connect to resources associated with your Windows Azure subscription.
    /// (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154124.aspx for
    /// more information)
    /// </summary>
    public static partial class ManagementCertificateOperationsExtensions
    {
        /// <summary>
        /// The Add Management Certificate operation adds a certificate to the
        /// list of management certificates. Management certificates, which
        /// are also known as subscription certificates, authenticate clients
        /// attempting to connect to resources associated with your Windows
        /// Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154123.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IManagementCertificateOperations.
        /// </param>
        /// <param name='parameters'>
        /// Parameters supplied to the Create Management Certificate operation.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static OperationResponse Create(this IManagementCertificateOperations operations, ManagementCertificateCreateParameters parameters)
        {
            try
            {
                return operations.CreateAsync(parameters).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The Add Management Certificate operation adds a certificate to the
        /// list of management certificates. Management certificates, which
        /// are also known as subscription certificates, authenticate clients
        /// attempting to connect to resources associated with your Windows
        /// Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154123.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IManagementCertificateOperations.
        /// </param>
        /// <param name='parameters'>
        /// Parameters supplied to the Create Management Certificate operation.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static Task<OperationResponse> CreateAsync(this IManagementCertificateOperations operations, ManagementCertificateCreateParameters parameters)
        {
            return operations.CreateAsync(parameters, CancellationToken.None);
        }
        
        /// <summary>
        /// The Delete Management Certificate operation deletes a certificate
        /// from the list of management certificates. Management certificates,
        /// which are also known as subscription certificates, authenticate
        /// clients attempting to connect to resources associated with your
        /// Windows Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154127.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IManagementCertificateOperations.
        /// </param>
        /// <param name='thumbprint'>
        /// the thumbprint value of the certificate to delete.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static OperationResponse Delete(this IManagementCertificateOperations operations, string thumbprint)
        {
            try
            {
                return operations.DeleteAsync(thumbprint).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The Delete Management Certificate operation deletes a certificate
        /// from the list of management certificates. Management certificates,
        /// which are also known as subscription certificates, authenticate
        /// clients attempting to connect to resources associated with your
        /// Windows Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154127.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IManagementCertificateOperations.
        /// </param>
        /// <param name='thumbprint'>
        /// the thumbprint value of the certificate to delete.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static Task<OperationResponse> DeleteAsync(this IManagementCertificateOperations operations, string thumbprint)
        {
            return operations.DeleteAsync(thumbprint, CancellationToken.None);
        }
        
        /// <summary>
        /// The Get Management Certificate operation retrieves information
        /// about the management certificate with the specified thumbprint.
        /// Management certificates, which are also known as subscription
        /// certificates, authenticate clients attempting to connect to
        /// resources associated with your Windows Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154131.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IManagementCertificateOperations.
        /// </param>
        /// <param name='thumbprint'>
        /// The thumbprint value of the certificate to retrieve information
        /// about.
        /// </param>
        /// <returns>
        /// The Get Management Certificate operation response.
        /// </returns>
        public static ManagementCertificateGetResponse Get(this IManagementCertificateOperations operations, string thumbprint)
        {
            try
            {
                return operations.GetAsync(thumbprint).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The Get Management Certificate operation retrieves information
        /// about the management certificate with the specified thumbprint.
        /// Management certificates, which are also known as subscription
        /// certificates, authenticate clients attempting to connect to
        /// resources associated with your Windows Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154131.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IManagementCertificateOperations.
        /// </param>
        /// <param name='thumbprint'>
        /// The thumbprint value of the certificate to retrieve information
        /// about.
        /// </param>
        /// <returns>
        /// The Get Management Certificate operation response.
        /// </returns>
        public static Task<ManagementCertificateGetResponse> GetAsync(this IManagementCertificateOperations operations, string thumbprint)
        {
            return operations.GetAsync(thumbprint, CancellationToken.None);
        }
        
        /// <summary>
        /// The List Management Certificates operation lists and returns basic
        /// information about all of the management certificates associated
        /// with the specified subscription. Management certificates, which
        /// are also known as subscription certificates, authenticate clients
        /// attempting to connect to resources associated with your Windows
        /// Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154105.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IManagementCertificateOperations.
        /// </param>
        /// <returns>
        /// The List Management Certificates operation response.
        /// </returns>
        public static ManagementCertificateListResponse List(this IManagementCertificateOperations operations)
        {
            try
            {
                return operations.ListAsync().Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The List Management Certificates operation lists and returns basic
        /// information about all of the management certificates associated
        /// with the specified subscription. Management certificates, which
        /// are also known as subscription certificates, authenticate clients
        /// attempting to connect to resources associated with your Windows
        /// Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154105.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.IManagementCertificateOperations.
        /// </param>
        /// <returns>
        /// The List Management Certificates operation response.
        /// </returns>
        public static Task<ManagementCertificateListResponse> ListAsync(this IManagementCertificateOperations operations)
        {
            return operations.ListAsync(CancellationToken.None);
        }
    }
    
    /// <summary>
    /// You can use management certificates, which are also known as
    /// subscription certificates, to authenticate clients attempting to
    /// connect to resources associated with your Windows Azure subscription.
    /// (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154124.aspx for
    /// more information)
    /// </summary>
    internal partial class ManagementCertificateOperations : IServiceOperations<ManagementClient>, IManagementCertificateOperations
    {
        /// <summary>
        /// Initializes a new instance of the ManagementCertificateOperations
        /// class.
        /// </summary>
        /// <param name='client'>
        /// Reference to the service client.
        /// </param>
        internal ManagementCertificateOperations(ManagementClient client)
        {
            this._client = client;
        }
        
        private ManagementClient _client;
        
        /// <summary>
        /// Gets a reference to the
        /// Microsoft.WindowsAzure.Management.ManagementClient.
        /// </summary>
        public ManagementClient Client
        {
            get { return this._client; }
        }
        
        /// <summary>
        /// The Add Management Certificate operation adds a certificate to the
        /// list of management certificates. Management certificates, which
        /// are also known as subscription certificates, authenticate clients
        /// attempting to connect to resources associated with your Windows
        /// Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154123.aspx
        /// for more information)
        /// </summary>
        /// <param name='parameters'>
        /// Parameters supplied to the Create Management Certificate operation.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public async Task<OperationResponse> CreateAsync(ManagementCertificateCreateParameters parameters, CancellationToken cancellationToken)
        {
            // Validate
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("parameters", parameters);
                Tracing.Enter(invocationId, this, "CreateAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/certificates";
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Post;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Serialize Request
                string requestContent = null;
                XDocument requestDoc = new XDocument();
                
                XElement subscriptionCertificateElement = new XElement(XName.Get("SubscriptionCertificate", "http://schemas.microsoft.com/windowsazure"));
                requestDoc.Add(subscriptionCertificateElement);
                
                if (parameters.PublicKey != null)
                {
                    XElement subscriptionCertificatePublicKeyElement = new XElement(XName.Get("SubscriptionCertificatePublicKey", "http://schemas.microsoft.com/windowsazure"));
                    subscriptionCertificatePublicKeyElement.Value = Convert.ToBase64String(parameters.PublicKey);
                    subscriptionCertificateElement.Add(subscriptionCertificatePublicKeyElement);
                }
                
                if (parameters.Thumbprint != null)
                {
                    XElement subscriptionCertificateThumbprintElement = new XElement(XName.Get("SubscriptionCertificateThumbprint", "http://schemas.microsoft.com/windowsazure"));
                    subscriptionCertificateThumbprintElement.Value = parameters.Thumbprint;
                    subscriptionCertificateElement.Add(subscriptionCertificateThumbprintElement);
                }
                
                if (parameters.Data != null)
                {
                    XElement subscriptionCertificateDataElement = new XElement(XName.Get("SubscriptionCertificateData", "http://schemas.microsoft.com/windowsazure"));
                    subscriptionCertificateDataElement.Value = Convert.ToBase64String(parameters.Data);
                    subscriptionCertificateElement.Add(subscriptionCertificateDataElement);
                }
                
                requestContent = requestDoc.ToString();
                httpRequest.Content = new StringContent(requestContent, Encoding.UTF8);
                httpRequest.Content.Headers.ContentType = new MediaTypeHeaderValue("application/xml");
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, requestContent, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    OperationResponse result = new OperationResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
        
        /// <summary>
        /// The Delete Management Certificate operation deletes a certificate
        /// from the list of management certificates. Management certificates,
        /// which are also known as subscription certificates, authenticate
        /// clients attempting to connect to resources associated with your
        /// Windows Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154127.aspx
        /// for more information)
        /// </summary>
        /// <param name='thumbprint'>
        /// the thumbprint value of the certificate to delete.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public async Task<OperationResponse> DeleteAsync(string thumbprint, CancellationToken cancellationToken)
        {
            // Validate
            if (thumbprint == null)
            {
                throw new ArgumentNullException("thumbprint");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("thumbprint", thumbprint);
                Tracing.Enter(invocationId, this, "DeleteAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/certificates/" + thumbprint;
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Delete;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK && statusCode != HttpStatusCode.NotFound)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    OperationResponse result = new OperationResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
        
        /// <summary>
        /// The Get Management Certificate operation retrieves information
        /// about the management certificate with the specified thumbprint.
        /// Management certificates, which are also known as subscription
        /// certificates, authenticate clients attempting to connect to
        /// resources associated with your Windows Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154131.aspx
        /// for more information)
        /// </summary>
        /// <param name='thumbprint'>
        /// The thumbprint value of the certificate to retrieve information
        /// about.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The Get Management Certificate operation response.
        /// </returns>
        public async Task<ManagementCertificateGetResponse> GetAsync(string thumbprint, CancellationToken cancellationToken)
        {
            // Validate
            if (thumbprint == null)
            {
                throw new ArgumentNullException("thumbprint");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("thumbprint", thumbprint);
                Tracing.Enter(invocationId, this, "GetAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/certificates/" + thumbprint;
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Get;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    ManagementCertificateGetResponse result = new ManagementCertificateGetResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    // Deserialize Response
                    cancellationToken.ThrowIfCancellationRequested();
                    string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    XDocument responseDoc = XDocument.Parse(responseContent);
                    
                    XElement subscriptionCertificateElement = responseDoc.Element(XName.Get("SubscriptionCertificate", "http://schemas.microsoft.com/windowsazure"));
                    if (subscriptionCertificateElement != null)
                    {
                        XElement subscriptionCertificatePublicKeyElement = subscriptionCertificateElement.Element(XName.Get("SubscriptionCertificatePublicKey", "http://schemas.microsoft.com/windowsazure"));
                        if (subscriptionCertificatePublicKeyElement != null)
                        {
                            byte[] subscriptionCertificatePublicKeyInstance = Convert.FromBase64String(subscriptionCertificatePublicKeyElement.Value);
                            result.PublicKey = subscriptionCertificatePublicKeyInstance;
                        }
                        
                        XElement subscriptionCertificateThumbprintElement = subscriptionCertificateElement.Element(XName.Get("SubscriptionCertificateThumbprint", "http://schemas.microsoft.com/windowsazure"));
                        if (subscriptionCertificateThumbprintElement != null)
                        {
                            string subscriptionCertificateThumbprintInstance = subscriptionCertificateThumbprintElement.Value;
                            result.Thumbprint = subscriptionCertificateThumbprintInstance;
                        }
                        
                        XElement subscriptionCertificateDataElement = subscriptionCertificateElement.Element(XName.Get("SubscriptionCertificateData", "http://schemas.microsoft.com/windowsazure"));
                        if (subscriptionCertificateDataElement != null)
                        {
                            byte[] subscriptionCertificateDataInstance = Convert.FromBase64String(subscriptionCertificateDataElement.Value);
                            result.Data = subscriptionCertificateDataInstance;
                        }
                        
                        XElement createdElement = subscriptionCertificateElement.Element(XName.Get("Created", "http://schemas.microsoft.com/windowsazure"));
                        if (createdElement != null)
                        {
                            DateTime createdInstance = DateTime.Parse(createdElement.Value, CultureInfo.InvariantCulture);
                            result.Created = createdInstance;
                        }
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
        
        /// <summary>
        /// The List Management Certificates operation lists and returns basic
        /// information about all of the management certificates associated
        /// with the specified subscription. Management certificates, which
        /// are also known as subscription certificates, authenticate clients
        /// attempting to connect to resources associated with your Windows
        /// Azure subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/jj154105.aspx
        /// for more information)
        /// </summary>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The List Management Certificates operation response.
        /// </returns>
        public async Task<ManagementCertificateListResponse> ListAsync(CancellationToken cancellationToken)
        {
            // Validate
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                Tracing.Enter(invocationId, this, "ListAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/certificates";
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Get;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    ManagementCertificateListResponse result = new ManagementCertificateListResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    // Deserialize Response
                    cancellationToken.ThrowIfCancellationRequested();
                    string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    XDocument responseDoc = XDocument.Parse(responseContent);
                    
                    XElement subscriptionCertificatesSequenceElement = responseDoc.Element(XName.Get("SubscriptionCertificates", "http://schemas.microsoft.com/windowsazure"));
                    if (subscriptionCertificatesSequenceElement != null)
                    {
                        foreach (XElement subscriptionCertificatesElement in subscriptionCertificatesSequenceElement.Elements(XName.Get("SubscriptionCertificate", "http://schemas.microsoft.com/windowsazure")))
                        {
                            ManagementCertificateListResponse.SubscriptionCertificate subscriptionCertificateInstance = new ManagementCertificateListResponse.SubscriptionCertificate();
                            result.SubscriptionCertificates.Add(subscriptionCertificateInstance);
                            
                            XElement subscriptionCertificatePublicKeyElement = subscriptionCertificatesElement.Element(XName.Get("SubscriptionCertificatePublicKey", "http://schemas.microsoft.com/windowsazure"));
                            if (subscriptionCertificatePublicKeyElement != null)
                            {
                                byte[] subscriptionCertificatePublicKeyInstance = Convert.FromBase64String(subscriptionCertificatePublicKeyElement.Value);
                                subscriptionCertificateInstance.PublicKey = subscriptionCertificatePublicKeyInstance;
                            }
                            
                            XElement subscriptionCertificateThumbprintElement = subscriptionCertificatesElement.Element(XName.Get("SubscriptionCertificateThumbprint", "http://schemas.microsoft.com/windowsazure"));
                            if (subscriptionCertificateThumbprintElement != null)
                            {
                                string subscriptionCertificateThumbprintInstance = subscriptionCertificateThumbprintElement.Value;
                                subscriptionCertificateInstance.Thumbprint = subscriptionCertificateThumbprintInstance;
                            }
                            
                            XElement subscriptionCertificateDataElement = subscriptionCertificatesElement.Element(XName.Get("SubscriptionCertificateData", "http://schemas.microsoft.com/windowsazure"));
                            if (subscriptionCertificateDataElement != null)
                            {
                                byte[] subscriptionCertificateDataInstance = Convert.FromBase64String(subscriptionCertificateDataElement.Value);
                                subscriptionCertificateInstance.Data = subscriptionCertificateDataInstance;
                            }
                            
                            XElement createdElement = subscriptionCertificatesElement.Element(XName.Get("Created", "http://schemas.microsoft.com/windowsazure"));
                            if (createdElement != null)
                            {
                                DateTime createdInstance = DateTime.Parse(createdElement.Value, CultureInfo.InvariantCulture);
                                subscriptionCertificateInstance.Created = createdInstance;
                            }
                        }
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
    }
    
    /// <summary>
    /// Operation for listing subscription operations and details.  (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715315.aspx for
    /// more information)
    /// </summary>
    public partial interface ISubscriptionOperations
    {
        /// <summary>
        /// The Get Subscription operation returns account and resource
        /// allocation information on the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/hh403995.aspx
        /// for more information)
        /// </summary>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The Get Subscription operation response.
        /// </returns>
        Task<SubscriptionGetResponse> GetAsync(CancellationToken cancellationToken);
        
        /// <summary>
        /// The List Subscription Operations operation returns a list of
        /// create, update, and delete operations that were performed on a
        /// subscription during the specified timeframe.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715318.aspx
        /// for more information)
        /// </summary>
        /// <param name='parameters'>
        /// Parameters supplied to the List Subscription Operations operation.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The List Subscription Operations operation response.
        /// </returns>
        Task<SubscriptionListOperationsResponse> ListOperationsAsync(SubscriptionListOperationsParameters parameters, CancellationToken cancellationToken);
        
        /// <summary>
        /// Register a resource with your subscription.
        /// </summary>
        /// <param name='resourceName'>
        /// Name of the resource to register.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        Task<OperationResponse> RegisterResourceAsync(string resourceName, CancellationToken cancellationToken);
        
        /// <summary>
        /// Unregister a resource with your subscription.
        /// </summary>
        /// <param name='resourceName'>
        /// Name of the resource to unregister.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        Task<OperationResponse> UnregisterResourceAsync(string resourceName, CancellationToken cancellationToken);
    }
    
    /// <summary>
    /// Operation for listing subscription operations and details.  (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715315.aspx for
    /// more information)
    /// </summary>
    public static partial class SubscriptionOperationsExtensions
    {
        /// <summary>
        /// The Get Subscription operation returns account and resource
        /// allocation information on the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/hh403995.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.ISubscriptionOperations.
        /// </param>
        /// <returns>
        /// The Get Subscription operation response.
        /// </returns>
        public static SubscriptionGetResponse Get(this ISubscriptionOperations operations)
        {
            try
            {
                return operations.GetAsync().Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The Get Subscription operation returns account and resource
        /// allocation information on the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/hh403995.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.ISubscriptionOperations.
        /// </param>
        /// <returns>
        /// The Get Subscription operation response.
        /// </returns>
        public static Task<SubscriptionGetResponse> GetAsync(this ISubscriptionOperations operations)
        {
            return operations.GetAsync(CancellationToken.None);
        }
        
        /// <summary>
        /// The List Subscription Operations operation returns a list of
        /// create, update, and delete operations that were performed on a
        /// subscription during the specified timeframe.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715318.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.ISubscriptionOperations.
        /// </param>
        /// <param name='parameters'>
        /// Parameters supplied to the List Subscription Operations operation.
        /// </param>
        /// <returns>
        /// The List Subscription Operations operation response.
        /// </returns>
        public static SubscriptionListOperationsResponse ListOperations(this ISubscriptionOperations operations, SubscriptionListOperationsParameters parameters)
        {
            try
            {
                return operations.ListOperationsAsync(parameters).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// The List Subscription Operations operation returns a list of
        /// create, update, and delete operations that were performed on a
        /// subscription during the specified timeframe.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715318.aspx
        /// for more information)
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.ISubscriptionOperations.
        /// </param>
        /// <param name='parameters'>
        /// Parameters supplied to the List Subscription Operations operation.
        /// </param>
        /// <returns>
        /// The List Subscription Operations operation response.
        /// </returns>
        public static Task<SubscriptionListOperationsResponse> ListOperationsAsync(this ISubscriptionOperations operations, SubscriptionListOperationsParameters parameters)
        {
            return operations.ListOperationsAsync(parameters, CancellationToken.None);
        }
        
        /// <summary>
        /// Register a resource with your subscription.
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.ISubscriptionOperations.
        /// </param>
        /// <param name='resourceName'>
        /// Name of the resource to register.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static OperationResponse RegisterResource(this ISubscriptionOperations operations, string resourceName)
        {
            try
            {
                return operations.RegisterResourceAsync(resourceName).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// Register a resource with your subscription.
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.ISubscriptionOperations.
        /// </param>
        /// <param name='resourceName'>
        /// Name of the resource to register.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static Task<OperationResponse> RegisterResourceAsync(this ISubscriptionOperations operations, string resourceName)
        {
            return operations.RegisterResourceAsync(resourceName, CancellationToken.None);
        }
        
        /// <summary>
        /// Unregister a resource with your subscription.
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.ISubscriptionOperations.
        /// </param>
        /// <param name='resourceName'>
        /// Name of the resource to unregister.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static OperationResponse UnregisterResource(this ISubscriptionOperations operations, string resourceName)
        {
            try
            {
                return operations.UnregisterResourceAsync(resourceName).Result;
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count > 1)
                {
                    throw;
                }
                else
                {
                    throw ex.InnerException;
                }
            }
        }
        
        /// <summary>
        /// Unregister a resource with your subscription.
        /// </summary>
        /// <param name='operations'>
        /// Reference to the
        /// Microsoft.WindowsAzure.Management.ISubscriptionOperations.
        /// </param>
        /// <param name='resourceName'>
        /// Name of the resource to unregister.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public static Task<OperationResponse> UnregisterResourceAsync(this ISubscriptionOperations operations, string resourceName)
        {
            return operations.UnregisterResourceAsync(resourceName, CancellationToken.None);
        }
    }
    
    /// <summary>
    /// Operation for listing subscription operations and details.  (see
    /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715315.aspx for
    /// more information)
    /// </summary>
    internal partial class SubscriptionOperations : IServiceOperations<ManagementClient>, ISubscriptionOperations
    {
        /// <summary>
        /// Initializes a new instance of the SubscriptionOperations class.
        /// </summary>
        /// <param name='client'>
        /// Reference to the service client.
        /// </param>
        internal SubscriptionOperations(ManagementClient client)
        {
            this._client = client;
        }
        
        private ManagementClient _client;
        
        /// <summary>
        /// Gets a reference to the
        /// Microsoft.WindowsAzure.Management.ManagementClient.
        /// </summary>
        public ManagementClient Client
        {
            get { return this._client; }
        }
        
        /// <summary>
        /// The Get Subscription operation returns account and resource
        /// allocation information on the specified subscription.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/hh403995.aspx
        /// for more information)
        /// </summary>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The Get Subscription operation response.
        /// </returns>
        public async Task<SubscriptionGetResponse> GetAsync(CancellationToken cancellationToken)
        {
            // Validate
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                Tracing.Enter(invocationId, this, "GetAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId;
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Get;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    SubscriptionGetResponse result = new SubscriptionGetResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    // Deserialize Response
                    cancellationToken.ThrowIfCancellationRequested();
                    string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    XDocument responseDoc = XDocument.Parse(responseContent);
                    
                    XElement subscriptionElement = responseDoc.Element(XName.Get("Subscription", "http://schemas.microsoft.com/windowsazure"));
                    if (subscriptionElement != null)
                    {
                        XElement subscriptionIDElement = subscriptionElement.Element(XName.Get("SubscriptionID", "http://schemas.microsoft.com/windowsazure"));
                        if (subscriptionIDElement != null)
                        {
                            string subscriptionIDInstance = subscriptionIDElement.Value;
                            result.SubscriptionID = subscriptionIDInstance;
                        }
                        
                        XElement subscriptionNameElement = subscriptionElement.Element(XName.Get("SubscriptionName", "http://schemas.microsoft.com/windowsazure"));
                        if (subscriptionNameElement != null)
                        {
                            string subscriptionNameInstance = subscriptionNameElement.Value;
                            result.SubscriptionName = subscriptionNameInstance;
                        }
                        
                        XElement subscriptionStatusElement = subscriptionElement.Element(XName.Get("SubscriptionStatus", "http://schemas.microsoft.com/windowsazure"));
                        if (subscriptionStatusElement != null)
                        {
                            SubscriptionStatus subscriptionStatusInstance = (SubscriptionStatus)Enum.Parse(typeof(SubscriptionStatus), subscriptionStatusElement.Value, false);
                            result.SubscriptionStatus = subscriptionStatusInstance;
                        }
                        
                        XElement accountAdminLiveEmailIdElement = subscriptionElement.Element(XName.Get("AccountAdminLiveEmailId", "http://schemas.microsoft.com/windowsazure"));
                        if (accountAdminLiveEmailIdElement != null)
                        {
                            string accountAdminLiveEmailIdInstance = accountAdminLiveEmailIdElement.Value;
                            result.AccountAdminLiveEmailId = accountAdminLiveEmailIdInstance;
                        }
                        
                        XElement serviceAdminLiveEmailIdElement = subscriptionElement.Element(XName.Get("ServiceAdminLiveEmailId", "http://schemas.microsoft.com/windowsazure"));
                        if (serviceAdminLiveEmailIdElement != null)
                        {
                            string serviceAdminLiveEmailIdInstance = serviceAdminLiveEmailIdElement.Value;
                            result.ServiceAdminLiveEmailId = serviceAdminLiveEmailIdInstance;
                        }
                        
                        XElement maxCoreCountElement = subscriptionElement.Element(XName.Get("MaxCoreCount", "http://schemas.microsoft.com/windowsazure"));
                        if (maxCoreCountElement != null)
                        {
                            int maxCoreCountInstance = int.Parse(maxCoreCountElement.Value, CultureInfo.InvariantCulture);
                            result.MaximumCoreCount = maxCoreCountInstance;
                        }
                        
                        XElement maxStorageAccountsElement = subscriptionElement.Element(XName.Get("MaxStorageAccounts", "http://schemas.microsoft.com/windowsazure"));
                        if (maxStorageAccountsElement != null)
                        {
                            int maxStorageAccountsInstance = int.Parse(maxStorageAccountsElement.Value, CultureInfo.InvariantCulture);
                            result.MaximumStorageAccounts = maxStorageAccountsInstance;
                        }
                        
                        XElement maxHostedServicesElement = subscriptionElement.Element(XName.Get("MaxHostedServices", "http://schemas.microsoft.com/windowsazure"));
                        if (maxHostedServicesElement != null)
                        {
                            int maxHostedServicesInstance = int.Parse(maxHostedServicesElement.Value, CultureInfo.InvariantCulture);
                            result.MaximumHostedServices = maxHostedServicesInstance;
                        }
                        
                        XElement currentCoreCountElement = subscriptionElement.Element(XName.Get("CurrentCoreCount", "http://schemas.microsoft.com/windowsazure"));
                        if (currentCoreCountElement != null)
                        {
                            int currentCoreCountInstance = int.Parse(currentCoreCountElement.Value, CultureInfo.InvariantCulture);
                            result.CurrentCoreCount = currentCoreCountInstance;
                        }
                        
                        XElement currentStorageAccountsElement = subscriptionElement.Element(XName.Get("CurrentStorageAccounts", "http://schemas.microsoft.com/windowsazure"));
                        if (currentStorageAccountsElement != null)
                        {
                            int currentStorageAccountsInstance = int.Parse(currentStorageAccountsElement.Value, CultureInfo.InvariantCulture);
                            result.CurrentStorageAccounts = currentStorageAccountsInstance;
                        }
                        
                        XElement currentHostedServicesElement = subscriptionElement.Element(XName.Get("CurrentHostedServices", "http://schemas.microsoft.com/windowsazure"));
                        if (currentHostedServicesElement != null)
                        {
                            int currentHostedServicesInstance = int.Parse(currentHostedServicesElement.Value, CultureInfo.InvariantCulture);
                            result.CurrentHostedServices = currentHostedServicesInstance;
                        }
                        
                        XElement maxVirtualNetworkSitesElement = subscriptionElement.Element(XName.Get("MaxVirtualNetworkSites", "http://schemas.microsoft.com/windowsazure"));
                        if (maxVirtualNetworkSitesElement != null)
                        {
                            int maxVirtualNetworkSitesInstance = int.Parse(maxVirtualNetworkSitesElement.Value, CultureInfo.InvariantCulture);
                            result.MaximumVirtualNetworkSites = maxVirtualNetworkSitesInstance;
                        }
                        
                        XElement currentVirtualNetworkSitesElement = subscriptionElement.Element(XName.Get("CurrentVirtualNetworkSites", "http://schemas.microsoft.com/windowsazure"));
                        if (currentVirtualNetworkSitesElement != null)
                        {
                            int currentVirtualNetworkSitesInstance = int.Parse(currentVirtualNetworkSitesElement.Value, CultureInfo.InvariantCulture);
                            result.CurrentVirtualNetworkSites = currentVirtualNetworkSitesInstance;
                        }
                        
                        XElement maxLocalNetworkSitesElement = subscriptionElement.Element(XName.Get("MaxLocalNetworkSites", "http://schemas.microsoft.com/windowsazure"));
                        if (maxLocalNetworkSitesElement != null)
                        {
                            int maxLocalNetworkSitesInstance = int.Parse(maxLocalNetworkSitesElement.Value, CultureInfo.InvariantCulture);
                            result.MaximumLocalNetworkSites = maxLocalNetworkSitesInstance;
                        }
                        
                        XElement maxDnsServersElement = subscriptionElement.Element(XName.Get("MaxDnsServers", "http://schemas.microsoft.com/windowsazure"));
                        if (maxDnsServersElement != null)
                        {
                            int maxDnsServersInstance = int.Parse(maxDnsServersElement.Value, CultureInfo.InvariantCulture);
                            result.MaximumDnsServers = maxDnsServersInstance;
                        }
                        
                        XElement currentLocalNetworkSitesElement = subscriptionElement.Element(XName.Get("CurrentLocalNetworkSites", "http://schemas.microsoft.com/windowsazure"));
                        if (currentLocalNetworkSitesElement != null)
                        {
                            int currentLocalNetworkSitesInstance = int.Parse(currentLocalNetworkSitesElement.Value, CultureInfo.InvariantCulture);
                            result.CurrentLocalNetworkSites = currentLocalNetworkSitesInstance;
                        }
                        
                        XElement currentDnsServersElement = subscriptionElement.Element(XName.Get("CurrentDnsServers", "http://schemas.microsoft.com/windowsazure"));
                        if (currentDnsServersElement != null)
                        {
                            int currentDnsServersInstance = int.Parse(currentDnsServersElement.Value, CultureInfo.InvariantCulture);
                            result.CurrentDnsServers = currentDnsServersInstance;
                        }
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
        
        /// <summary>
        /// The List Subscription Operations operation returns a list of
        /// create, update, and delete operations that were performed on a
        /// subscription during the specified timeframe.  (see
        /// http://msdn.microsoft.com/en-us/library/windowsazure/gg715318.aspx
        /// for more information)
        /// </summary>
        /// <param name='parameters'>
        /// Parameters supplied to the List Subscription Operations operation.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// The List Subscription Operations operation response.
        /// </returns>
        public async Task<SubscriptionListOperationsResponse> ListOperationsAsync(SubscriptionListOperationsParameters parameters, CancellationToken cancellationToken)
        {
            // Validate
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("parameters", parameters);
                Tracing.Enter(invocationId, this, "ListOperationsAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/operations?";
            url = url + "&StartTime=" + Uri.EscapeUriString(string.Format(CultureInfo.InvariantCulture, "{0:O}", parameters.StartTime.ToUniversalTime()));
            url = url + "&EndTime=" + Uri.EscapeUriString(string.Format(CultureInfo.InvariantCulture, "{0:O}", parameters.EndTime.ToUniversalTime()));
            if (parameters.ObjectIdFilter != null)
            {
                url = url + "&ObjectIdFilter=" + Uri.EscapeUriString(parameters.ObjectIdFilter);
            }
            if (parameters.OperationStatus != null)
            {
                url = url + "&OperationResultFilter=" + Uri.EscapeUriString(parameters.OperationStatus.Value.ToString());
            }
            if (parameters.ContinuationToken != null)
            {
                url = url + "&ContinuationToken=" + Uri.EscapeUriString(parameters.ContinuationToken);
            }
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Get;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    SubscriptionListOperationsResponse result = new SubscriptionListOperationsResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    // Deserialize Response
                    cancellationToken.ThrowIfCancellationRequested();
                    string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
                    XDocument responseDoc = XDocument.Parse(responseContent);
                    
                    XElement subscriptionOperationCollectionElement = responseDoc.Element(XName.Get("SubscriptionOperationCollection", "http://schemas.microsoft.com/windowsazure"));
                    if (subscriptionOperationCollectionElement != null)
                    {
                        XElement continuationTokenElement = subscriptionOperationCollectionElement.Element(XName.Get("ContinuationToken", "http://schemas.microsoft.com/windowsazure"));
                        if (continuationTokenElement != null)
                        {
                            string continuationTokenInstance = continuationTokenElement.Value;
                            result.ContinuationToken = continuationTokenInstance;
                        }
                        
                        XElement subscriptionOperationsSequenceElement = subscriptionOperationCollectionElement.Element(XName.Get("SubscriptionOperations", "http://schemas.microsoft.com/windowsazure"));
                        if (subscriptionOperationsSequenceElement != null)
                        {
                            foreach (XElement subscriptionOperationsElement in subscriptionOperationsSequenceElement.Elements(XName.Get("SubscriptionOperation", "http://schemas.microsoft.com/windowsazure")))
                            {
                                SubscriptionListOperationsResponse.SubscriptionOperation subscriptionOperationInstance = new SubscriptionListOperationsResponse.SubscriptionOperation();
                                result.SubscriptionOperations.Add(subscriptionOperationInstance);
                                
                                XElement operationIdElement = subscriptionOperationsElement.Element(XName.Get("OperationId", "http://schemas.microsoft.com/windowsazure"));
                                if (operationIdElement != null)
                                {
                                    string operationIdInstance = operationIdElement.Value;
                                    subscriptionOperationInstance.OperationId = operationIdInstance;
                                }
                                
                                XElement operationObjectIdElement = subscriptionOperationsElement.Element(XName.Get("OperationObjectId", "http://schemas.microsoft.com/windowsazure"));
                                if (operationObjectIdElement != null)
                                {
                                    string operationObjectIdInstance = operationObjectIdElement.Value;
                                    subscriptionOperationInstance.OperationObjectId = operationObjectIdInstance;
                                }
                                
                                XElement operationNameElement = subscriptionOperationsElement.Element(XName.Get("OperationName", "http://schemas.microsoft.com/windowsazure"));
                                if (operationNameElement != null)
                                {
                                    string operationNameInstance = operationNameElement.Value;
                                    subscriptionOperationInstance.OperationName = operationNameInstance;
                                }
                                
                                XElement operationParametersSequenceElement = subscriptionOperationsElement.Element(XName.Get("OperationParameters", "http://schemas.microsoft.com/windowsazure"));
                                if (operationParametersSequenceElement != null)
                                {
                                    foreach (XElement operationParametersElement in operationParametersSequenceElement.Elements(XName.Get("OperationParameter", "http://schemas.microsoft.com/windowsazure")))
                                    {
                                        string operationParametersKey = operationParametersElement.Element(XName.Get("Name", "http://schemas.datacontract.org/2004/07/Microsoft.WindowsAzure.ServiceManagement")).Value;
                                        string operationParametersValue = operationParametersElement.Element(XName.Get("Value", "http://schemas.datacontract.org/2004/07/Microsoft.WindowsAzure.ServiceManagement")).Value;
                                        subscriptionOperationInstance.OperationParameters.Add(operationParametersKey, operationParametersValue);
                                    }
                                }
                                
                                XElement operationCallerElement = subscriptionOperationsElement.Element(XName.Get("OperationCaller", "http://schemas.microsoft.com/windowsazure"));
                                if (operationCallerElement != null)
                                {
                                    SubscriptionListOperationsResponse.OperationCallerDetails operationCallerInstance = new SubscriptionListOperationsResponse.OperationCallerDetails();
                                    subscriptionOperationInstance.OperationCaller = operationCallerInstance;
                                    
                                    XElement usedServiceManagementApiElement = operationCallerElement.Element(XName.Get("UsedServiceManagementApi", "http://schemas.microsoft.com/windowsazure"));
                                    if (usedServiceManagementApiElement != null)
                                    {
                                        bool usedServiceManagementApiInstance = bool.Parse(usedServiceManagementApiElement.Value);
                                        operationCallerInstance.UsedServiceManagementApi = usedServiceManagementApiInstance;
                                    }
                                    
                                    XElement userEmailAddressElement = operationCallerElement.Element(XName.Get("UserEmailAddress", "http://schemas.microsoft.com/windowsazure"));
                                    if (userEmailAddressElement != null)
                                    {
                                        string userEmailAddressInstance = userEmailAddressElement.Value;
                                        operationCallerInstance.UserEmailAddress = userEmailAddressInstance;
                                    }
                                    
                                    XElement subscriptionCertificateThumbprintElement = operationCallerElement.Element(XName.Get("SubscriptionCertificateThumbprint", "http://schemas.microsoft.com/windowsazure"));
                                    if (subscriptionCertificateThumbprintElement != null)
                                    {
                                        string subscriptionCertificateThumbprintInstance = subscriptionCertificateThumbprintElement.Value;
                                        operationCallerInstance.SubscriptionCertificateThumbprint = subscriptionCertificateThumbprintInstance;
                                    }
                                    
                                    XElement clientIPElement = operationCallerElement.Element(XName.Get("ClientIP", "http://schemas.microsoft.com/windowsazure"));
                                    if (clientIPElement != null)
                                    {
                                        string clientIPInstance = clientIPElement.Value;
                                        operationCallerInstance.ClientIPAddress = clientIPInstance;
                                    }
                                }
                                
                                XElement operationStatusElement = subscriptionOperationsElement.Element(XName.Get("OperationStatus", "http://schemas.microsoft.com/windowsazure"));
                                if (operationStatusElement != null)
                                {
                                    string operationStatusInstance = operationStatusElement.Value;
                                    subscriptionOperationInstance.OperationStatus = operationStatusInstance;
                                }
                                
                                XElement operationStartedTimeElement = subscriptionOperationsElement.Element(XName.Get("OperationStartedTime", "http://schemas.microsoft.com/windowsazure"));
                                if (operationStartedTimeElement != null)
                                {
                                    DateTime operationStartedTimeInstance = DateTime.Parse(operationStartedTimeElement.Value, CultureInfo.InvariantCulture);
                                    subscriptionOperationInstance.OperationStartedTime = operationStartedTimeInstance;
                                }
                                
                                XElement operationCompletedTimeElement = subscriptionOperationsElement.Element(XName.Get("OperationCompletedTime", "http://schemas.microsoft.com/windowsazure"));
                                if (operationCompletedTimeElement != null)
                                {
                                    DateTime operationCompletedTimeInstance = DateTime.Parse(operationCompletedTimeElement.Value, CultureInfo.InvariantCulture);
                                    subscriptionOperationInstance.OperationCompletedTime = operationCompletedTimeInstance;
                                }
                            }
                        }
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Register a resource with your subscription.
        /// </summary>
        /// <param name='resourceName'>
        /// Name of the resource to register.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public async Task<OperationResponse> RegisterResourceAsync(string resourceName, CancellationToken cancellationToken)
        {
            // Validate
            if (resourceName == null)
            {
                throw new ArgumentNullException("resourceName");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("resourceName", resourceName);
                Tracing.Enter(invocationId, this, "RegisterResourceAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/services?service=" + resourceName + "&action=register";
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Put;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK && statusCode != HttpStatusCode.Accepted)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    OperationResponse result = new OperationResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
        
        /// <summary>
        /// Unregister a resource with your subscription.
        /// </summary>
        /// <param name='resourceName'>
        /// Name of the resource to unregister.
        /// </param>
        /// <param name='cancellationToken'>
        /// Cancellation token.
        /// </param>
        /// <returns>
        /// A standard service response including an HTTP status code and
        /// request ID.
        /// </returns>
        public async Task<OperationResponse> UnregisterResourceAsync(string resourceName, CancellationToken cancellationToken)
        {
            // Validate
            if (resourceName == null)
            {
                throw new ArgumentNullException("resourceName");
            }
            
            // Tracing
            bool shouldTrace = CloudContext.Configuration.Tracing.IsEnabled;
            string invocationId = null;
            if (shouldTrace)
            {
                invocationId = Tracing.NextInvocationId.ToString();
                Dictionary<string, object> tracingParameters = new Dictionary<string, object>();
                tracingParameters.Add("resourceName", resourceName);
                Tracing.Enter(invocationId, this, "UnregisterResourceAsync", tracingParameters);
            }
            
            // Construct URL
            string url = this.Client.BaseUri + "/" + this.Client.Credentials.SubscriptionId + "/services?service=" + resourceName + "&action=unregister";
            
            // Create HTTP transport objects
            HttpRequestMessage httpRequest = null;
            try
            {
                httpRequest = new HttpRequestMessage();
                httpRequest.Method = HttpMethod.Put;
                httpRequest.RequestUri = new Uri(url);
                
                // Set Headers
                httpRequest.Headers.Add("x-ms-version", "2013-03-01");
                
                // Set Credentials
                cancellationToken.ThrowIfCancellationRequested();
                await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                
                // Send Request
                HttpResponseMessage httpResponse = null;
                try
                {
                    if (shouldTrace)
                    {
                        Tracing.SendRequest(invocationId, httpRequest);
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                    httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
                    if (shouldTrace)
                    {
                        Tracing.ReceiveResponse(invocationId, httpResponse);
                    }
                    HttpStatusCode statusCode = httpResponse.StatusCode;
                    if (statusCode != HttpStatusCode.OK && statusCode != HttpStatusCode.Accepted)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        CloudException ex = CloudException.CreateFromXml(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
                        if (shouldTrace)
                        {
                            Tracing.Error(invocationId, ex);
                        }
                        throw ex;
                    }
                    
                    // Create Result
                    OperationResponse result = new OperationResponse();
                    result.StatusCode = statusCode;
                    if (httpResponse.Headers.Contains("x-ms-request-id"))
                    {
                        result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
                    }
                    
                    if (shouldTrace)
                    {
                        Tracing.Exit(invocationId, result);
                    }
                    return result;
                }
                finally
                {
                    if (httpResponse != null)
                    {
                        httpResponse.Dispose();
                    }
                }
            }
            finally
            {
                if (httpRequest != null)
                {
                    httpRequest.Dispose();
                }
            }
        }
    }
}