vendor: add github.com/Azure/azure-sdk-for-go and dependencies

vendor/github.com/Azure/azure-sdk-for-go/arm/datalake-analytics/account/accountgroup.go

@@ -0,0 +1,641 @@
+package account
+
+// Copyright (c) Microsoft and contributors.  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.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/Azure/go-autorest/autorest/validation"
+	"net/http"
+)
+
+// GroupClient is the creates an Azure Data Lake Analytics account management
+// client.
+type GroupClient struct {
+	ManagementClient
+}
+
+// NewGroupClient creates an instance of the GroupClient client.
+func NewGroupClient(subscriptionID string) GroupClient {
+	return NewGroupClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewGroupClientWithBaseURI creates an instance of the GroupClient client.
+func NewGroupClientWithBaseURI(baseURI string, subscriptionID string) GroupClient {
+	return GroupClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Create creates the specified Data Lake Analytics account. This supplies the
+// user with computation services for Data Lake Analytics workloads This method
+// may poll for completion. Polling can be canceled by passing the cancel
+// channel argument. The channel will be used to cancel polling and any
+// outstanding HTTP requests.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account.the account will be associated with. accountName
+// is the name of the Data Lake Analytics account to create. parameters is
+// parameters supplied to the create Data Lake Analytics account operation.
+func (client GroupClient) Create(resourceGroupName string, accountName string, parameters DataLakeAnalyticsAccount, cancel <-chan struct{}) (<-chan DataLakeAnalyticsAccount, <-chan error) {
+	resultChan := make(chan DataLakeAnalyticsAccount, 1)
+	errChan := make(chan error, 1)
+	if err := validation.Validate([]validation.Validation{
+		{TargetValue: parameters,
+			Constraints: []validation.Constraint{{Target: "parameters.DataLakeAnalyticsAccountProperties", Name: validation.Null, Rule: true,
+				Chain: []validation.Constraint{{Target: "parameters.DataLakeAnalyticsAccountProperties.DefaultDataLakeStoreAccount", Name: validation.Null, Rule: true, Chain: nil},
+					{Target: "parameters.DataLakeAnalyticsAccountProperties.MaxDegreeOfParallelism", Name: validation.Null, Rule: false,
+						Chain: []validation.Constraint{{Target: "parameters.DataLakeAnalyticsAccountProperties.MaxDegreeOfParallelism", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}},
+					{Target: "parameters.DataLakeAnalyticsAccountProperties.QueryStoreRetention", Name: validation.Null, Rule: false,
+						Chain: []validation.Constraint{{Target: "parameters.DataLakeAnalyticsAccountProperties.QueryStoreRetention", Name: validation.InclusiveMaximum, Rule: 180, Chain: nil},
+							{Target: "parameters.DataLakeAnalyticsAccountProperties.QueryStoreRetention", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil},
+						}},
+					{Target: "parameters.DataLakeAnalyticsAccountProperties.MaxJobCount", Name: validation.Null, Rule: false,
+						Chain: []validation.Constraint{{Target: "parameters.DataLakeAnalyticsAccountProperties.MaxJobCount", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}},
+					{Target: "parameters.DataLakeAnalyticsAccountProperties.DataLakeStoreAccounts", Name: validation.Null, Rule: true, Chain: nil},
+				}}}}}); err != nil {
+		errChan <- validation.NewErrorWithValidationError(err, "account.GroupClient", "Create")
+		close(errChan)
+		close(resultChan)
+		return resultChan, errChan
+	}
+
+	go func() {
+		var err error
+		var result DataLakeAnalyticsAccount
+		defer func() {
+			resultChan <- result
+			errChan <- err
+			close(resultChan)
+			close(errChan)
+		}()
+		req, err := client.CreatePreparer(resourceGroupName, accountName, parameters, cancel)
+		if err != nil {
+			err = autorest.NewErrorWithError(err, "account.GroupClient", "Create", nil, "Failure preparing request")
+			return
+		}
+
+		resp, err := client.CreateSender(req)
+		if err != nil {
+			result.Response = autorest.Response{Response: resp}
+			err = autorest.NewErrorWithError(err, "account.GroupClient", "Create", resp, "Failure sending request")
+			return
+		}
+
+		result, err = client.CreateResponder(resp)
+		if err != nil {
+			err = autorest.NewErrorWithError(err, "account.GroupClient", "Create", resp, "Failure responding to request")
+		}
+	}()
+	return resultChan, errChan
+}
+
+// CreatePreparer prepares the Create request.
+func (client GroupClient) CreatePreparer(resourceGroupName string, accountName string, parameters DataLakeAnalyticsAccount, cancel <-chan struct{}) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsJSON(),
+		autorest.AsPut(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}", pathParameters),
+		autorest.WithJSON(parameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateSender sends the Create request. The method will close the
+// http.Response Body if it receives an error.
+func (client GroupClient) CreateSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client,
+		req,
+		azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateResponder handles the response to the Create request. The method always
+// closes the http.Response Body.
+func (client GroupClient) CreateResponder(resp *http.Response) (result DataLakeAnalyticsAccount, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusCreated, http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// Delete begins the delete delete process for the Data Lake Analytics account
+// object specified by the account name. This method may poll for completion.
+// Polling can be canceled by passing the cancel channel argument. The channel
+// will be used to cancel polling and any outstanding HTTP requests.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account to delete
+func (client GroupClient) Delete(resourceGroupName string, accountName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
+	resultChan := make(chan autorest.Response, 1)
+	errChan := make(chan error, 1)
+	go func() {
+		var err error
+		var result autorest.Response
+		defer func() {
+			resultChan <- result
+			errChan <- err
+			close(resultChan)
+			close(errChan)
+		}()
+		req, err := client.DeletePreparer(resourceGroupName, accountName, cancel)
+		if err != nil {
+			err = autorest.NewErrorWithError(err, "account.GroupClient", "Delete", nil, "Failure preparing request")
+			return
+		}
+
+		resp, err := client.DeleteSender(req)
+		if err != nil {
+			result.Response = resp
+			err = autorest.NewErrorWithError(err, "account.GroupClient", "Delete", resp, "Failure sending request")
+			return
+		}
+
+		result, err = client.DeleteResponder(resp)
+		if err != nil {
+			err = autorest.NewErrorWithError(err, "account.GroupClient", "Delete", resp, "Failure responding to request")
+		}
+	}()
+	return resultChan, errChan
+}
+
+// DeletePreparer prepares the Delete request.
+func (client GroupClient) DeletePreparer(resourceGroupName string, accountName string, cancel <-chan struct{}) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsDelete(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client GroupClient) DeleteSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client,
+		req,
+		azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client GroupClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+		autorest.ByClosing())
+	result.Response = resp
+	return
+}
+
+// Get gets details of the specified Data Lake Analytics account.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account to retrieve.
+func (client GroupClient) Get(resourceGroupName string, accountName string) (result DataLakeAnalyticsAccount, err error) {
+	req, err := client.GetPreparer(resourceGroupName, accountName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "Get", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.GetSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "Get", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.GetResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "Get", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// GetPreparer prepares the Get request.
+func (client GroupClient) GetPreparer(resourceGroupName string, accountName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client GroupClient) GetSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client GroupClient) GetResponder(resp *http.Response) (result DataLakeAnalyticsAccount, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// List gets the first page of Data Lake Analytics accounts, if any, within the
+// current subscription. This includes a link to the next page, if any.
+//
+// filter is oData filter. Optional. top is the number of items to return.
+// Optional. skip is the number of items to skip over before returning
+// elements. Optional. selectParameter is oData Select statement. Limits the
+// properties on each entry to just those requested, e.g.
+// Categories?$select=CategoryName,Description. Optional. orderby is orderBy
+// clause. One or more comma-separated expressions with an optional "asc" (the
+// default) or "desc" depending on the order you'd like the values sorted, e.g.
+// Categories?$orderby=CategoryName desc. Optional. count is the Boolean value
+// of true or false to request a count of the matching resources included with
+// the resources in the response, e.g. Categories?$count=true. Optional.
+func (client GroupClient) List(filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (result DataLakeAnalyticsAccountListResult, err error) {
+	if err := validation.Validate([]validation.Validation{
+		{TargetValue: top,
+			Constraints: []validation.Constraint{{Target: "top", Name: validation.Null, Rule: false,
+				Chain: []validation.Constraint{{Target: "top", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}}}},
+		{TargetValue: skip,
+			Constraints: []validation.Constraint{{Target: "skip", Name: validation.Null, Rule: false,
+				Chain: []validation.Constraint{{Target: "skip", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}}}}}); err != nil {
+		return result, validation.NewErrorWithValidationError(err, "account.GroupClient", "List")
+	}
+
+	req, err := client.ListPreparer(filter, top, skip, selectParameter, orderby, count)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "List", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.ListSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "List", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.ListResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "List", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// ListPreparer prepares the List request.
+func (client GroupClient) ListPreparer(filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+	if len(filter) > 0 {
+		queryParameters["$filter"] = autorest.Encode("query", filter)
+	}
+	if top != nil {
+		queryParameters["$top"] = autorest.Encode("query", *top)
+	}
+	if skip != nil {
+		queryParameters["$skip"] = autorest.Encode("query", *skip)
+	}
+	if len(selectParameter) > 0 {
+		queryParameters["$select"] = autorest.Encode("query", selectParameter)
+	}
+	if len(orderby) > 0 {
+		queryParameters["$orderby"] = autorest.Encode("query", orderby)
+	}
+	if count != nil {
+		queryParameters["$count"] = autorest.Encode("query", *count)
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DataLakeAnalytics/accounts", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client GroupClient) ListSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client GroupClient) ListResponder(resp *http.Response) (result DataLakeAnalyticsAccountListResult, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// ListNextResults retrieves the next set of results, if any.
+func (client GroupClient) ListNextResults(lastResults DataLakeAnalyticsAccountListResult) (result DataLakeAnalyticsAccountListResult, err error) {
+	req, err := lastResults.DataLakeAnalyticsAccountListResultPreparer()
+	if err != nil {
+		return result, autorest.NewErrorWithError(err, "account.GroupClient", "List", nil, "Failure preparing next results request")
+	}
+	if req == nil {
+		return
+	}
+
+	resp, err := client.ListSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		return result, autorest.NewErrorWithError(err, "account.GroupClient", "List", resp, "Failure sending next results request")
+	}
+
+	result, err = client.ListResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "List", resp, "Failure responding to next results request")
+	}
+
+	return
+}
+
+// ListByResourceGroup gets the first page of Data Lake Analytics accounts, if
+// any, within a specific resource group. This includes a link to the next
+// page, if any.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. filter is oData filter. Optional. top is the
+// number of items to return. Optional. skip is the number of items to skip
+// over before returning elements. Optional. selectParameter is oData Select
+// statement. Limits the properties on each entry to just those requested, e.g.
+// Categories?$select=CategoryName,Description. Optional. orderby is orderBy
+// clause. One or more comma-separated expressions with an optional "asc" (the
+// default) or "desc" depending on the order you'd like the values sorted, e.g.
+// Categories?$orderby=CategoryName desc. Optional. count is the Boolean value
+// of true or false to request a count of the matching resources included with
+// the resources in the response, e.g. Categories?$count=true. Optional.
+func (client GroupClient) ListByResourceGroup(resourceGroupName string, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (result DataLakeAnalyticsAccountListResult, err error) {
+	if err := validation.Validate([]validation.Validation{
+		{TargetValue: top,
+			Constraints: []validation.Constraint{{Target: "top", Name: validation.Null, Rule: false,
+				Chain: []validation.Constraint{{Target: "top", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}}}},
+		{TargetValue: skip,
+			Constraints: []validation.Constraint{{Target: "skip", Name: validation.Null, Rule: false,
+				Chain: []validation.Constraint{{Target: "skip", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}}}}}); err != nil {
+		return result, validation.NewErrorWithValidationError(err, "account.GroupClient", "ListByResourceGroup")
+	}
+
+	req, err := client.ListByResourceGroupPreparer(resourceGroupName, filter, top, skip, selectParameter, orderby, count)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "ListByResourceGroup", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.ListByResourceGroupSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "ListByResourceGroup", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.ListByResourceGroupResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "ListByResourceGroup", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client GroupClient) ListByResourceGroupPreparer(resourceGroupName string, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+	if len(filter) > 0 {
+		queryParameters["$filter"] = autorest.Encode("query", filter)
+	}
+	if top != nil {
+		queryParameters["$top"] = autorest.Encode("query", *top)
+	}
+	if skip != nil {
+		queryParameters["$skip"] = autorest.Encode("query", *skip)
+	}
+	if len(selectParameter) > 0 {
+		queryParameters["$select"] = autorest.Encode("query", selectParameter)
+	}
+	if len(orderby) > 0 {
+		queryParameters["$orderby"] = autorest.Encode("query", orderby)
+	}
+	if count != nil {
+		queryParameters["$count"] = autorest.Encode("query", *count)
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client GroupClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client GroupClient) ListByResourceGroupResponder(resp *http.Response) (result DataLakeAnalyticsAccountListResult, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// ListByResourceGroupNextResults retrieves the next set of results, if any.
+func (client GroupClient) ListByResourceGroupNextResults(lastResults DataLakeAnalyticsAccountListResult) (result DataLakeAnalyticsAccountListResult, err error) {
+	req, err := lastResults.DataLakeAnalyticsAccountListResultPreparer()
+	if err != nil {
+		return result, autorest.NewErrorWithError(err, "account.GroupClient", "ListByResourceGroup", nil, "Failure preparing next results request")
+	}
+	if req == nil {
+		return
+	}
+
+	resp, err := client.ListByResourceGroupSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		return result, autorest.NewErrorWithError(err, "account.GroupClient", "ListByResourceGroup", resp, "Failure sending next results request")
+	}
+
+	result, err = client.ListByResourceGroupResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.GroupClient", "ListByResourceGroup", resp, "Failure responding to next results request")
+	}
+
+	return
+}
+
+// Update updates the Data Lake Analytics account object specified by the
+// accountName with the contents of the account object. This method may poll
+// for completion. Polling can be canceled by passing the cancel channel
+// argument. The channel will be used to cancel polling and any outstanding
+// HTTP requests.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account to update. parameters is parameters supplied to the update
+// Data Lake Analytics account operation.
+func (client GroupClient) Update(resourceGroupName string, accountName string, parameters *DataLakeAnalyticsAccountUpdateParameters, cancel <-chan struct{}) (<-chan DataLakeAnalyticsAccount, <-chan error) {
+	resultChan := make(chan DataLakeAnalyticsAccount, 1)
+	errChan := make(chan error, 1)
+	go func() {
+		var err error
+		var result DataLakeAnalyticsAccount
+		defer func() {
+			resultChan <- result
+			errChan <- err
+			close(resultChan)
+			close(errChan)
+		}()
+		req, err := client.UpdatePreparer(resourceGroupName, accountName, parameters, cancel)
+		if err != nil {
+			err = autorest.NewErrorWithError(err, "account.GroupClient", "Update", nil, "Failure preparing request")
+			return
+		}
+
+		resp, err := client.UpdateSender(req)
+		if err != nil {
+			result.Response = autorest.Response{Response: resp}
+			err = autorest.NewErrorWithError(err, "account.GroupClient", "Update", resp, "Failure sending request")
+			return
+		}
+
+		result, err = client.UpdateResponder(resp)
+		if err != nil {
+			err = autorest.NewErrorWithError(err, "account.GroupClient", "Update", resp, "Failure responding to request")
+		}
+	}()
+	return resultChan, errChan
+}
+
+// UpdatePreparer prepares the Update request.
+func (client GroupClient) UpdatePreparer(resourceGroupName string, accountName string, parameters *DataLakeAnalyticsAccountUpdateParameters, cancel <-chan struct{}) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsJSON(),
+		autorest.AsPatch(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	if parameters != nil {
+		preparer = autorest.DecoratePreparer(preparer,
+			autorest.WithJSON(parameters))
+	}
+	return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client GroupClient) UpdateSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client,
+		req,
+		azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client GroupClient) UpdateResponder(resp *http.Response) (result DataLakeAnalyticsAccount, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}

vendor/github.com/Azure/azure-sdk-for-go/arm/datalake-analytics/account/client.go

@@ -0,0 +1,53 @@
+// Package account implements the Azure ARM Account service API version
+// 2016-11-01.
+//
+// Creates an Azure Data Lake Analytics account management client.
+package account
+
+// Copyright (c) Microsoft and contributors.  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.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+	"github.com/Azure/go-autorest/autorest"
+)
+
+const (
+	// DefaultBaseURI is the default URI used for the service Account
+	DefaultBaseURI = "https://management.azure.com"
+)
+
+// ManagementClient is the base client for Account.
+type ManagementClient struct {
+	autorest.Client
+	BaseURI        string
+	SubscriptionID string
+}
+
+// New creates an instance of the ManagementClient client.
+func New(subscriptionID string) ManagementClient {
+	return NewWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewWithBaseURI creates an instance of the ManagementClient client.
+func NewWithBaseURI(baseURI string, subscriptionID string) ManagementClient {
+	return ManagementClient{
+		Client:         autorest.NewClientWithUserAgent(UserAgent()),
+		BaseURI:        baseURI,
+		SubscriptionID: subscriptionID,
+	}
+}

vendor/github.com/Azure/azure-sdk-for-go/arm/datalake-analytics/account/datalakestoreaccounts.go

@@ -0,0 +1,391 @@
+package account
+
+// Copyright (c) Microsoft and contributors.  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.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/Azure/go-autorest/autorest/validation"
+	"net/http"
+)
+
+// DataLakeStoreAccountsClient is the creates an Azure Data Lake Analytics
+// account management client.
+type DataLakeStoreAccountsClient struct {
+	ManagementClient
+}
+
+// NewDataLakeStoreAccountsClient creates an instance of the
+// DataLakeStoreAccountsClient client.
+func NewDataLakeStoreAccountsClient(subscriptionID string) DataLakeStoreAccountsClient {
+	return NewDataLakeStoreAccountsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewDataLakeStoreAccountsClientWithBaseURI creates an instance of the
+// DataLakeStoreAccountsClient client.
+func NewDataLakeStoreAccountsClientWithBaseURI(baseURI string, subscriptionID string) DataLakeStoreAccountsClient {
+	return DataLakeStoreAccountsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Add updates the specified Data Lake Analytics account to include the
+// additional Data Lake Store account.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account to which to add the Data Lake Store account.
+// dataLakeStoreAccountName is the name of the Data Lake Store account to add.
+// parameters is the details of the Data Lake Store account.
+func (client DataLakeStoreAccountsClient) Add(resourceGroupName string, accountName string, dataLakeStoreAccountName string, parameters *AddDataLakeStoreParameters) (result autorest.Response, err error) {
+	req, err := client.AddPreparer(resourceGroupName, accountName, dataLakeStoreAccountName, parameters)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "Add", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.AddSender(req)
+	if err != nil {
+		result.Response = resp
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "Add", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.AddResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "Add", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// AddPreparer prepares the Add request.
+func (client DataLakeStoreAccountsClient) AddPreparer(resourceGroupName string, accountName string, dataLakeStoreAccountName string, parameters *AddDataLakeStoreParameters) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":              autorest.Encode("path", accountName),
+		"dataLakeStoreAccountName": autorest.Encode("path", dataLakeStoreAccountName),
+		"resourceGroupName":        autorest.Encode("path", resourceGroupName),
+		"subscriptionId":           autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsJSON(),
+		autorest.AsPut(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/DataLakeStoreAccounts/{dataLakeStoreAccountName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	if parameters != nil {
+		preparer = autorest.DecoratePreparer(preparer,
+			autorest.WithJSON(parameters))
+	}
+	return preparer.Prepare(&http.Request{})
+}
+
+// AddSender sends the Add request. The method will close the
+// http.Response Body if it receives an error.
+func (client DataLakeStoreAccountsClient) AddSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// AddResponder handles the response to the Add request. The method always
+// closes the http.Response Body.
+func (client DataLakeStoreAccountsClient) AddResponder(resp *http.Response) (result autorest.Response, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByClosing())
+	result.Response = resp
+	return
+}
+
+// Delete updates the Data Lake Analytics account specified to remove the
+// specified Data Lake Store account.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account from which to remove the Data Lake Store account.
+// dataLakeStoreAccountName is the name of the Data Lake Store account to
+// remove
+func (client DataLakeStoreAccountsClient) Delete(resourceGroupName string, accountName string, dataLakeStoreAccountName string) (result autorest.Response, err error) {
+	req, err := client.DeletePreparer(resourceGroupName, accountName, dataLakeStoreAccountName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "Delete", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.DeleteSender(req)
+	if err != nil {
+		result.Response = resp
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "Delete", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.DeleteResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "Delete", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client DataLakeStoreAccountsClient) DeletePreparer(resourceGroupName string, accountName string, dataLakeStoreAccountName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":              autorest.Encode("path", accountName),
+		"dataLakeStoreAccountName": autorest.Encode("path", dataLakeStoreAccountName),
+		"resourceGroupName":        autorest.Encode("path", resourceGroupName),
+		"subscriptionId":           autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsDelete(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/DataLakeStoreAccounts/{dataLakeStoreAccountName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client DataLakeStoreAccountsClient) DeleteSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client DataLakeStoreAccountsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByClosing())
+	result.Response = resp
+	return
+}
+
+// Get gets the specified Data Lake Store account details in the specified Data
+// Lake Analytics account.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account from which to retrieve the Data Lake Store account
+// details. dataLakeStoreAccountName is the name of the Data Lake Store account
+// to retrieve
+func (client DataLakeStoreAccountsClient) Get(resourceGroupName string, accountName string, dataLakeStoreAccountName string) (result DataLakeStoreAccountInfo, err error) {
+	req, err := client.GetPreparer(resourceGroupName, accountName, dataLakeStoreAccountName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "Get", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.GetSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "Get", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.GetResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "Get", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// GetPreparer prepares the Get request.
+func (client DataLakeStoreAccountsClient) GetPreparer(resourceGroupName string, accountName string, dataLakeStoreAccountName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":              autorest.Encode("path", accountName),
+		"dataLakeStoreAccountName": autorest.Encode("path", dataLakeStoreAccountName),
+		"resourceGroupName":        autorest.Encode("path", resourceGroupName),
+		"subscriptionId":           autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/DataLakeStoreAccounts/{dataLakeStoreAccountName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client DataLakeStoreAccountsClient) GetSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client DataLakeStoreAccountsClient) GetResponder(resp *http.Response) (result DataLakeStoreAccountInfo, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// ListByAccount gets the first page of Data Lake Store accounts linked to the
+// specified Data Lake Analytics account. The response includes a link to the
+// next page, if any.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account for which to list Data Lake Store accounts. filter is
+// oData filter. Optional. top is the number of items to return. Optional. skip
+// is the number of items to skip over before returning elements. Optional.
+// selectParameter is oData Select statement. Limits the properties on each
+// entry to just those requested, e.g.
+// Categories?$select=CategoryName,Description. Optional. orderby is orderBy
+// clause. One or more comma-separated expressions with an optional "asc" (the
+// default) or "desc" depending on the order you'd like the values sorted, e.g.
+// Categories?$orderby=CategoryName desc. Optional. count is the Boolean value
+// of true or false to request a count of the matching resources included with
+// the resources in the response, e.g. Categories?$count=true. Optional.
+func (client DataLakeStoreAccountsClient) ListByAccount(resourceGroupName string, accountName string, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (result DataLakeAnalyticsAccountListDataLakeStoreResult, err error) {
+	if err := validation.Validate([]validation.Validation{
+		{TargetValue: top,
+			Constraints: []validation.Constraint{{Target: "top", Name: validation.Null, Rule: false,
+				Chain: []validation.Constraint{{Target: "top", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}}}},
+		{TargetValue: skip,
+			Constraints: []validation.Constraint{{Target: "skip", Name: validation.Null, Rule: false,
+				Chain: []validation.Constraint{{Target: "skip", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}}}}}); err != nil {
+		return result, validation.NewErrorWithValidationError(err, "account.DataLakeStoreAccountsClient", "ListByAccount")
+	}
+
+	req, err := client.ListByAccountPreparer(resourceGroupName, accountName, filter, top, skip, selectParameter, orderby, count)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "ListByAccount", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.ListByAccountSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "ListByAccount", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.ListByAccountResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "ListByAccount", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// ListByAccountPreparer prepares the ListByAccount request.
+func (client DataLakeStoreAccountsClient) ListByAccountPreparer(resourceGroupName string, accountName string, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+	if len(filter) > 0 {
+		queryParameters["$filter"] = autorest.Encode("query", filter)
+	}
+	if top != nil {
+		queryParameters["$top"] = autorest.Encode("query", *top)
+	}
+	if skip != nil {
+		queryParameters["$skip"] = autorest.Encode("query", *skip)
+	}
+	if len(selectParameter) > 0 {
+		queryParameters["$select"] = autorest.Encode("query", selectParameter)
+	}
+	if len(orderby) > 0 {
+		queryParameters["$orderby"] = autorest.Encode("query", orderby)
+	}
+	if count != nil {
+		queryParameters["$count"] = autorest.Encode("query", *count)
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/DataLakeStoreAccounts/", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// ListByAccountSender sends the ListByAccount request. The method will close the
+// http.Response Body if it receives an error.
+func (client DataLakeStoreAccountsClient) ListByAccountSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// ListByAccountResponder handles the response to the ListByAccount request. The method always
+// closes the http.Response Body.
+func (client DataLakeStoreAccountsClient) ListByAccountResponder(resp *http.Response) (result DataLakeAnalyticsAccountListDataLakeStoreResult, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// ListByAccountNextResults retrieves the next set of results, if any.
+func (client DataLakeStoreAccountsClient) ListByAccountNextResults(lastResults DataLakeAnalyticsAccountListDataLakeStoreResult) (result DataLakeAnalyticsAccountListDataLakeStoreResult, err error) {
+	req, err := lastResults.DataLakeAnalyticsAccountListDataLakeStoreResultPreparer()
+	if err != nil {
+		return result, autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "ListByAccount", nil, "Failure preparing next results request")
+	}
+	if req == nil {
+		return
+	}
+
+	resp, err := client.ListByAccountSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		return result, autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "ListByAccount", resp, "Failure sending next results request")
+	}
+
+	result, err = client.ListByAccountResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.DataLakeStoreAccountsClient", "ListByAccount", resp, "Failure responding to next results request")
+	}
+
+	return
+}

vendor/github.com/Azure/azure-sdk-for-go/arm/datalake-analytics/account/firewallrules.go

@@ -0,0 +1,432 @@
+package account
+
+// Copyright (c) Microsoft and contributors.  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.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/Azure/go-autorest/autorest/validation"
+	"net/http"
+)
+
+// FirewallRulesClient is the creates an Azure Data Lake Analytics account
+// management client.
+type FirewallRulesClient struct {
+	ManagementClient
+}
+
+// NewFirewallRulesClient creates an instance of the FirewallRulesClient
+// client.
+func NewFirewallRulesClient(subscriptionID string) FirewallRulesClient {
+	return NewFirewallRulesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewFirewallRulesClientWithBaseURI creates an instance of the
+// FirewallRulesClient client.
+func NewFirewallRulesClientWithBaseURI(baseURI string, subscriptionID string) FirewallRulesClient {
+	return FirewallRulesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates the specified firewall rule. During
+// update, the firewall rule with the specified name will be replaced with this
+// new firewall rule.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account to add or replace the firewall rule. firewallRuleName is
+// the name of the firewall rule to create or update. parameters is parameters
+// supplied to create or update the firewall rule.
+func (client FirewallRulesClient) CreateOrUpdate(resourceGroupName string, accountName string, firewallRuleName string, parameters FirewallRule) (result FirewallRule, err error) {
+	if err := validation.Validate([]validation.Validation{
+		{TargetValue: parameters,
+			Constraints: []validation.Constraint{{Target: "parameters.FirewallRuleProperties", Name: validation.Null, Rule: true,
+				Chain: []validation.Constraint{{Target: "parameters.FirewallRuleProperties.StartIPAddress", Name: validation.Null, Rule: true, Chain: nil},
+					{Target: "parameters.FirewallRuleProperties.EndIPAddress", Name: validation.Null, Rule: true, Chain: nil},
+				}}}}}); err != nil {
+		return result, validation.NewErrorWithValidationError(err, "account.FirewallRulesClient", "CreateOrUpdate")
+	}
+
+	req, err := client.CreateOrUpdatePreparer(resourceGroupName, accountName, firewallRuleName, parameters)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "CreateOrUpdate", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.CreateOrUpdateSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "CreateOrUpdate", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.CreateOrUpdateResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "CreateOrUpdate", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client FirewallRulesClient) CreateOrUpdatePreparer(resourceGroupName string, accountName string, firewallRuleName string, parameters FirewallRule) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"firewallRuleName":  autorest.Encode("path", firewallRuleName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsJSON(),
+		autorest.AsPut(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/firewallRules/{firewallRuleName}", pathParameters),
+		autorest.WithJSON(parameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client FirewallRulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client FirewallRulesClient) CreateOrUpdateResponder(resp *http.Response) (result FirewallRule, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// Delete deletes the specified firewall rule from the specified Data Lake
+// Analytics account
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account from which to delete the firewall rule. firewallRuleName
+// is the name of the firewall rule to delete.
+func (client FirewallRulesClient) Delete(resourceGroupName string, accountName string, firewallRuleName string) (result autorest.Response, err error) {
+	req, err := client.DeletePreparer(resourceGroupName, accountName, firewallRuleName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "Delete", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.DeleteSender(req)
+	if err != nil {
+		result.Response = resp
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "Delete", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.DeleteResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "Delete", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client FirewallRulesClient) DeletePreparer(resourceGroupName string, accountName string, firewallRuleName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"firewallRuleName":  autorest.Encode("path", firewallRuleName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsDelete(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/firewallRules/{firewallRuleName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client FirewallRulesClient) DeleteSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client FirewallRulesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+		autorest.ByClosing())
+	result.Response = resp
+	return
+}
+
+// Get gets the specified Data Lake Analytics firewall rule.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account from which to get the firewall rule. firewallRuleName is
+// the name of the firewall rule to retrieve.
+func (client FirewallRulesClient) Get(resourceGroupName string, accountName string, firewallRuleName string) (result FirewallRule, err error) {
+	req, err := client.GetPreparer(resourceGroupName, accountName, firewallRuleName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "Get", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.GetSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "Get", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.GetResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "Get", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// GetPreparer prepares the Get request.
+func (client FirewallRulesClient) GetPreparer(resourceGroupName string, accountName string, firewallRuleName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"firewallRuleName":  autorest.Encode("path", firewallRuleName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/firewallRules/{firewallRuleName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client FirewallRulesClient) GetSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client FirewallRulesClient) GetResponder(resp *http.Response) (result FirewallRule, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// ListByAccount lists the Data Lake Analytics firewall rules within the
+// specified Data Lake Analytics account.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account from which to get the firewall rules.
+func (client FirewallRulesClient) ListByAccount(resourceGroupName string, accountName string) (result DataLakeAnalyticsFirewallRuleListResult, err error) {
+	req, err := client.ListByAccountPreparer(resourceGroupName, accountName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "ListByAccount", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.ListByAccountSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "ListByAccount", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.ListByAccountResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "ListByAccount", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// ListByAccountPreparer prepares the ListByAccount request.
+func (client FirewallRulesClient) ListByAccountPreparer(resourceGroupName string, accountName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/firewallRules", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// ListByAccountSender sends the ListByAccount request. The method will close the
+// http.Response Body if it receives an error.
+func (client FirewallRulesClient) ListByAccountSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// ListByAccountResponder handles the response to the ListByAccount request. The method always
+// closes the http.Response Body.
+func (client FirewallRulesClient) ListByAccountResponder(resp *http.Response) (result DataLakeAnalyticsFirewallRuleListResult, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// ListByAccountNextResults retrieves the next set of results, if any.
+func (client FirewallRulesClient) ListByAccountNextResults(lastResults DataLakeAnalyticsFirewallRuleListResult) (result DataLakeAnalyticsFirewallRuleListResult, err error) {
+	req, err := lastResults.DataLakeAnalyticsFirewallRuleListResultPreparer()
+	if err != nil {
+		return result, autorest.NewErrorWithError(err, "account.FirewallRulesClient", "ListByAccount", nil, "Failure preparing next results request")
+	}
+	if req == nil {
+		return
+	}
+
+	resp, err := client.ListByAccountSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		return result, autorest.NewErrorWithError(err, "account.FirewallRulesClient", "ListByAccount", resp, "Failure sending next results request")
+	}
+
+	result, err = client.ListByAccountResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "ListByAccount", resp, "Failure responding to next results request")
+	}
+
+	return
+}
+
+// Update updates the specified firewall rule.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account to which to update the firewall rule. firewallRuleName is
+// the name of the firewall rule to update. parameters is parameters supplied
+// to update the firewall rule.
+func (client FirewallRulesClient) Update(resourceGroupName string, accountName string, firewallRuleName string, parameters *UpdateFirewallRuleParameters) (result FirewallRule, err error) {
+	req, err := client.UpdatePreparer(resourceGroupName, accountName, firewallRuleName, parameters)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "Update", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.UpdateSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "Update", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.UpdateResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.FirewallRulesClient", "Update", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client FirewallRulesClient) UpdatePreparer(resourceGroupName string, accountName string, firewallRuleName string, parameters *UpdateFirewallRuleParameters) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"firewallRuleName":  autorest.Encode("path", firewallRuleName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsJSON(),
+		autorest.AsPatch(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/firewallRules/{firewallRuleName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	if parameters != nil {
+		preparer = autorest.DecoratePreparer(preparer,
+			autorest.WithJSON(parameters))
+	}
+	return preparer.Prepare(&http.Request{})
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client FirewallRulesClient) UpdateSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client FirewallRulesClient) UpdateResponder(resp *http.Response) (result FirewallRule, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}

vendor/github.com/Azure/azure-sdk-for-go/arm/datalake-analytics/account/models.go

@@ -0,0 +1,429 @@
+package account
+
+// Copyright (c) Microsoft and contributors.  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.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest/date"
+	"github.com/Azure/go-autorest/autorest/to"
+	"net/http"
+)
+
+// DataLakeAnalyticsAccountState enumerates the values for data lake analytics
+// account state.
+type DataLakeAnalyticsAccountState string
+
+const (
+	// Active specifies the active state for data lake analytics account state.
+	Active DataLakeAnalyticsAccountState = "Active"
+	// Suspended specifies the suspended state for data lake analytics account
+	// state.
+	Suspended DataLakeAnalyticsAccountState = "Suspended"
+)
+
+// DataLakeAnalyticsAccountStatus enumerates the values for data lake analytics
+// account status.
+type DataLakeAnalyticsAccountStatus string
+
+const (
+	// Creating specifies the creating state for data lake analytics account
+	// status.
+	Creating DataLakeAnalyticsAccountStatus = "Creating"
+	// Deleted specifies the deleted state for data lake analytics account
+	// status.
+	Deleted DataLakeAnalyticsAccountStatus = "Deleted"
+	// Deleting specifies the deleting state for data lake analytics account
+	// status.
+	Deleting DataLakeAnalyticsAccountStatus = "Deleting"
+	// Failed specifies the failed state for data lake analytics account
+	// status.
+	Failed DataLakeAnalyticsAccountStatus = "Failed"
+	// Patching specifies the patching state for data lake analytics account
+	// status.
+	Patching DataLakeAnalyticsAccountStatus = "Patching"
+	// Resuming specifies the resuming state for data lake analytics account
+	// status.
+	Resuming DataLakeAnalyticsAccountStatus = "Resuming"
+	// Running specifies the running state for data lake analytics account
+	// status.
+	Running DataLakeAnalyticsAccountStatus = "Running"
+	// Succeeded specifies the succeeded state for data lake analytics account
+	// status.
+	Succeeded DataLakeAnalyticsAccountStatus = "Succeeded"
+	// Suspending specifies the suspending state for data lake analytics
+	// account status.
+	Suspending DataLakeAnalyticsAccountStatus = "Suspending"
+)
+
+// FirewallAllowAzureIpsState enumerates the values for firewall allow azure
+// ips state.
+type FirewallAllowAzureIpsState string
+
+const (
+	// Disabled specifies the disabled state for firewall allow azure ips
+	// state.
+	Disabled FirewallAllowAzureIpsState = "Disabled"
+	// Enabled specifies the enabled state for firewall allow azure ips state.
+	Enabled FirewallAllowAzureIpsState = "Enabled"
+)
+
+// FirewallState enumerates the values for firewall state.
+type FirewallState string
+
+const (
+	// FirewallStateDisabled specifies the firewall state disabled state for
+	// firewall state.
+	FirewallStateDisabled FirewallState = "Disabled"
+	// FirewallStateEnabled specifies the firewall state enabled state for
+	// firewall state.
+	FirewallStateEnabled FirewallState = "Enabled"
+)
+
+// TierType enumerates the values for tier type.
+type TierType string
+
+const (
+	// Commitment100000AUHours specifies the commitment 100000au hours state
+	// for tier type.
+	Commitment100000AUHours TierType = "Commitment_100000AUHours"
+	// Commitment10000AUHours specifies the commitment 10000au hours state for
+	// tier type.
+	Commitment10000AUHours TierType = "Commitment_10000AUHours"
+	// Commitment1000AUHours specifies the commitment 1000au hours state for
+	// tier type.
+	Commitment1000AUHours TierType = "Commitment_1000AUHours"
+	// Commitment100AUHours specifies the commitment 100au hours state for tier
+	// type.
+	Commitment100AUHours TierType = "Commitment_100AUHours"
+	// Commitment500000AUHours specifies the commitment 500000au hours state
+	// for tier type.
+	Commitment500000AUHours TierType = "Commitment_500000AUHours"
+	// Commitment50000AUHours specifies the commitment 50000au hours state for
+	// tier type.
+	Commitment50000AUHours TierType = "Commitment_50000AUHours"
+	// Commitment5000AUHours specifies the commitment 5000au hours state for
+	// tier type.
+	Commitment5000AUHours TierType = "Commitment_5000AUHours"
+	// Commitment500AUHours specifies the commitment 500au hours state for tier
+	// type.
+	Commitment500AUHours TierType = "Commitment_500AUHours"
+	// Consumption specifies the consumption state for tier type.
+	Consumption TierType = "Consumption"
+)
+
+// AddDataLakeStoreParameters is additional Data Lake Store parameters.
+type AddDataLakeStoreParameters struct {
+	*DataLakeStoreAccountInfoProperties `json:"properties,omitempty"`
+}
+
+// AddStorageAccountParameters is storage account parameters for a storage
+// account being added to a Data Lake Analytics account.
+type AddStorageAccountParameters struct {
+	*StorageAccountProperties `json:"properties,omitempty"`
+}
+
+// DataLakeAnalyticsAccount is a Data Lake Analytics account object, containing
+// all information associated with the named Data Lake Analytics account.
+type DataLakeAnalyticsAccount struct {
+	autorest.Response                   `json:"-"`
+	ID                                  *string             `json:"id,omitempty"`
+	Name                                *string             `json:"name,omitempty"`
+	Type                                *string             `json:"type,omitempty"`
+	Location                            *string             `json:"location,omitempty"`
+	Tags                                *map[string]*string `json:"tags,omitempty"`
+	*DataLakeAnalyticsAccountProperties `json:"properties,omitempty"`
+}
+
+// DataLakeAnalyticsAccountListDataLakeStoreResult is data Lake Account list
+// information.
+type DataLakeAnalyticsAccountListDataLakeStoreResult struct {
+	autorest.Response `json:"-"`
+	Value             *[]DataLakeStoreAccountInfo `json:"value,omitempty"`
+	NextLink          *string                     `json:"nextLink,omitempty"`
+}
+
+// DataLakeAnalyticsAccountListDataLakeStoreResultPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client DataLakeAnalyticsAccountListDataLakeStoreResult) DataLakeAnalyticsAccountListDataLakeStoreResultPreparer() (*http.Request, error) {
+	if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+		return nil, nil
+	}
+	return autorest.Prepare(&http.Request{},
+		autorest.AsJSON(),
+		autorest.AsGet(),
+		autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// DataLakeAnalyticsAccountListResult is dataLakeAnalytics Account list
+// information.
+type DataLakeAnalyticsAccountListResult struct {
+	autorest.Response `json:"-"`
+	Value             *[]DataLakeAnalyticsAccount `json:"value,omitempty"`
+	NextLink          *string                     `json:"nextLink,omitempty"`
+}
+
+// DataLakeAnalyticsAccountListResultPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client DataLakeAnalyticsAccountListResult) DataLakeAnalyticsAccountListResultPreparer() (*http.Request, error) {
+	if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+		return nil, nil
+	}
+	return autorest.Prepare(&http.Request{},
+		autorest.AsJSON(),
+		autorest.AsGet(),
+		autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// DataLakeAnalyticsAccountListStorageAccountsResult is azure Storage Account
+// list information.
+type DataLakeAnalyticsAccountListStorageAccountsResult struct {
+	autorest.Response `json:"-"`
+	Value             *[]StorageAccountInfo `json:"value,omitempty"`
+	NextLink          *string               `json:"nextLink,omitempty"`
+}
+
+// DataLakeAnalyticsAccountListStorageAccountsResultPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client DataLakeAnalyticsAccountListStorageAccountsResult) DataLakeAnalyticsAccountListStorageAccountsResultPreparer() (*http.Request, error) {
+	if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+		return nil, nil
+	}
+	return autorest.Prepare(&http.Request{},
+		autorest.AsJSON(),
+		autorest.AsGet(),
+		autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// DataLakeAnalyticsAccountProperties is the account specific properties that
+// are associated with an underlying Data Lake Analytics account.
+type DataLakeAnalyticsAccountProperties struct {
+	ProvisioningState            DataLakeAnalyticsAccountStatus `json:"provisioningState,omitempty"`
+	State                        DataLakeAnalyticsAccountState  `json:"state,omitempty"`
+	DefaultDataLakeStoreAccount  *string                        `json:"defaultDataLakeStoreAccount,omitempty"`
+	MaxDegreeOfParallelism       *int32                         `json:"maxDegreeOfParallelism,omitempty"`
+	QueryStoreRetention          *int32                         `json:"queryStoreRetention,omitempty"`
+	MaxJobCount                  *int32                         `json:"maxJobCount,omitempty"`
+	SystemMaxDegreeOfParallelism *int32                         `json:"systemMaxDegreeOfParallelism,omitempty"`
+	SystemMaxJobCount            *int32                         `json:"systemMaxJobCount,omitempty"`
+	DataLakeStoreAccounts        *[]DataLakeStoreAccountInfo    `json:"dataLakeStoreAccounts,omitempty"`
+	StorageAccounts              *[]StorageAccountInfo          `json:"storageAccounts,omitempty"`
+	CreationTime                 *date.Time                     `json:"creationTime,omitempty"`
+	LastModifiedTime             *date.Time                     `json:"lastModifiedTime,omitempty"`
+	Endpoint                     *string                        `json:"endpoint,omitempty"`
+	NewTier                      TierType                       `json:"newTier,omitempty"`
+	CurrentTier                  TierType                       `json:"currentTier,omitempty"`
+	FirewallState                FirewallState                  `json:"firewallState,omitempty"`
+	FirewallAllowAzureIps        FirewallAllowAzureIpsState     `json:"firewallAllowAzureIps,omitempty"`
+	FirewallRules                *[]FirewallRule                `json:"firewallRules,omitempty"`
+}
+
+// DataLakeAnalyticsAccountUpdateParameters is the parameters that can be used
+// to update an existing Data Lake Analytics account.
+type DataLakeAnalyticsAccountUpdateParameters struct {
+	Tags                                      *map[string]*string `json:"tags,omitempty"`
+	*UpdateDataLakeAnalyticsAccountProperties `json:"properties,omitempty"`
+}
+
+// DataLakeAnalyticsFirewallRuleListResult is data Lake Analytics firewall rule
+// list information.
+type DataLakeAnalyticsFirewallRuleListResult struct {
+	autorest.Response `json:"-"`
+	Value             *[]FirewallRule `json:"value,omitempty"`
+	NextLink          *string         `json:"nextLink,omitempty"`
+}
+
+// DataLakeAnalyticsFirewallRuleListResultPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client DataLakeAnalyticsFirewallRuleListResult) DataLakeAnalyticsFirewallRuleListResultPreparer() (*http.Request, error) {
+	if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+		return nil, nil
+	}
+	return autorest.Prepare(&http.Request{},
+		autorest.AsJSON(),
+		autorest.AsGet(),
+		autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// DataLakeStoreAccountInfo is data Lake Store account information.
+type DataLakeStoreAccountInfo struct {
+	autorest.Response                   `json:"-"`
+	ID                                  *string `json:"id,omitempty"`
+	Name                                *string `json:"name,omitempty"`
+	Type                                *string `json:"type,omitempty"`
+	*DataLakeStoreAccountInfoProperties `json:"properties,omitempty"`
+}
+
+// DataLakeStoreAccountInfoProperties is data Lake Store account properties
+// information.
+type DataLakeStoreAccountInfoProperties struct {
+	Suffix *string `json:"suffix,omitempty"`
+}
+
+// FirewallRule is data Lake Analytics firewall rule information
+type FirewallRule struct {
+	autorest.Response       `json:"-"`
+	ID                      *string `json:"id,omitempty"`
+	Name                    *string `json:"name,omitempty"`
+	Type                    *string `json:"type,omitempty"`
+	*FirewallRuleProperties `json:"properties,omitempty"`
+}
+
+// FirewallRuleProperties is data Lake Analytics firewall rule properties
+// information
+type FirewallRuleProperties struct {
+	StartIPAddress *string `json:"startIpAddress,omitempty"`
+	EndIPAddress   *string `json:"endIpAddress,omitempty"`
+}
+
+// ListSasTokensResult is the SAS response that contains the storage account,
+// container and associated SAS token for connection use.
+type ListSasTokensResult struct {
+	autorest.Response `json:"-"`
+	Value             *[]SasTokenInfo `json:"value,omitempty"`
+	NextLink          *string         `json:"nextLink,omitempty"`
+}
+
+// ListSasTokensResultPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client ListSasTokensResult) ListSasTokensResultPreparer() (*http.Request, error) {
+	if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+		return nil, nil
+	}
+	return autorest.Prepare(&http.Request{},
+		autorest.AsJSON(),
+		autorest.AsGet(),
+		autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// ListStorageContainersResult is the list of blob containers associated with
+// the storage account attached to the Data Lake Analytics account.
+type ListStorageContainersResult struct {
+	autorest.Response `json:"-"`
+	Value             *[]StorageContainer `json:"value,omitempty"`
+	NextLink          *string             `json:"nextLink,omitempty"`
+}
+
+// ListStorageContainersResultPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client ListStorageContainersResult) ListStorageContainersResultPreparer() (*http.Request, error) {
+	if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+		return nil, nil
+	}
+	return autorest.Prepare(&http.Request{},
+		autorest.AsJSON(),
+		autorest.AsGet(),
+		autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// OptionalSubResource is the Resource model definition for a nested resource
+// with no required properties.
+type OptionalSubResource struct {
+	ID   *string `json:"id,omitempty"`
+	Name *string `json:"name,omitempty"`
+	Type *string `json:"type,omitempty"`
+}
+
+// Resource is the Resource model definition.
+type Resource struct {
+	ID       *string             `json:"id,omitempty"`
+	Name     *string             `json:"name,omitempty"`
+	Type     *string             `json:"type,omitempty"`
+	Location *string             `json:"location,omitempty"`
+	Tags     *map[string]*string `json:"tags,omitempty"`
+}
+
+// SasTokenInfo is sAS token information.
+type SasTokenInfo struct {
+	AccessToken *string `json:"accessToken,omitempty"`
+}
+
+// StorageAccountInfo is azure Storage account information.
+type StorageAccountInfo struct {
+	autorest.Response         `json:"-"`
+	ID                        *string `json:"id,omitempty"`
+	Name                      *string `json:"name,omitempty"`
+	Type                      *string `json:"type,omitempty"`
+	*StorageAccountProperties `json:"properties,omitempty"`
+}
+
+// StorageAccountProperties is azure Storage account properties information.
+type StorageAccountProperties struct {
+	AccessKey *string `json:"accessKey,omitempty"`
+	Suffix    *string `json:"suffix,omitempty"`
+}
+
+// StorageContainer is azure Storage blob container information.
+type StorageContainer struct {
+	autorest.Response           `json:"-"`
+	Name                        *string `json:"name,omitempty"`
+	ID                          *string `json:"id,omitempty"`
+	Type                        *string `json:"type,omitempty"`
+	*StorageContainerProperties `json:"properties,omitempty"`
+}
+
+// StorageContainerProperties is azure Storage blob container properties
+// information.
+type StorageContainerProperties struct {
+	LastModifiedTime *date.Time `json:"lastModifiedTime,omitempty"`
+}
+
+// SubResource is the Sub Resource model definition.
+type SubResource struct {
+	ID   *string `json:"id,omitempty"`
+	Name *string `json:"name,omitempty"`
+	Type *string `json:"type,omitempty"`
+}
+
+// UpdateDataLakeAnalyticsAccountProperties is the properties to update that
+// are associated with an underlying Data Lake Analytics account to.
+type UpdateDataLakeAnalyticsAccountProperties struct {
+	MaxDegreeOfParallelism *int32                     `json:"maxDegreeOfParallelism,omitempty"`
+	QueryStoreRetention    *int32                     `json:"queryStoreRetention,omitempty"`
+	MaxJobCount            *int32                     `json:"maxJobCount,omitempty"`
+	NewTier                TierType                   `json:"newTier,omitempty"`
+	FirewallState          FirewallState              `json:"firewallState,omitempty"`
+	FirewallAllowAzureIps  FirewallAllowAzureIpsState `json:"firewallAllowAzureIps,omitempty"`
+	FirewallRules          *[]FirewallRule            `json:"firewallRules,omitempty"`
+}
+
+// UpdateFirewallRuleParameters is data Lake Analytics firewall rule update
+// parameters
+type UpdateFirewallRuleParameters struct {
+	*UpdateFirewallRuleProperties `json:"properties,omitempty"`
+}
+
+// UpdateFirewallRuleProperties is data Lake Analytics firewall rule properties
+// information
+type UpdateFirewallRuleProperties struct {
+	StartIPAddress *string `json:"startIpAddress,omitempty"`
+	EndIPAddress   *string `json:"endIpAddress,omitempty"`
+}
+
+// UpdateStorageAccountParameters is storage account parameters for a storage
+// account being updated in a Data Lake Analytics account.
+type UpdateStorageAccountParameters struct {
+	*UpdateStorageAccountProperties `json:"properties,omitempty"`
+}
+
+// UpdateStorageAccountProperties is azure Storage account properties
+// information to update.
+type UpdateStorageAccountProperties struct {
+	AccessKey *string `json:"accessKey,omitempty"`
+	Suffix    *string `json:"suffix,omitempty"`
+}

vendor/github.com/Azure/azure-sdk-for-go/arm/datalake-analytics/account/storageaccounts.go

@@ -0,0 +1,738 @@
+package account
+
+// Copyright (c) Microsoft and contributors.  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.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/Azure/go-autorest/autorest/validation"
+	"net/http"
+)
+
+// StorageAccountsClient is the creates an Azure Data Lake Analytics account
+// management client.
+type StorageAccountsClient struct {
+	ManagementClient
+}
+
+// NewStorageAccountsClient creates an instance of the StorageAccountsClient
+// client.
+func NewStorageAccountsClient(subscriptionID string) StorageAccountsClient {
+	return NewStorageAccountsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewStorageAccountsClientWithBaseURI creates an instance of the
+// StorageAccountsClient client.
+func NewStorageAccountsClientWithBaseURI(baseURI string, subscriptionID string) StorageAccountsClient {
+	return StorageAccountsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Add updates the specified Data Lake Analytics account to add an Azure
+// Storage account.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account to which to add the Azure Storage account.
+// storageAccountName is the name of the Azure Storage account to add
+// parameters is the parameters containing the access key and optional suffix
+// for the Azure Storage Account.
+func (client StorageAccountsClient) Add(resourceGroupName string, accountName string, storageAccountName string, parameters AddStorageAccountParameters) (result autorest.Response, err error) {
+	if err := validation.Validate([]validation.Validation{
+		{TargetValue: parameters,
+			Constraints: []validation.Constraint{{Target: "parameters.StorageAccountProperties", Name: validation.Null, Rule: true,
+				Chain: []validation.Constraint{{Target: "parameters.StorageAccountProperties.AccessKey", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil {
+		return result, validation.NewErrorWithValidationError(err, "account.StorageAccountsClient", "Add")
+	}
+
+	req, err := client.AddPreparer(resourceGroupName, accountName, storageAccountName, parameters)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Add", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.AddSender(req)
+	if err != nil {
+		result.Response = resp
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Add", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.AddResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Add", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// AddPreparer prepares the Add request.
+func (client StorageAccountsClient) AddPreparer(resourceGroupName string, accountName string, storageAccountName string, parameters AddStorageAccountParameters) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":        autorest.Encode("path", accountName),
+		"resourceGroupName":  autorest.Encode("path", resourceGroupName),
+		"storageAccountName": autorest.Encode("path", storageAccountName),
+		"subscriptionId":     autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsJSON(),
+		autorest.AsPut(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/StorageAccounts/{storageAccountName}", pathParameters),
+		autorest.WithJSON(parameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// AddSender sends the Add request. The method will close the
+// http.Response Body if it receives an error.
+func (client StorageAccountsClient) AddSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// AddResponder handles the response to the Add request. The method always
+// closes the http.Response Body.
+func (client StorageAccountsClient) AddResponder(resp *http.Response) (result autorest.Response, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByClosing())
+	result.Response = resp
+	return
+}
+
+// Delete updates the specified Data Lake Analytics account to remove an Azure
+// Storage account.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account from which to remove the Azure Storage account.
+// storageAccountName is the name of the Azure Storage account to remove
+func (client StorageAccountsClient) Delete(resourceGroupName string, accountName string, storageAccountName string) (result autorest.Response, err error) {
+	req, err := client.DeletePreparer(resourceGroupName, accountName, storageAccountName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Delete", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.DeleteSender(req)
+	if err != nil {
+		result.Response = resp
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Delete", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.DeleteResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Delete", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client StorageAccountsClient) DeletePreparer(resourceGroupName string, accountName string, storageAccountName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":        autorest.Encode("path", accountName),
+		"resourceGroupName":  autorest.Encode("path", resourceGroupName),
+		"storageAccountName": autorest.Encode("path", storageAccountName),
+		"subscriptionId":     autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsDelete(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/StorageAccounts/{storageAccountName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client StorageAccountsClient) DeleteSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client StorageAccountsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByClosing())
+	result.Response = resp
+	return
+}
+
+// Get gets the specified Azure Storage account linked to the given Data Lake
+// Analytics account.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account from which to retrieve Azure storage account details.
+// storageAccountName is the name of the Azure Storage account for which to
+// retrieve the details.
+func (client StorageAccountsClient) Get(resourceGroupName string, accountName string, storageAccountName string) (result StorageAccountInfo, err error) {
+	req, err := client.GetPreparer(resourceGroupName, accountName, storageAccountName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Get", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.GetSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Get", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.GetResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Get", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// GetPreparer prepares the Get request.
+func (client StorageAccountsClient) GetPreparer(resourceGroupName string, accountName string, storageAccountName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":        autorest.Encode("path", accountName),
+		"resourceGroupName":  autorest.Encode("path", resourceGroupName),
+		"storageAccountName": autorest.Encode("path", storageAccountName),
+		"subscriptionId":     autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/StorageAccounts/{storageAccountName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client StorageAccountsClient) GetSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client StorageAccountsClient) GetResponder(resp *http.Response) (result StorageAccountInfo, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// GetStorageContainer gets the specified Azure Storage container associated
+// with the given Data Lake Analytics and Azure Storage accounts.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account for which to retrieve blob container. storageAccountName
+// is the name of the Azure storage account from which to retrieve the blob
+// container. containerName is the name of the Azure storage container to
+// retrieve
+func (client StorageAccountsClient) GetStorageContainer(resourceGroupName string, accountName string, storageAccountName string, containerName string) (result StorageContainer, err error) {
+	req, err := client.GetStorageContainerPreparer(resourceGroupName, accountName, storageAccountName, containerName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "GetStorageContainer", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.GetStorageContainerSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "GetStorageContainer", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.GetStorageContainerResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "GetStorageContainer", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// GetStorageContainerPreparer prepares the GetStorageContainer request.
+func (client StorageAccountsClient) GetStorageContainerPreparer(resourceGroupName string, accountName string, storageAccountName string, containerName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":        autorest.Encode("path", accountName),
+		"containerName":      autorest.Encode("path", containerName),
+		"resourceGroupName":  autorest.Encode("path", resourceGroupName),
+		"storageAccountName": autorest.Encode("path", storageAccountName),
+		"subscriptionId":     autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/StorageAccounts/{storageAccountName}/Containers/{containerName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// GetStorageContainerSender sends the GetStorageContainer request. The method will close the
+// http.Response Body if it receives an error.
+func (client StorageAccountsClient) GetStorageContainerSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// GetStorageContainerResponder handles the response to the GetStorageContainer request. The method always
+// closes the http.Response Body.
+func (client StorageAccountsClient) GetStorageContainerResponder(resp *http.Response) (result StorageContainer, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// ListByAccount gets the first page of Azure Storage accounts, if any, linked
+// to the specified Data Lake Analytics account. The response includes a link
+// to the next page, if any.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account for which to list Azure Storage accounts. filter is the
+// OData filter. Optional. top is the number of items to return. Optional. skip
+// is the number of items to skip over before returning elements. Optional.
+// selectParameter is oData Select statement. Limits the properties on each
+// entry to just those requested, e.g.
+// Categories?$select=CategoryName,Description. Optional. orderby is orderBy
+// clause. One or more comma-separated expressions with an optional "asc" (the
+// default) or "desc" depending on the order you'd like the values sorted, e.g.
+// Categories?$orderby=CategoryName desc. Optional. count is the Boolean value
+// of true or false to request a count of the matching resources included with
+// the resources in the response, e.g. Categories?$count=true. Optional.
+func (client StorageAccountsClient) ListByAccount(resourceGroupName string, accountName string, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (result DataLakeAnalyticsAccountListStorageAccountsResult, err error) {
+	if err := validation.Validate([]validation.Validation{
+		{TargetValue: top,
+			Constraints: []validation.Constraint{{Target: "top", Name: validation.Null, Rule: false,
+				Chain: []validation.Constraint{{Target: "top", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}}}},
+		{TargetValue: skip,
+			Constraints: []validation.Constraint{{Target: "skip", Name: validation.Null, Rule: false,
+				Chain: []validation.Constraint{{Target: "skip", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}}}}}); err != nil {
+		return result, validation.NewErrorWithValidationError(err, "account.StorageAccountsClient", "ListByAccount")
+	}
+
+	req, err := client.ListByAccountPreparer(resourceGroupName, accountName, filter, top, skip, selectParameter, orderby, count)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListByAccount", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.ListByAccountSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListByAccount", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.ListByAccountResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListByAccount", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// ListByAccountPreparer prepares the ListByAccount request.
+func (client StorageAccountsClient) ListByAccountPreparer(resourceGroupName string, accountName string, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":       autorest.Encode("path", accountName),
+		"resourceGroupName": autorest.Encode("path", resourceGroupName),
+		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+	if len(filter) > 0 {
+		queryParameters["$filter"] = autorest.Encode("query", filter)
+	}
+	if top != nil {
+		queryParameters["$top"] = autorest.Encode("query", *top)
+	}
+	if skip != nil {
+		queryParameters["$skip"] = autorest.Encode("query", *skip)
+	}
+	if len(selectParameter) > 0 {
+		queryParameters["$select"] = autorest.Encode("query", selectParameter)
+	}
+	if len(orderby) > 0 {
+		queryParameters["$orderby"] = autorest.Encode("query", orderby)
+	}
+	if count != nil {
+		queryParameters["$count"] = autorest.Encode("query", *count)
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/StorageAccounts/", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// ListByAccountSender sends the ListByAccount request. The method will close the
+// http.Response Body if it receives an error.
+func (client StorageAccountsClient) ListByAccountSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// ListByAccountResponder handles the response to the ListByAccount request. The method always
+// closes the http.Response Body.
+func (client StorageAccountsClient) ListByAccountResponder(resp *http.Response) (result DataLakeAnalyticsAccountListStorageAccountsResult, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// ListByAccountNextResults retrieves the next set of results, if any.
+func (client StorageAccountsClient) ListByAccountNextResults(lastResults DataLakeAnalyticsAccountListStorageAccountsResult) (result DataLakeAnalyticsAccountListStorageAccountsResult, err error) {
+	req, err := lastResults.DataLakeAnalyticsAccountListStorageAccountsResultPreparer()
+	if err != nil {
+		return result, autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListByAccount", nil, "Failure preparing next results request")
+	}
+	if req == nil {
+		return
+	}
+
+	resp, err := client.ListByAccountSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		return result, autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListByAccount", resp, "Failure sending next results request")
+	}
+
+	result, err = client.ListByAccountResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListByAccount", resp, "Failure responding to next results request")
+	}
+
+	return
+}
+
+// ListSasTokens gets the SAS token associated with the specified Data Lake
+// Analytics and Azure Storage account and container combination.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account from which an Azure Storage account's SAS token is being
+// requested. storageAccountName is the name of the Azure storage account for
+// which the SAS token is being requested. containerName is the name of the
+// Azure storage container for which the SAS token is being requested.
+func (client StorageAccountsClient) ListSasTokens(resourceGroupName string, accountName string, storageAccountName string, containerName string) (result ListSasTokensResult, err error) {
+	req, err := client.ListSasTokensPreparer(resourceGroupName, accountName, storageAccountName, containerName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListSasTokens", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.ListSasTokensSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListSasTokens", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.ListSasTokensResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListSasTokens", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// ListSasTokensPreparer prepares the ListSasTokens request.
+func (client StorageAccountsClient) ListSasTokensPreparer(resourceGroupName string, accountName string, storageAccountName string, containerName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":        autorest.Encode("path", accountName),
+		"containerName":      autorest.Encode("path", containerName),
+		"resourceGroupName":  autorest.Encode("path", resourceGroupName),
+		"storageAccountName": autorest.Encode("path", storageAccountName),
+		"subscriptionId":     autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsPost(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/StorageAccounts/{storageAccountName}/Containers/{containerName}/listSasTokens", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// ListSasTokensSender sends the ListSasTokens request. The method will close the
+// http.Response Body if it receives an error.
+func (client StorageAccountsClient) ListSasTokensSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// ListSasTokensResponder handles the response to the ListSasTokens request. The method always
+// closes the http.Response Body.
+func (client StorageAccountsClient) ListSasTokensResponder(resp *http.Response) (result ListSasTokensResult, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// ListSasTokensNextResults retrieves the next set of results, if any.
+func (client StorageAccountsClient) ListSasTokensNextResults(lastResults ListSasTokensResult) (result ListSasTokensResult, err error) {
+	req, err := lastResults.ListSasTokensResultPreparer()
+	if err != nil {
+		return result, autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListSasTokens", nil, "Failure preparing next results request")
+	}
+	if req == nil {
+		return
+	}
+
+	resp, err := client.ListSasTokensSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		return result, autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListSasTokens", resp, "Failure sending next results request")
+	}
+
+	result, err = client.ListSasTokensResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListSasTokens", resp, "Failure responding to next results request")
+	}
+
+	return
+}
+
+// ListStorageContainers lists the Azure Storage containers, if any, associated
+// with the specified Data Lake Analytics and Azure Storage account
+// combination. The response includes a link to the next page of results, if
+// any.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account for which to list Azure Storage blob containers.
+// storageAccountName is the name of the Azure storage account from which to
+// list blob containers.
+func (client StorageAccountsClient) ListStorageContainers(resourceGroupName string, accountName string, storageAccountName string) (result ListStorageContainersResult, err error) {
+	req, err := client.ListStorageContainersPreparer(resourceGroupName, accountName, storageAccountName)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListStorageContainers", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.ListStorageContainersSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListStorageContainers", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.ListStorageContainersResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListStorageContainers", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// ListStorageContainersPreparer prepares the ListStorageContainers request.
+func (client StorageAccountsClient) ListStorageContainersPreparer(resourceGroupName string, accountName string, storageAccountName string) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":        autorest.Encode("path", accountName),
+		"resourceGroupName":  autorest.Encode("path", resourceGroupName),
+		"storageAccountName": autorest.Encode("path", storageAccountName),
+		"subscriptionId":     autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/StorageAccounts/{storageAccountName}/Containers", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	return preparer.Prepare(&http.Request{})
+}
+
+// ListStorageContainersSender sends the ListStorageContainers request. The method will close the
+// http.Response Body if it receives an error.
+func (client StorageAccountsClient) ListStorageContainersSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// ListStorageContainersResponder handles the response to the ListStorageContainers request. The method always
+// closes the http.Response Body.
+func (client StorageAccountsClient) ListStorageContainersResponder(resp *http.Response) (result ListStorageContainersResult, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&result),
+		autorest.ByClosing())
+	result.Response = autorest.Response{Response: resp}
+	return
+}
+
+// ListStorageContainersNextResults retrieves the next set of results, if any.
+func (client StorageAccountsClient) ListStorageContainersNextResults(lastResults ListStorageContainersResult) (result ListStorageContainersResult, err error) {
+	req, err := lastResults.ListStorageContainersResultPreparer()
+	if err != nil {
+		return result, autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListStorageContainers", nil, "Failure preparing next results request")
+	}
+	if req == nil {
+		return
+	}
+
+	resp, err := client.ListStorageContainersSender(req)
+	if err != nil {
+		result.Response = autorest.Response{Response: resp}
+		return result, autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListStorageContainers", resp, "Failure sending next results request")
+	}
+
+	result, err = client.ListStorageContainersResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "ListStorageContainers", resp, "Failure responding to next results request")
+	}
+
+	return
+}
+
+// Update updates the Data Lake Analytics account to replace Azure Storage blob
+// account details, such as the access key and/or suffix.
+//
+// resourceGroupName is the name of the Azure resource group that contains the
+// Data Lake Analytics account. accountName is the name of the Data Lake
+// Analytics account to modify storage accounts in storageAccountName is the
+// Azure Storage account to modify parameters is the parameters containing the
+// access key and suffix to update the storage account with, if any. Passing
+// nothing results in no change.
+func (client StorageAccountsClient) Update(resourceGroupName string, accountName string, storageAccountName string, parameters *UpdateStorageAccountParameters) (result autorest.Response, err error) {
+	req, err := client.UpdatePreparer(resourceGroupName, accountName, storageAccountName, parameters)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Update", nil, "Failure preparing request")
+		return
+	}
+
+	resp, err := client.UpdateSender(req)
+	if err != nil {
+		result.Response = resp
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Update", resp, "Failure sending request")
+		return
+	}
+
+	result, err = client.UpdateResponder(resp)
+	if err != nil {
+		err = autorest.NewErrorWithError(err, "account.StorageAccountsClient", "Update", resp, "Failure responding to request")
+	}
+
+	return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client StorageAccountsClient) UpdatePreparer(resourceGroupName string, accountName string, storageAccountName string, parameters *UpdateStorageAccountParameters) (*http.Request, error) {
+	pathParameters := map[string]interface{}{
+		"accountName":        autorest.Encode("path", accountName),
+		"resourceGroupName":  autorest.Encode("path", resourceGroupName),
+		"storageAccountName": autorest.Encode("path", storageAccountName),
+		"subscriptionId":     autorest.Encode("path", client.SubscriptionID),
+	}
+
+	const APIVersion = "2016-11-01"
+	queryParameters := map[string]interface{}{
+		"api-version": APIVersion,
+	}
+
+	preparer := autorest.CreatePreparer(
+		autorest.AsJSON(),
+		autorest.AsPatch(),
+		autorest.WithBaseURL(client.BaseURI),
+		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/StorageAccounts/{storageAccountName}", pathParameters),
+		autorest.WithQueryParameters(queryParameters))
+	if parameters != nil {
+		preparer = autorest.DecoratePreparer(preparer,
+			autorest.WithJSON(parameters))
+	}
+	return preparer.Prepare(&http.Request{})
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client StorageAccountsClient) UpdateSender(req *http.Request) (*http.Response, error) {
+	return autorest.SendWithSender(client, req)
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client StorageAccountsClient) UpdateResponder(resp *http.Response) (result autorest.Response, err error) {
+	err = autorest.Respond(
+		resp,
+		client.ByInspecting(),
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByClosing())
+	result.Response = resp
+	return
+}

vendor/github.com/Azure/azure-sdk-for-go/arm/datalake-analytics/account/version.go

@@ -0,0 +1,29 @@
+package account
+
+// Copyright (c) Microsoft and contributors.  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.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+// UserAgent returns the UserAgent string to use when sending http.Requests.
+func UserAgent() string {
+	return "Azure-SDK-For-Go/v10.1.0-beta arm-account/2016-11-01"
+}
+
+// Version returns the semantic version (see http://semver.org) of the client.
+func Version() string {
+	return "v10.1.0-beta"
+}