Source file src/github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v2.1/customvision/training/client.go

Documentation: github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v2.1/customvision/training

     1  // Package training implements the Azure ARM Training service API version 2.1.
     2  //
     3  //
     4  package training
     5  
     6  // Copyright (c) Microsoft Corporation. All rights reserved.
     7  // Licensed under the MIT License. See License.txt in the project root for license information.
     8  //
     9  // Code generated by Microsoft (R) AutoRest Code Generator.
    10  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
    11  
    12  import (
    13  	"context"
    14  	"github.com/Azure/go-autorest/autorest"
    15  	"github.com/Azure/go-autorest/autorest/azure"
    16  	"github.com/Azure/go-autorest/autorest/validation"
    17  	"github.com/Azure/go-autorest/tracing"
    18  	"github.com/gofrs/uuid"
    19  	"io"
    20  	"net/http"
    21  )
    22  
    23  const (
    24  	// DefaultBaseURI is the default URI used for the service Training
    25  	DefaultBaseURI = "https://southcentralus.api.cognitive.microsoft.com/customvision/v2.1/Training"
    26  )
    27  
    28  // BaseClient is the base client for Training.
    29  type BaseClient struct {
    30  	autorest.Client
    31  	BaseURI string
    32  	APIKey  string
    33  }
    34  
    35  // New creates an instance of the BaseClient client.
    36  func New(aPIKey string) BaseClient {
    37  	return NewWithBaseURI(DefaultBaseURI, aPIKey)
    38  }
    39  
    40  // NewWithBaseURI creates an instance of the BaseClient client using a custom endpoint.  Use this when interacting with
    41  // an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    42  func NewWithBaseURI(baseURI string, aPIKey string) BaseClient {
    43  	return BaseClient{
    44  		Client:  autorest.NewClientWithUserAgent(UserAgent()),
    45  		BaseURI: baseURI,
    46  		APIKey:  aPIKey,
    47  	}
    48  }
    49  
    50  // CreateImageRegions this API accepts a batch of image regions, and optionally tags, to update existing images with
    51  // region information.
    52  // There is a limit of 64 entries in the batch.
    53  // Parameters:
    54  // projectID - the project id
    55  // batch - batch of image regions which include a tag and bounding box. Limited to 64
    56  func (client BaseClient) CreateImageRegions(ctx context.Context, projectID uuid.UUID, batch ImageRegionCreateBatch) (result ImageRegionCreateSummary, err error) {
    57  	if tracing.IsEnabled() {
    58  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImageRegions")
    59  		defer func() {
    60  			sc := -1
    61  			if result.Response.Response != nil {
    62  				sc = result.Response.Response.StatusCode
    63  			}
    64  			tracing.EndSpan(ctx, sc, err)
    65  		}()
    66  	}
    67  	req, err := client.CreateImageRegionsPreparer(ctx, projectID, batch)
    68  	if err != nil {
    69  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageRegions", nil, "Failure preparing request")
    70  		return
    71  	}
    72  
    73  	resp, err := client.CreateImageRegionsSender(req)
    74  	if err != nil {
    75  		result.Response = autorest.Response{Response: resp}
    76  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageRegions", resp, "Failure sending request")
    77  		return
    78  	}
    79  
    80  	result, err = client.CreateImageRegionsResponder(resp)
    81  	if err != nil {
    82  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageRegions", resp, "Failure responding to request")
    83  		return
    84  	}
    85  
    86  	return
    87  }
    88  
    89  // CreateImageRegionsPreparer prepares the CreateImageRegions request.
    90  func (client BaseClient) CreateImageRegionsPreparer(ctx context.Context, projectID uuid.UUID, batch ImageRegionCreateBatch) (*http.Request, error) {
    91  	pathParameters := map[string]interface{}{
    92  		"projectId": autorest.Encode("path", projectID),
    93  	}
    94  
    95  	preparer := autorest.CreatePreparer(
    96  		autorest.AsContentType("application/json; charset=utf-8"),
    97  		autorest.AsPost(),
    98  		autorest.WithBaseURL(client.BaseURI),
    99  		autorest.WithPathParameters("/projects/{projectId}/images/regions", pathParameters),
   100  		autorest.WithJSON(batch),
   101  		autorest.WithHeader("Training-Key", client.APIKey))
   102  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   103  }
   104  
   105  // CreateImageRegionsSender sends the CreateImageRegions request. The method will close the
   106  // http.Response Body if it receives an error.
   107  func (client BaseClient) CreateImageRegionsSender(req *http.Request) (*http.Response, error) {
   108  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   109  }
   110  
   111  // CreateImageRegionsResponder handles the response to the CreateImageRegions request. The method always
   112  // closes the http.Response Body.
   113  func (client BaseClient) CreateImageRegionsResponder(resp *http.Response) (result ImageRegionCreateSummary, err error) {
   114  	err = autorest.Respond(
   115  		resp,
   116  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   117  		autorest.ByUnmarshallingJSON(&result),
   118  		autorest.ByClosing())
   119  	result.Response = autorest.Response{Response: resp}
   120  	return
   121  }
   122  
   123  // CreateImagesFromData this API accepts body content as multipart/form-data and application/octet-stream. When using
   124  // multipart
   125  // multiple image files can be sent at once, with a maximum of 64 files
   126  // Parameters:
   127  // projectID - the project id
   128  // tagIds - the tags ids with which to tag each image. Limited to 20
   129  func (client BaseClient) CreateImagesFromData(ctx context.Context, projectID uuid.UUID, imageData io.ReadCloser, tagIds []string) (result ImageCreateSummary, err error) {
   130  	if tracing.IsEnabled() {
   131  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImagesFromData")
   132  		defer func() {
   133  			sc := -1
   134  			if result.Response.Response != nil {
   135  				sc = result.Response.Response.StatusCode
   136  			}
   137  			tracing.EndSpan(ctx, sc, err)
   138  		}()
   139  	}
   140  	req, err := client.CreateImagesFromDataPreparer(ctx, projectID, imageData, tagIds)
   141  	if err != nil {
   142  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromData", nil, "Failure preparing request")
   143  		return
   144  	}
   145  
   146  	resp, err := client.CreateImagesFromDataSender(req)
   147  	if err != nil {
   148  		result.Response = autorest.Response{Response: resp}
   149  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromData", resp, "Failure sending request")
   150  		return
   151  	}
   152  
   153  	result, err = client.CreateImagesFromDataResponder(resp)
   154  	if err != nil {
   155  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromData", resp, "Failure responding to request")
   156  		return
   157  	}
   158  
   159  	return
   160  }
   161  
   162  // CreateImagesFromDataPreparer prepares the CreateImagesFromData request.
   163  func (client BaseClient) CreateImagesFromDataPreparer(ctx context.Context, projectID uuid.UUID, imageData io.ReadCloser, tagIds []string) (*http.Request, error) {
   164  	pathParameters := map[string]interface{}{
   165  		"projectId": autorest.Encode("path", projectID),
   166  	}
   167  
   168  	queryParameters := map[string]interface{}{}
   169  	if tagIds != nil && len(tagIds) > 0 {
   170  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
   171  	}
   172  
   173  	formDataParameters := map[string]interface{}{
   174  		"imageData": imageData,
   175  	}
   176  
   177  	preparer := autorest.CreatePreparer(
   178  		autorest.AsPost(),
   179  		autorest.WithBaseURL(client.BaseURI),
   180  		autorest.WithPathParameters("/projects/{projectId}/images", pathParameters),
   181  		autorest.WithQueryParameters(queryParameters),
   182  		autorest.WithMultiPartFormData(formDataParameters),
   183  		autorest.WithHeader("Training-Key", client.APIKey))
   184  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   185  }
   186  
   187  // CreateImagesFromDataSender sends the CreateImagesFromData request. The method will close the
   188  // http.Response Body if it receives an error.
   189  func (client BaseClient) CreateImagesFromDataSender(req *http.Request) (*http.Response, error) {
   190  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   191  }
   192  
   193  // CreateImagesFromDataResponder handles the response to the CreateImagesFromData request. The method always
   194  // closes the http.Response Body.
   195  func (client BaseClient) CreateImagesFromDataResponder(resp *http.Response) (result ImageCreateSummary, err error) {
   196  	err = autorest.Respond(
   197  		resp,
   198  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   199  		autorest.ByUnmarshallingJSON(&result),
   200  		autorest.ByClosing())
   201  	result.Response = autorest.Response{Response: resp}
   202  	return
   203  }
   204  
   205  // CreateImagesFromFiles this API accepts a batch of files, and optionally tags, to create images. There is a limit of
   206  // 64 images and 20 tags.
   207  // Parameters:
   208  // projectID - the project id
   209  // batch - the batch of image files to add. Limited to 64 images and 20 tags per batch
   210  func (client BaseClient) CreateImagesFromFiles(ctx context.Context, projectID uuid.UUID, batch ImageFileCreateBatch) (result ImageCreateSummary, err error) {
   211  	if tracing.IsEnabled() {
   212  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImagesFromFiles")
   213  		defer func() {
   214  			sc := -1
   215  			if result.Response.Response != nil {
   216  				sc = result.Response.Response.StatusCode
   217  			}
   218  			tracing.EndSpan(ctx, sc, err)
   219  		}()
   220  	}
   221  	req, err := client.CreateImagesFromFilesPreparer(ctx, projectID, batch)
   222  	if err != nil {
   223  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromFiles", nil, "Failure preparing request")
   224  		return
   225  	}
   226  
   227  	resp, err := client.CreateImagesFromFilesSender(req)
   228  	if err != nil {
   229  		result.Response = autorest.Response{Response: resp}
   230  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromFiles", resp, "Failure sending request")
   231  		return
   232  	}
   233  
   234  	result, err = client.CreateImagesFromFilesResponder(resp)
   235  	if err != nil {
   236  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromFiles", resp, "Failure responding to request")
   237  		return
   238  	}
   239  
   240  	return
   241  }
   242  
   243  // CreateImagesFromFilesPreparer prepares the CreateImagesFromFiles request.
   244  func (client BaseClient) CreateImagesFromFilesPreparer(ctx context.Context, projectID uuid.UUID, batch ImageFileCreateBatch) (*http.Request, error) {
   245  	pathParameters := map[string]interface{}{
   246  		"projectId": autorest.Encode("path", projectID),
   247  	}
   248  
   249  	preparer := autorest.CreatePreparer(
   250  		autorest.AsContentType("application/json; charset=utf-8"),
   251  		autorest.AsPost(),
   252  		autorest.WithBaseURL(client.BaseURI),
   253  		autorest.WithPathParameters("/projects/{projectId}/images/files", pathParameters),
   254  		autorest.WithJSON(batch),
   255  		autorest.WithHeader("Training-Key", client.APIKey))
   256  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   257  }
   258  
   259  // CreateImagesFromFilesSender sends the CreateImagesFromFiles request. The method will close the
   260  // http.Response Body if it receives an error.
   261  func (client BaseClient) CreateImagesFromFilesSender(req *http.Request) (*http.Response, error) {
   262  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   263  }
   264  
   265  // CreateImagesFromFilesResponder handles the response to the CreateImagesFromFiles request. The method always
   266  // closes the http.Response Body.
   267  func (client BaseClient) CreateImagesFromFilesResponder(resp *http.Response) (result ImageCreateSummary, err error) {
   268  	err = autorest.Respond(
   269  		resp,
   270  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   271  		autorest.ByUnmarshallingJSON(&result),
   272  		autorest.ByClosing())
   273  	result.Response = autorest.Response{Response: resp}
   274  	return
   275  }
   276  
   277  // CreateImagesFromPredictions this API creates a batch of images from predicted images specified. There is a limit of
   278  // 64 images and 20 tags.
   279  // Parameters:
   280  // projectID - the project id
   281  // batch - image and tag ids. Limited to 64 images and 20 tags per batch
   282  func (client BaseClient) CreateImagesFromPredictions(ctx context.Context, projectID uuid.UUID, batch ImageIDCreateBatch) (result ImageCreateSummary, err error) {
   283  	if tracing.IsEnabled() {
   284  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImagesFromPredictions")
   285  		defer func() {
   286  			sc := -1
   287  			if result.Response.Response != nil {
   288  				sc = result.Response.Response.StatusCode
   289  			}
   290  			tracing.EndSpan(ctx, sc, err)
   291  		}()
   292  	}
   293  	req, err := client.CreateImagesFromPredictionsPreparer(ctx, projectID, batch)
   294  	if err != nil {
   295  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromPredictions", nil, "Failure preparing request")
   296  		return
   297  	}
   298  
   299  	resp, err := client.CreateImagesFromPredictionsSender(req)
   300  	if err != nil {
   301  		result.Response = autorest.Response{Response: resp}
   302  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromPredictions", resp, "Failure sending request")
   303  		return
   304  	}
   305  
   306  	result, err = client.CreateImagesFromPredictionsResponder(resp)
   307  	if err != nil {
   308  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromPredictions", resp, "Failure responding to request")
   309  		return
   310  	}
   311  
   312  	return
   313  }
   314  
   315  // CreateImagesFromPredictionsPreparer prepares the CreateImagesFromPredictions request.
   316  func (client BaseClient) CreateImagesFromPredictionsPreparer(ctx context.Context, projectID uuid.UUID, batch ImageIDCreateBatch) (*http.Request, error) {
   317  	pathParameters := map[string]interface{}{
   318  		"projectId": autorest.Encode("path", projectID),
   319  	}
   320  
   321  	preparer := autorest.CreatePreparer(
   322  		autorest.AsContentType("application/json; charset=utf-8"),
   323  		autorest.AsPost(),
   324  		autorest.WithBaseURL(client.BaseURI),
   325  		autorest.WithPathParameters("/projects/{projectId}/images/predictions", pathParameters),
   326  		autorest.WithJSON(batch),
   327  		autorest.WithHeader("Training-Key", client.APIKey))
   328  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   329  }
   330  
   331  // CreateImagesFromPredictionsSender sends the CreateImagesFromPredictions request. The method will close the
   332  // http.Response Body if it receives an error.
   333  func (client BaseClient) CreateImagesFromPredictionsSender(req *http.Request) (*http.Response, error) {
   334  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   335  }
   336  
   337  // CreateImagesFromPredictionsResponder handles the response to the CreateImagesFromPredictions request. The method always
   338  // closes the http.Response Body.
   339  func (client BaseClient) CreateImagesFromPredictionsResponder(resp *http.Response) (result ImageCreateSummary, err error) {
   340  	err = autorest.Respond(
   341  		resp,
   342  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   343  		autorest.ByUnmarshallingJSON(&result),
   344  		autorest.ByClosing())
   345  	result.Response = autorest.Response{Response: resp}
   346  	return
   347  }
   348  
   349  // CreateImagesFromUrls this API accepts a batch of urls, and optionally tags, to create images. There is a limit of 64
   350  // images and 20 tags.
   351  // Parameters:
   352  // projectID - the project id
   353  // batch - image urls and tag ids. Limited to 64 images and 20 tags per batch
   354  func (client BaseClient) CreateImagesFromUrls(ctx context.Context, projectID uuid.UUID, batch ImageURLCreateBatch) (result ImageCreateSummary, err error) {
   355  	if tracing.IsEnabled() {
   356  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImagesFromUrls")
   357  		defer func() {
   358  			sc := -1
   359  			if result.Response.Response != nil {
   360  				sc = result.Response.Response.StatusCode
   361  			}
   362  			tracing.EndSpan(ctx, sc, err)
   363  		}()
   364  	}
   365  	req, err := client.CreateImagesFromUrlsPreparer(ctx, projectID, batch)
   366  	if err != nil {
   367  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromUrls", nil, "Failure preparing request")
   368  		return
   369  	}
   370  
   371  	resp, err := client.CreateImagesFromUrlsSender(req)
   372  	if err != nil {
   373  		result.Response = autorest.Response{Response: resp}
   374  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromUrls", resp, "Failure sending request")
   375  		return
   376  	}
   377  
   378  	result, err = client.CreateImagesFromUrlsResponder(resp)
   379  	if err != nil {
   380  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImagesFromUrls", resp, "Failure responding to request")
   381  		return
   382  	}
   383  
   384  	return
   385  }
   386  
   387  // CreateImagesFromUrlsPreparer prepares the CreateImagesFromUrls request.
   388  func (client BaseClient) CreateImagesFromUrlsPreparer(ctx context.Context, projectID uuid.UUID, batch ImageURLCreateBatch) (*http.Request, error) {
   389  	pathParameters := map[string]interface{}{
   390  		"projectId": autorest.Encode("path", projectID),
   391  	}
   392  
   393  	preparer := autorest.CreatePreparer(
   394  		autorest.AsContentType("application/json; charset=utf-8"),
   395  		autorest.AsPost(),
   396  		autorest.WithBaseURL(client.BaseURI),
   397  		autorest.WithPathParameters("/projects/{projectId}/images/urls", pathParameters),
   398  		autorest.WithJSON(batch),
   399  		autorest.WithHeader("Training-Key", client.APIKey))
   400  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   401  }
   402  
   403  // CreateImagesFromUrlsSender sends the CreateImagesFromUrls request. The method will close the
   404  // http.Response Body if it receives an error.
   405  func (client BaseClient) CreateImagesFromUrlsSender(req *http.Request) (*http.Response, error) {
   406  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   407  }
   408  
   409  // CreateImagesFromUrlsResponder handles the response to the CreateImagesFromUrls request. The method always
   410  // closes the http.Response Body.
   411  func (client BaseClient) CreateImagesFromUrlsResponder(resp *http.Response) (result ImageCreateSummary, err error) {
   412  	err = autorest.Respond(
   413  		resp,
   414  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   415  		autorest.ByUnmarshallingJSON(&result),
   416  		autorest.ByClosing())
   417  	result.Response = autorest.Response{Response: resp}
   418  	return
   419  }
   420  
   421  // CreateImageTags sends the create image tags request.
   422  // Parameters:
   423  // projectID - the project id
   424  // batch - batch of image tags. Limited to 128 tags per batch
   425  func (client BaseClient) CreateImageTags(ctx context.Context, projectID uuid.UUID, batch ImageTagCreateBatch) (result ImageTagCreateSummary, err error) {
   426  	if tracing.IsEnabled() {
   427  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateImageTags")
   428  		defer func() {
   429  			sc := -1
   430  			if result.Response.Response != nil {
   431  				sc = result.Response.Response.StatusCode
   432  			}
   433  			tracing.EndSpan(ctx, sc, err)
   434  		}()
   435  	}
   436  	req, err := client.CreateImageTagsPreparer(ctx, projectID, batch)
   437  	if err != nil {
   438  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageTags", nil, "Failure preparing request")
   439  		return
   440  	}
   441  
   442  	resp, err := client.CreateImageTagsSender(req)
   443  	if err != nil {
   444  		result.Response = autorest.Response{Response: resp}
   445  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageTags", resp, "Failure sending request")
   446  		return
   447  	}
   448  
   449  	result, err = client.CreateImageTagsResponder(resp)
   450  	if err != nil {
   451  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateImageTags", resp, "Failure responding to request")
   452  		return
   453  	}
   454  
   455  	return
   456  }
   457  
   458  // CreateImageTagsPreparer prepares the CreateImageTags request.
   459  func (client BaseClient) CreateImageTagsPreparer(ctx context.Context, projectID uuid.UUID, batch ImageTagCreateBatch) (*http.Request, error) {
   460  	pathParameters := map[string]interface{}{
   461  		"projectId": autorest.Encode("path", projectID),
   462  	}
   463  
   464  	preparer := autorest.CreatePreparer(
   465  		autorest.AsContentType("application/json; charset=utf-8"),
   466  		autorest.AsPost(),
   467  		autorest.WithBaseURL(client.BaseURI),
   468  		autorest.WithPathParameters("/projects/{projectId}/images/tags", pathParameters),
   469  		autorest.WithJSON(batch),
   470  		autorest.WithHeader("Training-Key", client.APIKey))
   471  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   472  }
   473  
   474  // CreateImageTagsSender sends the CreateImageTags request. The method will close the
   475  // http.Response Body if it receives an error.
   476  func (client BaseClient) CreateImageTagsSender(req *http.Request) (*http.Response, error) {
   477  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   478  }
   479  
   480  // CreateImageTagsResponder handles the response to the CreateImageTags request. The method always
   481  // closes the http.Response Body.
   482  func (client BaseClient) CreateImageTagsResponder(resp *http.Response) (result ImageTagCreateSummary, err error) {
   483  	err = autorest.Respond(
   484  		resp,
   485  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   486  		autorest.ByUnmarshallingJSON(&result),
   487  		autorest.ByClosing())
   488  	result.Response = autorest.Response{Response: resp}
   489  	return
   490  }
   491  
   492  // CreateProject sends the create project request.
   493  // Parameters:
   494  // name - name of the project
   495  // description - the description of the project
   496  // domainID - the id of the domain to use for this project. Defaults to General
   497  // classificationType - the type of classifier to create for this project
   498  func (client BaseClient) CreateProject(ctx context.Context, name string, description string, domainID *uuid.UUID, classificationType string) (result Project, err error) {
   499  	if tracing.IsEnabled() {
   500  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateProject")
   501  		defer func() {
   502  			sc := -1
   503  			if result.Response.Response != nil {
   504  				sc = result.Response.Response.StatusCode
   505  			}
   506  			tracing.EndSpan(ctx, sc, err)
   507  		}()
   508  	}
   509  	req, err := client.CreateProjectPreparer(ctx, name, description, domainID, classificationType)
   510  	if err != nil {
   511  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateProject", nil, "Failure preparing request")
   512  		return
   513  	}
   514  
   515  	resp, err := client.CreateProjectSender(req)
   516  	if err != nil {
   517  		result.Response = autorest.Response{Response: resp}
   518  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateProject", resp, "Failure sending request")
   519  		return
   520  	}
   521  
   522  	result, err = client.CreateProjectResponder(resp)
   523  	if err != nil {
   524  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateProject", resp, "Failure responding to request")
   525  		return
   526  	}
   527  
   528  	return
   529  }
   530  
   531  // CreateProjectPreparer prepares the CreateProject request.
   532  func (client BaseClient) CreateProjectPreparer(ctx context.Context, name string, description string, domainID *uuid.UUID, classificationType string) (*http.Request, error) {
   533  	queryParameters := map[string]interface{}{
   534  		"name": autorest.Encode("query", name),
   535  	}
   536  	if len(description) > 0 {
   537  		queryParameters["description"] = autorest.Encode("query", description)
   538  	}
   539  	if domainID != nil {
   540  		queryParameters["domainId"] = autorest.Encode("query", *domainID)
   541  	}
   542  	if len(string(classificationType)) > 0 {
   543  		queryParameters["classificationType"] = autorest.Encode("query", classificationType)
   544  	}
   545  
   546  	preparer := autorest.CreatePreparer(
   547  		autorest.AsPost(),
   548  		autorest.WithBaseURL(client.BaseURI),
   549  		autorest.WithPath("/projects"),
   550  		autorest.WithQueryParameters(queryParameters),
   551  		autorest.WithHeader("Training-Key", client.APIKey))
   552  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   553  }
   554  
   555  // CreateProjectSender sends the CreateProject request. The method will close the
   556  // http.Response Body if it receives an error.
   557  func (client BaseClient) CreateProjectSender(req *http.Request) (*http.Response, error) {
   558  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   559  }
   560  
   561  // CreateProjectResponder handles the response to the CreateProject request. The method always
   562  // closes the http.Response Body.
   563  func (client BaseClient) CreateProjectResponder(resp *http.Response) (result Project, err error) {
   564  	err = autorest.Respond(
   565  		resp,
   566  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   567  		autorest.ByUnmarshallingJSON(&result),
   568  		autorest.ByClosing())
   569  	result.Response = autorest.Response{Response: resp}
   570  	return
   571  }
   572  
   573  // CreateTag sends the create tag request.
   574  // Parameters:
   575  // projectID - the project id
   576  // name - the tag name
   577  // description - optional description for the tag
   578  func (client BaseClient) CreateTag(ctx context.Context, projectID uuid.UUID, name string, description string) (result Tag, err error) {
   579  	if tracing.IsEnabled() {
   580  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CreateTag")
   581  		defer func() {
   582  			sc := -1
   583  			if result.Response.Response != nil {
   584  				sc = result.Response.Response.StatusCode
   585  			}
   586  			tracing.EndSpan(ctx, sc, err)
   587  		}()
   588  	}
   589  	req, err := client.CreateTagPreparer(ctx, projectID, name, description)
   590  	if err != nil {
   591  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateTag", nil, "Failure preparing request")
   592  		return
   593  	}
   594  
   595  	resp, err := client.CreateTagSender(req)
   596  	if err != nil {
   597  		result.Response = autorest.Response{Response: resp}
   598  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateTag", resp, "Failure sending request")
   599  		return
   600  	}
   601  
   602  	result, err = client.CreateTagResponder(resp)
   603  	if err != nil {
   604  		err = autorest.NewErrorWithError(err, "training.BaseClient", "CreateTag", resp, "Failure responding to request")
   605  		return
   606  	}
   607  
   608  	return
   609  }
   610  
   611  // CreateTagPreparer prepares the CreateTag request.
   612  func (client BaseClient) CreateTagPreparer(ctx context.Context, projectID uuid.UUID, name string, description string) (*http.Request, error) {
   613  	pathParameters := map[string]interface{}{
   614  		"projectId": autorest.Encode("path", projectID),
   615  	}
   616  
   617  	queryParameters := map[string]interface{}{
   618  		"name": autorest.Encode("query", name),
   619  	}
   620  	if len(description) > 0 {
   621  		queryParameters["description"] = autorest.Encode("query", description)
   622  	}
   623  
   624  	preparer := autorest.CreatePreparer(
   625  		autorest.AsPost(),
   626  		autorest.WithBaseURL(client.BaseURI),
   627  		autorest.WithPathParameters("/projects/{projectId}/tags", pathParameters),
   628  		autorest.WithQueryParameters(queryParameters),
   629  		autorest.WithHeader("Training-Key", client.APIKey))
   630  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   631  }
   632  
   633  // CreateTagSender sends the CreateTag request. The method will close the
   634  // http.Response Body if it receives an error.
   635  func (client BaseClient) CreateTagSender(req *http.Request) (*http.Response, error) {
   636  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   637  }
   638  
   639  // CreateTagResponder handles the response to the CreateTag request. The method always
   640  // closes the http.Response Body.
   641  func (client BaseClient) CreateTagResponder(resp *http.Response) (result Tag, err error) {
   642  	err = autorest.Respond(
   643  		resp,
   644  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   645  		autorest.ByUnmarshallingJSON(&result),
   646  		autorest.ByClosing())
   647  	result.Response = autorest.Response{Response: resp}
   648  	return
   649  }
   650  
   651  // DeleteImageRegions sends the delete image regions request.
   652  // Parameters:
   653  // projectID - the project id
   654  // regionIds - regions to delete. Limited to 64
   655  func (client BaseClient) DeleteImageRegions(ctx context.Context, projectID uuid.UUID, regionIds []string) (result autorest.Response, err error) {
   656  	if tracing.IsEnabled() {
   657  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteImageRegions")
   658  		defer func() {
   659  			sc := -1
   660  			if result.Response != nil {
   661  				sc = result.Response.StatusCode
   662  			}
   663  			tracing.EndSpan(ctx, sc, err)
   664  		}()
   665  	}
   666  	if err := validation.Validate([]validation.Validation{
   667  		{TargetValue: regionIds,
   668  			Constraints: []validation.Constraint{{Target: "regionIds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   669  		return result, validation.NewError("training.BaseClient", "DeleteImageRegions", err.Error())
   670  	}
   671  
   672  	req, err := client.DeleteImageRegionsPreparer(ctx, projectID, regionIds)
   673  	if err != nil {
   674  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageRegions", nil, "Failure preparing request")
   675  		return
   676  	}
   677  
   678  	resp, err := client.DeleteImageRegionsSender(req)
   679  	if err != nil {
   680  		result.Response = resp
   681  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageRegions", resp, "Failure sending request")
   682  		return
   683  	}
   684  
   685  	result, err = client.DeleteImageRegionsResponder(resp)
   686  	if err != nil {
   687  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageRegions", resp, "Failure responding to request")
   688  		return
   689  	}
   690  
   691  	return
   692  }
   693  
   694  // DeleteImageRegionsPreparer prepares the DeleteImageRegions request.
   695  func (client BaseClient) DeleteImageRegionsPreparer(ctx context.Context, projectID uuid.UUID, regionIds []string) (*http.Request, error) {
   696  	pathParameters := map[string]interface{}{
   697  		"projectId": autorest.Encode("path", projectID),
   698  	}
   699  
   700  	queryParameters := map[string]interface{}{
   701  		"regionIds": autorest.Encode("query", regionIds, ","),
   702  	}
   703  
   704  	preparer := autorest.CreatePreparer(
   705  		autorest.AsDelete(),
   706  		autorest.WithBaseURL(client.BaseURI),
   707  		autorest.WithPathParameters("/projects/{projectId}/images/regions", pathParameters),
   708  		autorest.WithQueryParameters(queryParameters),
   709  		autorest.WithHeader("Training-Key", client.APIKey))
   710  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   711  }
   712  
   713  // DeleteImageRegionsSender sends the DeleteImageRegions request. The method will close the
   714  // http.Response Body if it receives an error.
   715  func (client BaseClient) DeleteImageRegionsSender(req *http.Request) (*http.Response, error) {
   716  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   717  }
   718  
   719  // DeleteImageRegionsResponder handles the response to the DeleteImageRegions request. The method always
   720  // closes the http.Response Body.
   721  func (client BaseClient) DeleteImageRegionsResponder(resp *http.Response) (result autorest.Response, err error) {
   722  	err = autorest.Respond(
   723  		resp,
   724  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   725  		autorest.ByClosing())
   726  	result.Response = resp
   727  	return
   728  }
   729  
   730  // DeleteImages sends the delete images request.
   731  // Parameters:
   732  // projectID - the project id
   733  // imageIds - ids of the images to be deleted. Limited to 256 images per batch
   734  func (client BaseClient) DeleteImages(ctx context.Context, projectID uuid.UUID, imageIds []string) (result autorest.Response, err error) {
   735  	if tracing.IsEnabled() {
   736  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteImages")
   737  		defer func() {
   738  			sc := -1
   739  			if result.Response != nil {
   740  				sc = result.Response.StatusCode
   741  			}
   742  			tracing.EndSpan(ctx, sc, err)
   743  		}()
   744  	}
   745  	if err := validation.Validate([]validation.Validation{
   746  		{TargetValue: imageIds,
   747  			Constraints: []validation.Constraint{{Target: "imageIds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   748  		return result, validation.NewError("training.BaseClient", "DeleteImages", err.Error())
   749  	}
   750  
   751  	req, err := client.DeleteImagesPreparer(ctx, projectID, imageIds)
   752  	if err != nil {
   753  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImages", nil, "Failure preparing request")
   754  		return
   755  	}
   756  
   757  	resp, err := client.DeleteImagesSender(req)
   758  	if err != nil {
   759  		result.Response = resp
   760  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImages", resp, "Failure sending request")
   761  		return
   762  	}
   763  
   764  	result, err = client.DeleteImagesResponder(resp)
   765  	if err != nil {
   766  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImages", resp, "Failure responding to request")
   767  		return
   768  	}
   769  
   770  	return
   771  }
   772  
   773  // DeleteImagesPreparer prepares the DeleteImages request.
   774  func (client BaseClient) DeleteImagesPreparer(ctx context.Context, projectID uuid.UUID, imageIds []string) (*http.Request, error) {
   775  	pathParameters := map[string]interface{}{
   776  		"projectId": autorest.Encode("path", projectID),
   777  	}
   778  
   779  	queryParameters := map[string]interface{}{
   780  		"imageIds": autorest.Encode("query", imageIds, ","),
   781  	}
   782  
   783  	preparer := autorest.CreatePreparer(
   784  		autorest.AsDelete(),
   785  		autorest.WithBaseURL(client.BaseURI),
   786  		autorest.WithPathParameters("/projects/{projectId}/images", pathParameters),
   787  		autorest.WithQueryParameters(queryParameters),
   788  		autorest.WithHeader("Training-Key", client.APIKey))
   789  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   790  }
   791  
   792  // DeleteImagesSender sends the DeleteImages request. The method will close the
   793  // http.Response Body if it receives an error.
   794  func (client BaseClient) DeleteImagesSender(req *http.Request) (*http.Response, error) {
   795  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   796  }
   797  
   798  // DeleteImagesResponder handles the response to the DeleteImages request. The method always
   799  // closes the http.Response Body.
   800  func (client BaseClient) DeleteImagesResponder(resp *http.Response) (result autorest.Response, err error) {
   801  	err = autorest.Respond(
   802  		resp,
   803  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   804  		autorest.ByClosing())
   805  	result.Response = resp
   806  	return
   807  }
   808  
   809  // DeleteImageTags sends the delete image tags request.
   810  // Parameters:
   811  // projectID - the project id
   812  // imageIds - image ids. Limited to 64 images
   813  // tagIds - tags to be deleted from the specified images. Limited to 20 tags
   814  func (client BaseClient) DeleteImageTags(ctx context.Context, projectID uuid.UUID, imageIds []string, tagIds []string) (result autorest.Response, err error) {
   815  	if tracing.IsEnabled() {
   816  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteImageTags")
   817  		defer func() {
   818  			sc := -1
   819  			if result.Response != nil {
   820  				sc = result.Response.StatusCode
   821  			}
   822  			tracing.EndSpan(ctx, sc, err)
   823  		}()
   824  	}
   825  	if err := validation.Validate([]validation.Validation{
   826  		{TargetValue: imageIds,
   827  			Constraints: []validation.Constraint{{Target: "imageIds", Name: validation.Null, Rule: true, Chain: nil}}},
   828  		{TargetValue: tagIds,
   829  			Constraints: []validation.Constraint{{Target: "tagIds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   830  		return result, validation.NewError("training.BaseClient", "DeleteImageTags", err.Error())
   831  	}
   832  
   833  	req, err := client.DeleteImageTagsPreparer(ctx, projectID, imageIds, tagIds)
   834  	if err != nil {
   835  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageTags", nil, "Failure preparing request")
   836  		return
   837  	}
   838  
   839  	resp, err := client.DeleteImageTagsSender(req)
   840  	if err != nil {
   841  		result.Response = resp
   842  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageTags", resp, "Failure sending request")
   843  		return
   844  	}
   845  
   846  	result, err = client.DeleteImageTagsResponder(resp)
   847  	if err != nil {
   848  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteImageTags", resp, "Failure responding to request")
   849  		return
   850  	}
   851  
   852  	return
   853  }
   854  
   855  // DeleteImageTagsPreparer prepares the DeleteImageTags request.
   856  func (client BaseClient) DeleteImageTagsPreparer(ctx context.Context, projectID uuid.UUID, imageIds []string, tagIds []string) (*http.Request, error) {
   857  	pathParameters := map[string]interface{}{
   858  		"projectId": autorest.Encode("path", projectID),
   859  	}
   860  
   861  	queryParameters := map[string]interface{}{
   862  		"imageIds": autorest.Encode("query", imageIds, ","),
   863  		"tagIds":   autorest.Encode("query", tagIds, ","),
   864  	}
   865  
   866  	preparer := autorest.CreatePreparer(
   867  		autorest.AsDelete(),
   868  		autorest.WithBaseURL(client.BaseURI),
   869  		autorest.WithPathParameters("/projects/{projectId}/images/tags", pathParameters),
   870  		autorest.WithQueryParameters(queryParameters),
   871  		autorest.WithHeader("Training-Key", client.APIKey))
   872  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   873  }
   874  
   875  // DeleteImageTagsSender sends the DeleteImageTags request. The method will close the
   876  // http.Response Body if it receives an error.
   877  func (client BaseClient) DeleteImageTagsSender(req *http.Request) (*http.Response, error) {
   878  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   879  }
   880  
   881  // DeleteImageTagsResponder handles the response to the DeleteImageTags request. The method always
   882  // closes the http.Response Body.
   883  func (client BaseClient) DeleteImageTagsResponder(resp *http.Response) (result autorest.Response, err error) {
   884  	err = autorest.Respond(
   885  		resp,
   886  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   887  		autorest.ByClosing())
   888  	result.Response = resp
   889  	return
   890  }
   891  
   892  // DeleteIteration sends the delete iteration request.
   893  // Parameters:
   894  // projectID - the project id
   895  // iterationID - the iteration id
   896  func (client BaseClient) DeleteIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (result autorest.Response, err error) {
   897  	if tracing.IsEnabled() {
   898  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteIteration")
   899  		defer func() {
   900  			sc := -1
   901  			if result.Response != nil {
   902  				sc = result.Response.StatusCode
   903  			}
   904  			tracing.EndSpan(ctx, sc, err)
   905  		}()
   906  	}
   907  	req, err := client.DeleteIterationPreparer(ctx, projectID, iterationID)
   908  	if err != nil {
   909  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteIteration", nil, "Failure preparing request")
   910  		return
   911  	}
   912  
   913  	resp, err := client.DeleteIterationSender(req)
   914  	if err != nil {
   915  		result.Response = resp
   916  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteIteration", resp, "Failure sending request")
   917  		return
   918  	}
   919  
   920  	result, err = client.DeleteIterationResponder(resp)
   921  	if err != nil {
   922  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteIteration", resp, "Failure responding to request")
   923  		return
   924  	}
   925  
   926  	return
   927  }
   928  
   929  // DeleteIterationPreparer prepares the DeleteIteration request.
   930  func (client BaseClient) DeleteIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (*http.Request, error) {
   931  	pathParameters := map[string]interface{}{
   932  		"iterationId": autorest.Encode("path", iterationID),
   933  		"projectId":   autorest.Encode("path", projectID),
   934  	}
   935  
   936  	preparer := autorest.CreatePreparer(
   937  		autorest.AsDelete(),
   938  		autorest.WithBaseURL(client.BaseURI),
   939  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}", pathParameters),
   940  		autorest.WithHeader("Training-Key", client.APIKey))
   941  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   942  }
   943  
   944  // DeleteIterationSender sends the DeleteIteration request. The method will close the
   945  // http.Response Body if it receives an error.
   946  func (client BaseClient) DeleteIterationSender(req *http.Request) (*http.Response, error) {
   947  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   948  }
   949  
   950  // DeleteIterationResponder handles the response to the DeleteIteration request. The method always
   951  // closes the http.Response Body.
   952  func (client BaseClient) DeleteIterationResponder(resp *http.Response) (result autorest.Response, err error) {
   953  	err = autorest.Respond(
   954  		resp,
   955  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   956  		autorest.ByClosing())
   957  	result.Response = resp
   958  	return
   959  }
   960  
   961  // DeletePrediction sends the delete prediction request.
   962  // Parameters:
   963  // projectID - the project id
   964  // ids - the prediction ids. Limited to 64
   965  func (client BaseClient) DeletePrediction(ctx context.Context, projectID uuid.UUID, ids []string) (result autorest.Response, err error) {
   966  	if tracing.IsEnabled() {
   967  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeletePrediction")
   968  		defer func() {
   969  			sc := -1
   970  			if result.Response != nil {
   971  				sc = result.Response.StatusCode
   972  			}
   973  			tracing.EndSpan(ctx, sc, err)
   974  		}()
   975  	}
   976  	if err := validation.Validate([]validation.Validation{
   977  		{TargetValue: ids,
   978  			Constraints: []validation.Constraint{{Target: "ids", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   979  		return result, validation.NewError("training.BaseClient", "DeletePrediction", err.Error())
   980  	}
   981  
   982  	req, err := client.DeletePredictionPreparer(ctx, projectID, ids)
   983  	if err != nil {
   984  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeletePrediction", nil, "Failure preparing request")
   985  		return
   986  	}
   987  
   988  	resp, err := client.DeletePredictionSender(req)
   989  	if err != nil {
   990  		result.Response = resp
   991  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeletePrediction", resp, "Failure sending request")
   992  		return
   993  	}
   994  
   995  	result, err = client.DeletePredictionResponder(resp)
   996  	if err != nil {
   997  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeletePrediction", resp, "Failure responding to request")
   998  		return
   999  	}
  1000  
  1001  	return
  1002  }
  1003  
  1004  // DeletePredictionPreparer prepares the DeletePrediction request.
  1005  func (client BaseClient) DeletePredictionPreparer(ctx context.Context, projectID uuid.UUID, ids []string) (*http.Request, error) {
  1006  	pathParameters := map[string]interface{}{
  1007  		"projectId": autorest.Encode("path", projectID),
  1008  	}
  1009  
  1010  	queryParameters := map[string]interface{}{
  1011  		"ids": autorest.Encode("query", ids, ","),
  1012  	}
  1013  
  1014  	preparer := autorest.CreatePreparer(
  1015  		autorest.AsDelete(),
  1016  		autorest.WithBaseURL(client.BaseURI),
  1017  		autorest.WithPathParameters("/projects/{projectId}/predictions", pathParameters),
  1018  		autorest.WithQueryParameters(queryParameters),
  1019  		autorest.WithHeader("Training-Key", client.APIKey))
  1020  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1021  }
  1022  
  1023  // DeletePredictionSender sends the DeletePrediction request. The method will close the
  1024  // http.Response Body if it receives an error.
  1025  func (client BaseClient) DeletePredictionSender(req *http.Request) (*http.Response, error) {
  1026  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1027  }
  1028  
  1029  // DeletePredictionResponder handles the response to the DeletePrediction request. The method always
  1030  // closes the http.Response Body.
  1031  func (client BaseClient) DeletePredictionResponder(resp *http.Response) (result autorest.Response, err error) {
  1032  	err = autorest.Respond(
  1033  		resp,
  1034  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1035  		autorest.ByClosing())
  1036  	result.Response = resp
  1037  	return
  1038  }
  1039  
  1040  // DeleteProject sends the delete project request.
  1041  // Parameters:
  1042  // projectID - the project id
  1043  func (client BaseClient) DeleteProject(ctx context.Context, projectID uuid.UUID) (result autorest.Response, err error) {
  1044  	if tracing.IsEnabled() {
  1045  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteProject")
  1046  		defer func() {
  1047  			sc := -1
  1048  			if result.Response != nil {
  1049  				sc = result.Response.StatusCode
  1050  			}
  1051  			tracing.EndSpan(ctx, sc, err)
  1052  		}()
  1053  	}
  1054  	req, err := client.DeleteProjectPreparer(ctx, projectID)
  1055  	if err != nil {
  1056  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteProject", nil, "Failure preparing request")
  1057  		return
  1058  	}
  1059  
  1060  	resp, err := client.DeleteProjectSender(req)
  1061  	if err != nil {
  1062  		result.Response = resp
  1063  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteProject", resp, "Failure sending request")
  1064  		return
  1065  	}
  1066  
  1067  	result, err = client.DeleteProjectResponder(resp)
  1068  	if err != nil {
  1069  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteProject", resp, "Failure responding to request")
  1070  		return
  1071  	}
  1072  
  1073  	return
  1074  }
  1075  
  1076  // DeleteProjectPreparer prepares the DeleteProject request.
  1077  func (client BaseClient) DeleteProjectPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  1078  	pathParameters := map[string]interface{}{
  1079  		"projectId": autorest.Encode("path", projectID),
  1080  	}
  1081  
  1082  	preparer := autorest.CreatePreparer(
  1083  		autorest.AsDelete(),
  1084  		autorest.WithBaseURL(client.BaseURI),
  1085  		autorest.WithPathParameters("/projects/{projectId}", pathParameters),
  1086  		autorest.WithHeader("Training-Key", client.APIKey))
  1087  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1088  }
  1089  
  1090  // DeleteProjectSender sends the DeleteProject request. The method will close the
  1091  // http.Response Body if it receives an error.
  1092  func (client BaseClient) DeleteProjectSender(req *http.Request) (*http.Response, error) {
  1093  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1094  }
  1095  
  1096  // DeleteProjectResponder handles the response to the DeleteProject request. The method always
  1097  // closes the http.Response Body.
  1098  func (client BaseClient) DeleteProjectResponder(resp *http.Response) (result autorest.Response, err error) {
  1099  	err = autorest.Respond(
  1100  		resp,
  1101  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1102  		autorest.ByClosing())
  1103  	result.Response = resp
  1104  	return
  1105  }
  1106  
  1107  // DeleteTag sends the delete tag request.
  1108  // Parameters:
  1109  // projectID - the project id
  1110  // tagID - id of the tag to be deleted
  1111  func (client BaseClient) DeleteTag(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID) (result autorest.Response, err error) {
  1112  	if tracing.IsEnabled() {
  1113  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DeleteTag")
  1114  		defer func() {
  1115  			sc := -1
  1116  			if result.Response != nil {
  1117  				sc = result.Response.StatusCode
  1118  			}
  1119  			tracing.EndSpan(ctx, sc, err)
  1120  		}()
  1121  	}
  1122  	req, err := client.DeleteTagPreparer(ctx, projectID, tagID)
  1123  	if err != nil {
  1124  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteTag", nil, "Failure preparing request")
  1125  		return
  1126  	}
  1127  
  1128  	resp, err := client.DeleteTagSender(req)
  1129  	if err != nil {
  1130  		result.Response = resp
  1131  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteTag", resp, "Failure sending request")
  1132  		return
  1133  	}
  1134  
  1135  	result, err = client.DeleteTagResponder(resp)
  1136  	if err != nil {
  1137  		err = autorest.NewErrorWithError(err, "training.BaseClient", "DeleteTag", resp, "Failure responding to request")
  1138  		return
  1139  	}
  1140  
  1141  	return
  1142  }
  1143  
  1144  // DeleteTagPreparer prepares the DeleteTag request.
  1145  func (client BaseClient) DeleteTagPreparer(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID) (*http.Request, error) {
  1146  	pathParameters := map[string]interface{}{
  1147  		"projectId": autorest.Encode("path", projectID),
  1148  		"tagId":     autorest.Encode("path", tagID),
  1149  	}
  1150  
  1151  	preparer := autorest.CreatePreparer(
  1152  		autorest.AsDelete(),
  1153  		autorest.WithBaseURL(client.BaseURI),
  1154  		autorest.WithPathParameters("/projects/{projectId}/tags/{tagId}", pathParameters),
  1155  		autorest.WithHeader("Training-Key", client.APIKey))
  1156  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1157  }
  1158  
  1159  // DeleteTagSender sends the DeleteTag request. The method will close the
  1160  // http.Response Body if it receives an error.
  1161  func (client BaseClient) DeleteTagSender(req *http.Request) (*http.Response, error) {
  1162  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1163  }
  1164  
  1165  // DeleteTagResponder handles the response to the DeleteTag request. The method always
  1166  // closes the http.Response Body.
  1167  func (client BaseClient) DeleteTagResponder(resp *http.Response) (result autorest.Response, err error) {
  1168  	err = autorest.Respond(
  1169  		resp,
  1170  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
  1171  		autorest.ByClosing())
  1172  	result.Response = resp
  1173  	return
  1174  }
  1175  
  1176  // ExportIteration sends the export iteration request.
  1177  // Parameters:
  1178  // projectID - the project id
  1179  // iterationID - the iteration id
  1180  // platform - the target platform (coreml or tensorflow)
  1181  // flavor - the flavor of the target platform (Windows, Linux, ARM, or GPU)
  1182  func (client BaseClient) ExportIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, platform string, flavor string) (result Export, err error) {
  1183  	if tracing.IsEnabled() {
  1184  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.ExportIteration")
  1185  		defer func() {
  1186  			sc := -1
  1187  			if result.Response.Response != nil {
  1188  				sc = result.Response.Response.StatusCode
  1189  			}
  1190  			tracing.EndSpan(ctx, sc, err)
  1191  		}()
  1192  	}
  1193  	req, err := client.ExportIterationPreparer(ctx, projectID, iterationID, platform, flavor)
  1194  	if err != nil {
  1195  		err = autorest.NewErrorWithError(err, "training.BaseClient", "ExportIteration", nil, "Failure preparing request")
  1196  		return
  1197  	}
  1198  
  1199  	resp, err := client.ExportIterationSender(req)
  1200  	if err != nil {
  1201  		result.Response = autorest.Response{Response: resp}
  1202  		err = autorest.NewErrorWithError(err, "training.BaseClient", "ExportIteration", resp, "Failure sending request")
  1203  		return
  1204  	}
  1205  
  1206  	result, err = client.ExportIterationResponder(resp)
  1207  	if err != nil {
  1208  		err = autorest.NewErrorWithError(err, "training.BaseClient", "ExportIteration", resp, "Failure responding to request")
  1209  		return
  1210  	}
  1211  
  1212  	return
  1213  }
  1214  
  1215  // ExportIterationPreparer prepares the ExportIteration request.
  1216  func (client BaseClient) ExportIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, platform string, flavor string) (*http.Request, error) {
  1217  	pathParameters := map[string]interface{}{
  1218  		"iterationId": autorest.Encode("path", iterationID),
  1219  		"projectId":   autorest.Encode("path", projectID),
  1220  	}
  1221  
  1222  	queryParameters := map[string]interface{}{
  1223  		"platform": autorest.Encode("query", platform),
  1224  	}
  1225  	if len(string(flavor)) > 0 {
  1226  		queryParameters["flavor"] = autorest.Encode("query", flavor)
  1227  	}
  1228  
  1229  	preparer := autorest.CreatePreparer(
  1230  		autorest.AsPost(),
  1231  		autorest.WithBaseURL(client.BaseURI),
  1232  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/export", pathParameters),
  1233  		autorest.WithQueryParameters(queryParameters),
  1234  		autorest.WithHeader("Training-Key", client.APIKey))
  1235  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1236  }
  1237  
  1238  // ExportIterationSender sends the ExportIteration request. The method will close the
  1239  // http.Response Body if it receives an error.
  1240  func (client BaseClient) ExportIterationSender(req *http.Request) (*http.Response, error) {
  1241  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1242  }
  1243  
  1244  // ExportIterationResponder handles the response to the ExportIteration request. The method always
  1245  // closes the http.Response Body.
  1246  func (client BaseClient) ExportIterationResponder(resp *http.Response) (result Export, err error) {
  1247  	err = autorest.Respond(
  1248  		resp,
  1249  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1250  		autorest.ByUnmarshallingJSON(&result),
  1251  		autorest.ByClosing())
  1252  	result.Response = autorest.Response{Response: resp}
  1253  	return
  1254  }
  1255  
  1256  // GetDomain sends the get domain request.
  1257  // Parameters:
  1258  // domainID - the id of the domain to get information about
  1259  func (client BaseClient) GetDomain(ctx context.Context, domainID uuid.UUID) (result Domain, err error) {
  1260  	if tracing.IsEnabled() {
  1261  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetDomain")
  1262  		defer func() {
  1263  			sc := -1
  1264  			if result.Response.Response != nil {
  1265  				sc = result.Response.Response.StatusCode
  1266  			}
  1267  			tracing.EndSpan(ctx, sc, err)
  1268  		}()
  1269  	}
  1270  	req, err := client.GetDomainPreparer(ctx, domainID)
  1271  	if err != nil {
  1272  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomain", nil, "Failure preparing request")
  1273  		return
  1274  	}
  1275  
  1276  	resp, err := client.GetDomainSender(req)
  1277  	if err != nil {
  1278  		result.Response = autorest.Response{Response: resp}
  1279  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomain", resp, "Failure sending request")
  1280  		return
  1281  	}
  1282  
  1283  	result, err = client.GetDomainResponder(resp)
  1284  	if err != nil {
  1285  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomain", resp, "Failure responding to request")
  1286  		return
  1287  	}
  1288  
  1289  	return
  1290  }
  1291  
  1292  // GetDomainPreparer prepares the GetDomain request.
  1293  func (client BaseClient) GetDomainPreparer(ctx context.Context, domainID uuid.UUID) (*http.Request, error) {
  1294  	pathParameters := map[string]interface{}{
  1295  		"domainId": autorest.Encode("path", domainID),
  1296  	}
  1297  
  1298  	preparer := autorest.CreatePreparer(
  1299  		autorest.AsGet(),
  1300  		autorest.WithBaseURL(client.BaseURI),
  1301  		autorest.WithPathParameters("/domains/{domainId}", pathParameters),
  1302  		autorest.WithHeader("Training-Key", client.APIKey))
  1303  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1304  }
  1305  
  1306  // GetDomainSender sends the GetDomain request. The method will close the
  1307  // http.Response Body if it receives an error.
  1308  func (client BaseClient) GetDomainSender(req *http.Request) (*http.Response, error) {
  1309  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1310  }
  1311  
  1312  // GetDomainResponder handles the response to the GetDomain request. The method always
  1313  // closes the http.Response Body.
  1314  func (client BaseClient) GetDomainResponder(resp *http.Response) (result Domain, err error) {
  1315  	err = autorest.Respond(
  1316  		resp,
  1317  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1318  		autorest.ByUnmarshallingJSON(&result),
  1319  		autorest.ByClosing())
  1320  	result.Response = autorest.Response{Response: resp}
  1321  	return
  1322  }
  1323  
  1324  // GetDomains sends the get domains request.
  1325  func (client BaseClient) GetDomains(ctx context.Context) (result ListDomain, err error) {
  1326  	if tracing.IsEnabled() {
  1327  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetDomains")
  1328  		defer func() {
  1329  			sc := -1
  1330  			if result.Response.Response != nil {
  1331  				sc = result.Response.Response.StatusCode
  1332  			}
  1333  			tracing.EndSpan(ctx, sc, err)
  1334  		}()
  1335  	}
  1336  	req, err := client.GetDomainsPreparer(ctx)
  1337  	if err != nil {
  1338  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomains", nil, "Failure preparing request")
  1339  		return
  1340  	}
  1341  
  1342  	resp, err := client.GetDomainsSender(req)
  1343  	if err != nil {
  1344  		result.Response = autorest.Response{Response: resp}
  1345  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomains", resp, "Failure sending request")
  1346  		return
  1347  	}
  1348  
  1349  	result, err = client.GetDomainsResponder(resp)
  1350  	if err != nil {
  1351  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetDomains", resp, "Failure responding to request")
  1352  		return
  1353  	}
  1354  
  1355  	return
  1356  }
  1357  
  1358  // GetDomainsPreparer prepares the GetDomains request.
  1359  func (client BaseClient) GetDomainsPreparer(ctx context.Context) (*http.Request, error) {
  1360  	preparer := autorest.CreatePreparer(
  1361  		autorest.AsGet(),
  1362  		autorest.WithBaseURL(client.BaseURI),
  1363  		autorest.WithPath("/domains"),
  1364  		autorest.WithHeader("Training-Key", client.APIKey))
  1365  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1366  }
  1367  
  1368  // GetDomainsSender sends the GetDomains request. The method will close the
  1369  // http.Response Body if it receives an error.
  1370  func (client BaseClient) GetDomainsSender(req *http.Request) (*http.Response, error) {
  1371  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1372  }
  1373  
  1374  // GetDomainsResponder handles the response to the GetDomains request. The method always
  1375  // closes the http.Response Body.
  1376  func (client BaseClient) GetDomainsResponder(resp *http.Response) (result ListDomain, err error) {
  1377  	err = autorest.Respond(
  1378  		resp,
  1379  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1380  		autorest.ByUnmarshallingJSON(&result.Value),
  1381  		autorest.ByClosing())
  1382  	result.Response = autorest.Response{Response: resp}
  1383  	return
  1384  }
  1385  
  1386  // GetExports sends the get exports request.
  1387  // Parameters:
  1388  // projectID - the project id
  1389  // iterationID - the iteration id
  1390  func (client BaseClient) GetExports(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (result ListExport, err error) {
  1391  	if tracing.IsEnabled() {
  1392  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetExports")
  1393  		defer func() {
  1394  			sc := -1
  1395  			if result.Response.Response != nil {
  1396  				sc = result.Response.Response.StatusCode
  1397  			}
  1398  			tracing.EndSpan(ctx, sc, err)
  1399  		}()
  1400  	}
  1401  	req, err := client.GetExportsPreparer(ctx, projectID, iterationID)
  1402  	if err != nil {
  1403  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetExports", nil, "Failure preparing request")
  1404  		return
  1405  	}
  1406  
  1407  	resp, err := client.GetExportsSender(req)
  1408  	if err != nil {
  1409  		result.Response = autorest.Response{Response: resp}
  1410  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetExports", resp, "Failure sending request")
  1411  		return
  1412  	}
  1413  
  1414  	result, err = client.GetExportsResponder(resp)
  1415  	if err != nil {
  1416  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetExports", resp, "Failure responding to request")
  1417  		return
  1418  	}
  1419  
  1420  	return
  1421  }
  1422  
  1423  // GetExportsPreparer prepares the GetExports request.
  1424  func (client BaseClient) GetExportsPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (*http.Request, error) {
  1425  	pathParameters := map[string]interface{}{
  1426  		"iterationId": autorest.Encode("path", iterationID),
  1427  		"projectId":   autorest.Encode("path", projectID),
  1428  	}
  1429  
  1430  	preparer := autorest.CreatePreparer(
  1431  		autorest.AsGet(),
  1432  		autorest.WithBaseURL(client.BaseURI),
  1433  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/export", pathParameters),
  1434  		autorest.WithHeader("Training-Key", client.APIKey))
  1435  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1436  }
  1437  
  1438  // GetExportsSender sends the GetExports request. The method will close the
  1439  // http.Response Body if it receives an error.
  1440  func (client BaseClient) GetExportsSender(req *http.Request) (*http.Response, error) {
  1441  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1442  }
  1443  
  1444  // GetExportsResponder handles the response to the GetExports request. The method always
  1445  // closes the http.Response Body.
  1446  func (client BaseClient) GetExportsResponder(resp *http.Response) (result ListExport, err error) {
  1447  	err = autorest.Respond(
  1448  		resp,
  1449  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1450  		autorest.ByUnmarshallingJSON(&result.Value),
  1451  		autorest.ByClosing())
  1452  	result.Response = autorest.Response{Response: resp}
  1453  	return
  1454  }
  1455  
  1456  // GetImagePerformanceCount the filtering is on an and/or relationship. For example, if the provided tag ids are for
  1457  // the "Dog" and
  1458  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  1459  // Parameters:
  1460  // projectID - the project id
  1461  // iterationID - the iteration id. Defaults to workspace
  1462  // tagIds - a list of tags ids to filter the images to count. Defaults to all tags when null.
  1463  func (client BaseClient) GetImagePerformanceCount(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, tagIds []string) (result Int32, err error) {
  1464  	if tracing.IsEnabled() {
  1465  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImagePerformanceCount")
  1466  		defer func() {
  1467  			sc := -1
  1468  			if result.Response.Response != nil {
  1469  				sc = result.Response.Response.StatusCode
  1470  			}
  1471  			tracing.EndSpan(ctx, sc, err)
  1472  		}()
  1473  	}
  1474  	req, err := client.GetImagePerformanceCountPreparer(ctx, projectID, iterationID, tagIds)
  1475  	if err != nil {
  1476  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformanceCount", nil, "Failure preparing request")
  1477  		return
  1478  	}
  1479  
  1480  	resp, err := client.GetImagePerformanceCountSender(req)
  1481  	if err != nil {
  1482  		result.Response = autorest.Response{Response: resp}
  1483  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformanceCount", resp, "Failure sending request")
  1484  		return
  1485  	}
  1486  
  1487  	result, err = client.GetImagePerformanceCountResponder(resp)
  1488  	if err != nil {
  1489  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformanceCount", resp, "Failure responding to request")
  1490  		return
  1491  	}
  1492  
  1493  	return
  1494  }
  1495  
  1496  // GetImagePerformanceCountPreparer prepares the GetImagePerformanceCount request.
  1497  func (client BaseClient) GetImagePerformanceCountPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, tagIds []string) (*http.Request, error) {
  1498  	pathParameters := map[string]interface{}{
  1499  		"iterationId": autorest.Encode("path", iterationID),
  1500  		"projectId":   autorest.Encode("path", projectID),
  1501  	}
  1502  
  1503  	queryParameters := map[string]interface{}{}
  1504  	if tagIds != nil && len(tagIds) > 0 {
  1505  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  1506  	}
  1507  
  1508  	preparer := autorest.CreatePreparer(
  1509  		autorest.AsGet(),
  1510  		autorest.WithBaseURL(client.BaseURI),
  1511  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/performance/images/count", pathParameters),
  1512  		autorest.WithQueryParameters(queryParameters),
  1513  		autorest.WithHeader("Training-Key", client.APIKey))
  1514  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1515  }
  1516  
  1517  // GetImagePerformanceCountSender sends the GetImagePerformanceCount request. The method will close the
  1518  // http.Response Body if it receives an error.
  1519  func (client BaseClient) GetImagePerformanceCountSender(req *http.Request) (*http.Response, error) {
  1520  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1521  }
  1522  
  1523  // GetImagePerformanceCountResponder handles the response to the GetImagePerformanceCount request. The method always
  1524  // closes the http.Response Body.
  1525  func (client BaseClient) GetImagePerformanceCountResponder(resp *http.Response) (result Int32, err error) {
  1526  	err = autorest.Respond(
  1527  		resp,
  1528  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1529  		autorest.ByUnmarshallingJSON(&result.Value),
  1530  		autorest.ByClosing())
  1531  	result.Response = autorest.Response{Response: resp}
  1532  	return
  1533  }
  1534  
  1535  // GetImagePerformances this API supports batching and range selection. By default it will only return first 50 images
  1536  // matching images.
  1537  // Use the {take} and {skip} parameters to control how many images to return in a given batch.
  1538  // The filtering is on an and/or relationship. For example, if the provided tag ids are for the "Dog" and
  1539  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  1540  // Parameters:
  1541  // projectID - the project id
  1542  // iterationID - the iteration id. Defaults to workspace
  1543  // tagIds - a list of tags ids to filter the images. Defaults to all tagged images when null. Limited to 20
  1544  // orderBy - the ordering. Defaults to newest
  1545  // take - maximum number of images to return. Defaults to 50, limited to 256
  1546  // skip - number of images to skip before beginning the image batch. Defaults to 0
  1547  func (client BaseClient) GetImagePerformances(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, tagIds []string, orderBy string, take *int32, skip *int32) (result ListImagePerformance, err error) {
  1548  	if tracing.IsEnabled() {
  1549  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImagePerformances")
  1550  		defer func() {
  1551  			sc := -1
  1552  			if result.Response.Response != nil {
  1553  				sc = result.Response.Response.StatusCode
  1554  			}
  1555  			tracing.EndSpan(ctx, sc, err)
  1556  		}()
  1557  	}
  1558  	req, err := client.GetImagePerformancesPreparer(ctx, projectID, iterationID, tagIds, orderBy, take, skip)
  1559  	if err != nil {
  1560  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformances", nil, "Failure preparing request")
  1561  		return
  1562  	}
  1563  
  1564  	resp, err := client.GetImagePerformancesSender(req)
  1565  	if err != nil {
  1566  		result.Response = autorest.Response{Response: resp}
  1567  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformances", resp, "Failure sending request")
  1568  		return
  1569  	}
  1570  
  1571  	result, err = client.GetImagePerformancesResponder(resp)
  1572  	if err != nil {
  1573  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagePerformances", resp, "Failure responding to request")
  1574  		return
  1575  	}
  1576  
  1577  	return
  1578  }
  1579  
  1580  // GetImagePerformancesPreparer prepares the GetImagePerformances request.
  1581  func (client BaseClient) GetImagePerformancesPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, tagIds []string, orderBy string, take *int32, skip *int32) (*http.Request, error) {
  1582  	pathParameters := map[string]interface{}{
  1583  		"iterationId": autorest.Encode("path", iterationID),
  1584  		"projectId":   autorest.Encode("path", projectID),
  1585  	}
  1586  
  1587  	queryParameters := map[string]interface{}{}
  1588  	if tagIds != nil && len(tagIds) > 0 {
  1589  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  1590  	}
  1591  	if len(string(orderBy)) > 0 {
  1592  		queryParameters["orderBy"] = autorest.Encode("query", orderBy)
  1593  	}
  1594  	if take != nil {
  1595  		queryParameters["take"] = autorest.Encode("query", *take)
  1596  	} else {
  1597  		queryParameters["take"] = autorest.Encode("query", 50)
  1598  	}
  1599  	if skip != nil {
  1600  		queryParameters["skip"] = autorest.Encode("query", *skip)
  1601  	} else {
  1602  		queryParameters["skip"] = autorest.Encode("query", 0)
  1603  	}
  1604  
  1605  	preparer := autorest.CreatePreparer(
  1606  		autorest.AsGet(),
  1607  		autorest.WithBaseURL(client.BaseURI),
  1608  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/performance/images", pathParameters),
  1609  		autorest.WithQueryParameters(queryParameters),
  1610  		autorest.WithHeader("Training-Key", client.APIKey))
  1611  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1612  }
  1613  
  1614  // GetImagePerformancesSender sends the GetImagePerformances request. The method will close the
  1615  // http.Response Body if it receives an error.
  1616  func (client BaseClient) GetImagePerformancesSender(req *http.Request) (*http.Response, error) {
  1617  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1618  }
  1619  
  1620  // GetImagePerformancesResponder handles the response to the GetImagePerformances request. The method always
  1621  // closes the http.Response Body.
  1622  func (client BaseClient) GetImagePerformancesResponder(resp *http.Response) (result ListImagePerformance, err error) {
  1623  	err = autorest.Respond(
  1624  		resp,
  1625  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1626  		autorest.ByUnmarshallingJSON(&result.Value),
  1627  		autorest.ByClosing())
  1628  	result.Response = autorest.Response{Response: resp}
  1629  	return
  1630  }
  1631  
  1632  // GetImageRegionProposals this API will get region proposals for an image along with confidences for the region. It
  1633  // returns an empty array if no proposals are found.
  1634  // Parameters:
  1635  // projectID - the project id
  1636  // imageID - the image id
  1637  func (client BaseClient) GetImageRegionProposals(ctx context.Context, projectID uuid.UUID, imageID uuid.UUID) (result ImageRegionProposal, err error) {
  1638  	if tracing.IsEnabled() {
  1639  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImageRegionProposals")
  1640  		defer func() {
  1641  			sc := -1
  1642  			if result.Response.Response != nil {
  1643  				sc = result.Response.Response.StatusCode
  1644  			}
  1645  			tracing.EndSpan(ctx, sc, err)
  1646  		}()
  1647  	}
  1648  	req, err := client.GetImageRegionProposalsPreparer(ctx, projectID, imageID)
  1649  	if err != nil {
  1650  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImageRegionProposals", nil, "Failure preparing request")
  1651  		return
  1652  	}
  1653  
  1654  	resp, err := client.GetImageRegionProposalsSender(req)
  1655  	if err != nil {
  1656  		result.Response = autorest.Response{Response: resp}
  1657  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImageRegionProposals", resp, "Failure sending request")
  1658  		return
  1659  	}
  1660  
  1661  	result, err = client.GetImageRegionProposalsResponder(resp)
  1662  	if err != nil {
  1663  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImageRegionProposals", resp, "Failure responding to request")
  1664  		return
  1665  	}
  1666  
  1667  	return
  1668  }
  1669  
  1670  // GetImageRegionProposalsPreparer prepares the GetImageRegionProposals request.
  1671  func (client BaseClient) GetImageRegionProposalsPreparer(ctx context.Context, projectID uuid.UUID, imageID uuid.UUID) (*http.Request, error) {
  1672  	pathParameters := map[string]interface{}{
  1673  		"imageId":   autorest.Encode("path", imageID),
  1674  		"projectId": autorest.Encode("path", projectID),
  1675  	}
  1676  
  1677  	preparer := autorest.CreatePreparer(
  1678  		autorest.AsPost(),
  1679  		autorest.WithBaseURL(client.BaseURI),
  1680  		autorest.WithPathParameters("/{projectId}/images/{imageId}/regionproposals", pathParameters),
  1681  		autorest.WithHeader("Training-Key", client.APIKey))
  1682  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1683  }
  1684  
  1685  // GetImageRegionProposalsSender sends the GetImageRegionProposals request. The method will close the
  1686  // http.Response Body if it receives an error.
  1687  func (client BaseClient) GetImageRegionProposalsSender(req *http.Request) (*http.Response, error) {
  1688  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1689  }
  1690  
  1691  // GetImageRegionProposalsResponder handles the response to the GetImageRegionProposals request. The method always
  1692  // closes the http.Response Body.
  1693  func (client BaseClient) GetImageRegionProposalsResponder(resp *http.Response) (result ImageRegionProposal, err error) {
  1694  	err = autorest.Respond(
  1695  		resp,
  1696  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1697  		autorest.ByUnmarshallingJSON(&result),
  1698  		autorest.ByClosing())
  1699  	result.Response = autorest.Response{Response: resp}
  1700  	return
  1701  }
  1702  
  1703  // GetImagesByIds this API will return a set of Images for the specified tags and optionally iteration. If no iteration
  1704  // is specified the
  1705  // current workspace is used.
  1706  // Parameters:
  1707  // projectID - the project id
  1708  // imageIds - the list of image ids to retrieve. Limited to 256
  1709  // iterationID - the iteration id. Defaults to workspace
  1710  func (client BaseClient) GetImagesByIds(ctx context.Context, projectID uuid.UUID, imageIds []string, iterationID *uuid.UUID) (result ListImage, err error) {
  1711  	if tracing.IsEnabled() {
  1712  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetImagesByIds")
  1713  		defer func() {
  1714  			sc := -1
  1715  			if result.Response.Response != nil {
  1716  				sc = result.Response.Response.StatusCode
  1717  			}
  1718  			tracing.EndSpan(ctx, sc, err)
  1719  		}()
  1720  	}
  1721  	req, err := client.GetImagesByIdsPreparer(ctx, projectID, imageIds, iterationID)
  1722  	if err != nil {
  1723  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagesByIds", nil, "Failure preparing request")
  1724  		return
  1725  	}
  1726  
  1727  	resp, err := client.GetImagesByIdsSender(req)
  1728  	if err != nil {
  1729  		result.Response = autorest.Response{Response: resp}
  1730  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagesByIds", resp, "Failure sending request")
  1731  		return
  1732  	}
  1733  
  1734  	result, err = client.GetImagesByIdsResponder(resp)
  1735  	if err != nil {
  1736  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetImagesByIds", resp, "Failure responding to request")
  1737  		return
  1738  	}
  1739  
  1740  	return
  1741  }
  1742  
  1743  // GetImagesByIdsPreparer prepares the GetImagesByIds request.
  1744  func (client BaseClient) GetImagesByIdsPreparer(ctx context.Context, projectID uuid.UUID, imageIds []string, iterationID *uuid.UUID) (*http.Request, error) {
  1745  	pathParameters := map[string]interface{}{
  1746  		"projectId": autorest.Encode("path", projectID),
  1747  	}
  1748  
  1749  	queryParameters := map[string]interface{}{}
  1750  	if imageIds != nil && len(imageIds) > 0 {
  1751  		queryParameters["imageIds"] = autorest.Encode("query", imageIds, ",")
  1752  	}
  1753  	if iterationID != nil {
  1754  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  1755  	}
  1756  
  1757  	preparer := autorest.CreatePreparer(
  1758  		autorest.AsGet(),
  1759  		autorest.WithBaseURL(client.BaseURI),
  1760  		autorest.WithPathParameters("/projects/{projectId}/images/id", pathParameters),
  1761  		autorest.WithQueryParameters(queryParameters),
  1762  		autorest.WithHeader("Training-Key", client.APIKey))
  1763  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1764  }
  1765  
  1766  // GetImagesByIdsSender sends the GetImagesByIds request. The method will close the
  1767  // http.Response Body if it receives an error.
  1768  func (client BaseClient) GetImagesByIdsSender(req *http.Request) (*http.Response, error) {
  1769  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1770  }
  1771  
  1772  // GetImagesByIdsResponder handles the response to the GetImagesByIds request. The method always
  1773  // closes the http.Response Body.
  1774  func (client BaseClient) GetImagesByIdsResponder(resp *http.Response) (result ListImage, err error) {
  1775  	err = autorest.Respond(
  1776  		resp,
  1777  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1778  		autorest.ByUnmarshallingJSON(&result.Value),
  1779  		autorest.ByClosing())
  1780  	result.Response = autorest.Response{Response: resp}
  1781  	return
  1782  }
  1783  
  1784  // GetIteration sends the get iteration request.
  1785  // Parameters:
  1786  // projectID - the id of the project the iteration belongs to
  1787  // iterationID - the id of the iteration to get
  1788  func (client BaseClient) GetIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (result Iteration, err error) {
  1789  	if tracing.IsEnabled() {
  1790  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetIteration")
  1791  		defer func() {
  1792  			sc := -1
  1793  			if result.Response.Response != nil {
  1794  				sc = result.Response.Response.StatusCode
  1795  			}
  1796  			tracing.EndSpan(ctx, sc, err)
  1797  		}()
  1798  	}
  1799  	req, err := client.GetIterationPreparer(ctx, projectID, iterationID)
  1800  	if err != nil {
  1801  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIteration", nil, "Failure preparing request")
  1802  		return
  1803  	}
  1804  
  1805  	resp, err := client.GetIterationSender(req)
  1806  	if err != nil {
  1807  		result.Response = autorest.Response{Response: resp}
  1808  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIteration", resp, "Failure sending request")
  1809  		return
  1810  	}
  1811  
  1812  	result, err = client.GetIterationResponder(resp)
  1813  	if err != nil {
  1814  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIteration", resp, "Failure responding to request")
  1815  		return
  1816  	}
  1817  
  1818  	return
  1819  }
  1820  
  1821  // GetIterationPreparer prepares the GetIteration request.
  1822  func (client BaseClient) GetIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID) (*http.Request, error) {
  1823  	pathParameters := map[string]interface{}{
  1824  		"iterationId": autorest.Encode("path", iterationID),
  1825  		"projectId":   autorest.Encode("path", projectID),
  1826  	}
  1827  
  1828  	preparer := autorest.CreatePreparer(
  1829  		autorest.AsGet(),
  1830  		autorest.WithBaseURL(client.BaseURI),
  1831  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}", pathParameters),
  1832  		autorest.WithHeader("Training-Key", client.APIKey))
  1833  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1834  }
  1835  
  1836  // GetIterationSender sends the GetIteration request. The method will close the
  1837  // http.Response Body if it receives an error.
  1838  func (client BaseClient) GetIterationSender(req *http.Request) (*http.Response, error) {
  1839  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1840  }
  1841  
  1842  // GetIterationResponder handles the response to the GetIteration request. The method always
  1843  // closes the http.Response Body.
  1844  func (client BaseClient) GetIterationResponder(resp *http.Response) (result Iteration, err error) {
  1845  	err = autorest.Respond(
  1846  		resp,
  1847  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1848  		autorest.ByUnmarshallingJSON(&result),
  1849  		autorest.ByClosing())
  1850  	result.Response = autorest.Response{Response: resp}
  1851  	return
  1852  }
  1853  
  1854  // GetIterationPerformance sends the get iteration performance request.
  1855  // Parameters:
  1856  // projectID - the id of the project the iteration belongs to
  1857  // iterationID - the id of the iteration to get
  1858  // threshold - the threshold used to determine true predictions
  1859  // overlapThreshold - if applicable, the bounding box overlap threshold used to determine true predictions
  1860  func (client BaseClient) GetIterationPerformance(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, threshold *float64, overlapThreshold *float64) (result IterationPerformance, err error) {
  1861  	if tracing.IsEnabled() {
  1862  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetIterationPerformance")
  1863  		defer func() {
  1864  			sc := -1
  1865  			if result.Response.Response != nil {
  1866  				sc = result.Response.Response.StatusCode
  1867  			}
  1868  			tracing.EndSpan(ctx, sc, err)
  1869  		}()
  1870  	}
  1871  	req, err := client.GetIterationPerformancePreparer(ctx, projectID, iterationID, threshold, overlapThreshold)
  1872  	if err != nil {
  1873  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterationPerformance", nil, "Failure preparing request")
  1874  		return
  1875  	}
  1876  
  1877  	resp, err := client.GetIterationPerformanceSender(req)
  1878  	if err != nil {
  1879  		result.Response = autorest.Response{Response: resp}
  1880  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterationPerformance", resp, "Failure sending request")
  1881  		return
  1882  	}
  1883  
  1884  	result, err = client.GetIterationPerformanceResponder(resp)
  1885  	if err != nil {
  1886  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterationPerformance", resp, "Failure responding to request")
  1887  		return
  1888  	}
  1889  
  1890  	return
  1891  }
  1892  
  1893  // GetIterationPerformancePreparer prepares the GetIterationPerformance request.
  1894  func (client BaseClient) GetIterationPerformancePreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, threshold *float64, overlapThreshold *float64) (*http.Request, error) {
  1895  	pathParameters := map[string]interface{}{
  1896  		"iterationId": autorest.Encode("path", iterationID),
  1897  		"projectId":   autorest.Encode("path", projectID),
  1898  	}
  1899  
  1900  	queryParameters := map[string]interface{}{}
  1901  	if threshold != nil {
  1902  		queryParameters["threshold"] = autorest.Encode("query", *threshold)
  1903  	}
  1904  	if overlapThreshold != nil {
  1905  		queryParameters["overlapThreshold"] = autorest.Encode("query", *overlapThreshold)
  1906  	}
  1907  
  1908  	preparer := autorest.CreatePreparer(
  1909  		autorest.AsGet(),
  1910  		autorest.WithBaseURL(client.BaseURI),
  1911  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}/performance", pathParameters),
  1912  		autorest.WithQueryParameters(queryParameters),
  1913  		autorest.WithHeader("Training-Key", client.APIKey))
  1914  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1915  }
  1916  
  1917  // GetIterationPerformanceSender sends the GetIterationPerformance request. The method will close the
  1918  // http.Response Body if it receives an error.
  1919  func (client BaseClient) GetIterationPerformanceSender(req *http.Request) (*http.Response, error) {
  1920  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1921  }
  1922  
  1923  // GetIterationPerformanceResponder handles the response to the GetIterationPerformance request. The method always
  1924  // closes the http.Response Body.
  1925  func (client BaseClient) GetIterationPerformanceResponder(resp *http.Response) (result IterationPerformance, err error) {
  1926  	err = autorest.Respond(
  1927  		resp,
  1928  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1929  		autorest.ByUnmarshallingJSON(&result),
  1930  		autorest.ByClosing())
  1931  	result.Response = autorest.Response{Response: resp}
  1932  	return
  1933  }
  1934  
  1935  // GetIterations sends the get iterations request.
  1936  // Parameters:
  1937  // projectID - the project id
  1938  func (client BaseClient) GetIterations(ctx context.Context, projectID uuid.UUID) (result ListIteration, err error) {
  1939  	if tracing.IsEnabled() {
  1940  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetIterations")
  1941  		defer func() {
  1942  			sc := -1
  1943  			if result.Response.Response != nil {
  1944  				sc = result.Response.Response.StatusCode
  1945  			}
  1946  			tracing.EndSpan(ctx, sc, err)
  1947  		}()
  1948  	}
  1949  	req, err := client.GetIterationsPreparer(ctx, projectID)
  1950  	if err != nil {
  1951  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterations", nil, "Failure preparing request")
  1952  		return
  1953  	}
  1954  
  1955  	resp, err := client.GetIterationsSender(req)
  1956  	if err != nil {
  1957  		result.Response = autorest.Response{Response: resp}
  1958  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterations", resp, "Failure sending request")
  1959  		return
  1960  	}
  1961  
  1962  	result, err = client.GetIterationsResponder(resp)
  1963  	if err != nil {
  1964  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetIterations", resp, "Failure responding to request")
  1965  		return
  1966  	}
  1967  
  1968  	return
  1969  }
  1970  
  1971  // GetIterationsPreparer prepares the GetIterations request.
  1972  func (client BaseClient) GetIterationsPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  1973  	pathParameters := map[string]interface{}{
  1974  		"projectId": autorest.Encode("path", projectID),
  1975  	}
  1976  
  1977  	preparer := autorest.CreatePreparer(
  1978  		autorest.AsGet(),
  1979  		autorest.WithBaseURL(client.BaseURI),
  1980  		autorest.WithPathParameters("/projects/{projectId}/iterations", pathParameters),
  1981  		autorest.WithHeader("Training-Key", client.APIKey))
  1982  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1983  }
  1984  
  1985  // GetIterationsSender sends the GetIterations request. The method will close the
  1986  // http.Response Body if it receives an error.
  1987  func (client BaseClient) GetIterationsSender(req *http.Request) (*http.Response, error) {
  1988  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  1989  }
  1990  
  1991  // GetIterationsResponder handles the response to the GetIterations request. The method always
  1992  // closes the http.Response Body.
  1993  func (client BaseClient) GetIterationsResponder(resp *http.Response) (result ListIteration, err error) {
  1994  	err = autorest.Respond(
  1995  		resp,
  1996  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1997  		autorest.ByUnmarshallingJSON(&result.Value),
  1998  		autorest.ByClosing())
  1999  	result.Response = autorest.Response{Response: resp}
  2000  	return
  2001  }
  2002  
  2003  // GetProject sends the get project request.
  2004  // Parameters:
  2005  // projectID - the id of the project to get
  2006  func (client BaseClient) GetProject(ctx context.Context, projectID uuid.UUID) (result Project, err error) {
  2007  	if tracing.IsEnabled() {
  2008  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetProject")
  2009  		defer func() {
  2010  			sc := -1
  2011  			if result.Response.Response != nil {
  2012  				sc = result.Response.Response.StatusCode
  2013  			}
  2014  			tracing.EndSpan(ctx, sc, err)
  2015  		}()
  2016  	}
  2017  	req, err := client.GetProjectPreparer(ctx, projectID)
  2018  	if err != nil {
  2019  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProject", nil, "Failure preparing request")
  2020  		return
  2021  	}
  2022  
  2023  	resp, err := client.GetProjectSender(req)
  2024  	if err != nil {
  2025  		result.Response = autorest.Response{Response: resp}
  2026  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProject", resp, "Failure sending request")
  2027  		return
  2028  	}
  2029  
  2030  	result, err = client.GetProjectResponder(resp)
  2031  	if err != nil {
  2032  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProject", resp, "Failure responding to request")
  2033  		return
  2034  	}
  2035  
  2036  	return
  2037  }
  2038  
  2039  // GetProjectPreparer prepares the GetProject request.
  2040  func (client BaseClient) GetProjectPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  2041  	pathParameters := map[string]interface{}{
  2042  		"projectId": autorest.Encode("path", projectID),
  2043  	}
  2044  
  2045  	preparer := autorest.CreatePreparer(
  2046  		autorest.AsGet(),
  2047  		autorest.WithBaseURL(client.BaseURI),
  2048  		autorest.WithPathParameters("/projects/{projectId}", pathParameters),
  2049  		autorest.WithHeader("Training-Key", client.APIKey))
  2050  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2051  }
  2052  
  2053  // GetProjectSender sends the GetProject request. The method will close the
  2054  // http.Response Body if it receives an error.
  2055  func (client BaseClient) GetProjectSender(req *http.Request) (*http.Response, error) {
  2056  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2057  }
  2058  
  2059  // GetProjectResponder handles the response to the GetProject request. The method always
  2060  // closes the http.Response Body.
  2061  func (client BaseClient) GetProjectResponder(resp *http.Response) (result Project, err error) {
  2062  	err = autorest.Respond(
  2063  		resp,
  2064  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2065  		autorest.ByUnmarshallingJSON(&result),
  2066  		autorest.ByClosing())
  2067  	result.Response = autorest.Response{Response: resp}
  2068  	return
  2069  }
  2070  
  2071  // GetProjects sends the get projects request.
  2072  func (client BaseClient) GetProjects(ctx context.Context) (result ListProject, err error) {
  2073  	if tracing.IsEnabled() {
  2074  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetProjects")
  2075  		defer func() {
  2076  			sc := -1
  2077  			if result.Response.Response != nil {
  2078  				sc = result.Response.Response.StatusCode
  2079  			}
  2080  			tracing.EndSpan(ctx, sc, err)
  2081  		}()
  2082  	}
  2083  	req, err := client.GetProjectsPreparer(ctx)
  2084  	if err != nil {
  2085  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProjects", nil, "Failure preparing request")
  2086  		return
  2087  	}
  2088  
  2089  	resp, err := client.GetProjectsSender(req)
  2090  	if err != nil {
  2091  		result.Response = autorest.Response{Response: resp}
  2092  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProjects", resp, "Failure sending request")
  2093  		return
  2094  	}
  2095  
  2096  	result, err = client.GetProjectsResponder(resp)
  2097  	if err != nil {
  2098  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetProjects", resp, "Failure responding to request")
  2099  		return
  2100  	}
  2101  
  2102  	return
  2103  }
  2104  
  2105  // GetProjectsPreparer prepares the GetProjects request.
  2106  func (client BaseClient) GetProjectsPreparer(ctx context.Context) (*http.Request, error) {
  2107  	preparer := autorest.CreatePreparer(
  2108  		autorest.AsGet(),
  2109  		autorest.WithBaseURL(client.BaseURI),
  2110  		autorest.WithPath("/projects"),
  2111  		autorest.WithHeader("Training-Key", client.APIKey))
  2112  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2113  }
  2114  
  2115  // GetProjectsSender sends the GetProjects request. The method will close the
  2116  // http.Response Body if it receives an error.
  2117  func (client BaseClient) GetProjectsSender(req *http.Request) (*http.Response, error) {
  2118  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2119  }
  2120  
  2121  // GetProjectsResponder handles the response to the GetProjects request. The method always
  2122  // closes the http.Response Body.
  2123  func (client BaseClient) GetProjectsResponder(resp *http.Response) (result ListProject, err error) {
  2124  	err = autorest.Respond(
  2125  		resp,
  2126  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2127  		autorest.ByUnmarshallingJSON(&result.Value),
  2128  		autorest.ByClosing())
  2129  	result.Response = autorest.Response{Response: resp}
  2130  	return
  2131  }
  2132  
  2133  // GetTag sends the get tag request.
  2134  // Parameters:
  2135  // projectID - the project this tag belongs to
  2136  // tagID - the tag id
  2137  // iterationID - the iteration to retrieve this tag from. Optional, defaults to current training set
  2138  func (client BaseClient) GetTag(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, iterationID *uuid.UUID) (result Tag, err error) {
  2139  	if tracing.IsEnabled() {
  2140  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTag")
  2141  		defer func() {
  2142  			sc := -1
  2143  			if result.Response.Response != nil {
  2144  				sc = result.Response.Response.StatusCode
  2145  			}
  2146  			tracing.EndSpan(ctx, sc, err)
  2147  		}()
  2148  	}
  2149  	req, err := client.GetTagPreparer(ctx, projectID, tagID, iterationID)
  2150  	if err != nil {
  2151  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTag", nil, "Failure preparing request")
  2152  		return
  2153  	}
  2154  
  2155  	resp, err := client.GetTagSender(req)
  2156  	if err != nil {
  2157  		result.Response = autorest.Response{Response: resp}
  2158  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTag", resp, "Failure sending request")
  2159  		return
  2160  	}
  2161  
  2162  	result, err = client.GetTagResponder(resp)
  2163  	if err != nil {
  2164  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTag", resp, "Failure responding to request")
  2165  		return
  2166  	}
  2167  
  2168  	return
  2169  }
  2170  
  2171  // GetTagPreparer prepares the GetTag request.
  2172  func (client BaseClient) GetTagPreparer(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, iterationID *uuid.UUID) (*http.Request, error) {
  2173  	pathParameters := map[string]interface{}{
  2174  		"projectId": autorest.Encode("path", projectID),
  2175  		"tagId":     autorest.Encode("path", tagID),
  2176  	}
  2177  
  2178  	queryParameters := map[string]interface{}{}
  2179  	if iterationID != nil {
  2180  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2181  	}
  2182  
  2183  	preparer := autorest.CreatePreparer(
  2184  		autorest.AsGet(),
  2185  		autorest.WithBaseURL(client.BaseURI),
  2186  		autorest.WithPathParameters("/projects/{projectId}/tags/{tagId}", pathParameters),
  2187  		autorest.WithQueryParameters(queryParameters),
  2188  		autorest.WithHeader("Training-Key", client.APIKey))
  2189  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2190  }
  2191  
  2192  // GetTagSender sends the GetTag request. The method will close the
  2193  // http.Response Body if it receives an error.
  2194  func (client BaseClient) GetTagSender(req *http.Request) (*http.Response, error) {
  2195  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2196  }
  2197  
  2198  // GetTagResponder handles the response to the GetTag request. The method always
  2199  // closes the http.Response Body.
  2200  func (client BaseClient) GetTagResponder(resp *http.Response) (result Tag, err error) {
  2201  	err = autorest.Respond(
  2202  		resp,
  2203  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2204  		autorest.ByUnmarshallingJSON(&result),
  2205  		autorest.ByClosing())
  2206  	result.Response = autorest.Response{Response: resp}
  2207  	return
  2208  }
  2209  
  2210  // GetTaggedImageCount the filtering is on an and/or relationship. For example, if the provided tag ids are for the
  2211  // "Dog" and
  2212  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  2213  // Parameters:
  2214  // projectID - the project id
  2215  // iterationID - the iteration id. Defaults to workspace
  2216  // tagIds - a list of tags ids to filter the images to count. Defaults to all tags when null.
  2217  func (client BaseClient) GetTaggedImageCount(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, tagIds []string) (result Int32, err error) {
  2218  	if tracing.IsEnabled() {
  2219  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTaggedImageCount")
  2220  		defer func() {
  2221  			sc := -1
  2222  			if result.Response.Response != nil {
  2223  				sc = result.Response.Response.StatusCode
  2224  			}
  2225  			tracing.EndSpan(ctx, sc, err)
  2226  		}()
  2227  	}
  2228  	req, err := client.GetTaggedImageCountPreparer(ctx, projectID, iterationID, tagIds)
  2229  	if err != nil {
  2230  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImageCount", nil, "Failure preparing request")
  2231  		return
  2232  	}
  2233  
  2234  	resp, err := client.GetTaggedImageCountSender(req)
  2235  	if err != nil {
  2236  		result.Response = autorest.Response{Response: resp}
  2237  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImageCount", resp, "Failure sending request")
  2238  		return
  2239  	}
  2240  
  2241  	result, err = client.GetTaggedImageCountResponder(resp)
  2242  	if err != nil {
  2243  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImageCount", resp, "Failure responding to request")
  2244  		return
  2245  	}
  2246  
  2247  	return
  2248  }
  2249  
  2250  // GetTaggedImageCountPreparer prepares the GetTaggedImageCount request.
  2251  func (client BaseClient) GetTaggedImageCountPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, tagIds []string) (*http.Request, error) {
  2252  	pathParameters := map[string]interface{}{
  2253  		"projectId": autorest.Encode("path", projectID),
  2254  	}
  2255  
  2256  	queryParameters := map[string]interface{}{}
  2257  	if iterationID != nil {
  2258  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2259  	}
  2260  	if tagIds != nil && len(tagIds) > 0 {
  2261  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  2262  	}
  2263  
  2264  	preparer := autorest.CreatePreparer(
  2265  		autorest.AsGet(),
  2266  		autorest.WithBaseURL(client.BaseURI),
  2267  		autorest.WithPathParameters("/projects/{projectId}/images/tagged/count", pathParameters),
  2268  		autorest.WithQueryParameters(queryParameters),
  2269  		autorest.WithHeader("Training-Key", client.APIKey))
  2270  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2271  }
  2272  
  2273  // GetTaggedImageCountSender sends the GetTaggedImageCount request. The method will close the
  2274  // http.Response Body if it receives an error.
  2275  func (client BaseClient) GetTaggedImageCountSender(req *http.Request) (*http.Response, error) {
  2276  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2277  }
  2278  
  2279  // GetTaggedImageCountResponder handles the response to the GetTaggedImageCount request. The method always
  2280  // closes the http.Response Body.
  2281  func (client BaseClient) GetTaggedImageCountResponder(resp *http.Response) (result Int32, err error) {
  2282  	err = autorest.Respond(
  2283  		resp,
  2284  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2285  		autorest.ByUnmarshallingJSON(&result.Value),
  2286  		autorest.ByClosing())
  2287  	result.Response = autorest.Response{Response: resp}
  2288  	return
  2289  }
  2290  
  2291  // GetTaggedImages this API supports batching and range selection. By default it will only return first 50 images
  2292  // matching images.
  2293  // Use the {take} and {skip} parameters to control how many images to return in a given batch.
  2294  // The filtering is on an and/or relationship. For example, if the provided tag ids are for the "Dog" and
  2295  // "Cat" tags, then only images tagged with Dog and/or Cat will be returned
  2296  // Parameters:
  2297  // projectID - the project id
  2298  // iterationID - the iteration id. Defaults to workspace
  2299  // tagIds - a list of tags ids to filter the images. Defaults to all tagged images when null. Limited to 20
  2300  // orderBy - the ordering. Defaults to newest
  2301  // take - maximum number of images to return. Defaults to 50, limited to 256
  2302  // skip - number of images to skip before beginning the image batch. Defaults to 0
  2303  func (client BaseClient) GetTaggedImages(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, tagIds []string, orderBy string, take *int32, skip *int32) (result ListImage, err error) {
  2304  	if tracing.IsEnabled() {
  2305  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTaggedImages")
  2306  		defer func() {
  2307  			sc := -1
  2308  			if result.Response.Response != nil {
  2309  				sc = result.Response.Response.StatusCode
  2310  			}
  2311  			tracing.EndSpan(ctx, sc, err)
  2312  		}()
  2313  	}
  2314  	req, err := client.GetTaggedImagesPreparer(ctx, projectID, iterationID, tagIds, orderBy, take, skip)
  2315  	if err != nil {
  2316  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImages", nil, "Failure preparing request")
  2317  		return
  2318  	}
  2319  
  2320  	resp, err := client.GetTaggedImagesSender(req)
  2321  	if err != nil {
  2322  		result.Response = autorest.Response{Response: resp}
  2323  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImages", resp, "Failure sending request")
  2324  		return
  2325  	}
  2326  
  2327  	result, err = client.GetTaggedImagesResponder(resp)
  2328  	if err != nil {
  2329  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTaggedImages", resp, "Failure responding to request")
  2330  		return
  2331  	}
  2332  
  2333  	return
  2334  }
  2335  
  2336  // GetTaggedImagesPreparer prepares the GetTaggedImages request.
  2337  func (client BaseClient) GetTaggedImagesPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, tagIds []string, orderBy string, take *int32, skip *int32) (*http.Request, error) {
  2338  	pathParameters := map[string]interface{}{
  2339  		"projectId": autorest.Encode("path", projectID),
  2340  	}
  2341  
  2342  	queryParameters := map[string]interface{}{}
  2343  	if iterationID != nil {
  2344  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2345  	}
  2346  	if tagIds != nil && len(tagIds) > 0 {
  2347  		queryParameters["tagIds"] = autorest.Encode("query", tagIds, ",")
  2348  	}
  2349  	if len(string(orderBy)) > 0 {
  2350  		queryParameters["orderBy"] = autorest.Encode("query", orderBy)
  2351  	}
  2352  	if take != nil {
  2353  		queryParameters["take"] = autorest.Encode("query", *take)
  2354  	} else {
  2355  		queryParameters["take"] = autorest.Encode("query", 50)
  2356  	}
  2357  	if skip != nil {
  2358  		queryParameters["skip"] = autorest.Encode("query", *skip)
  2359  	} else {
  2360  		queryParameters["skip"] = autorest.Encode("query", 0)
  2361  	}
  2362  
  2363  	preparer := autorest.CreatePreparer(
  2364  		autorest.AsGet(),
  2365  		autorest.WithBaseURL(client.BaseURI),
  2366  		autorest.WithPathParameters("/projects/{projectId}/images/tagged", pathParameters),
  2367  		autorest.WithQueryParameters(queryParameters),
  2368  		autorest.WithHeader("Training-Key", client.APIKey))
  2369  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2370  }
  2371  
  2372  // GetTaggedImagesSender sends the GetTaggedImages request. The method will close the
  2373  // http.Response Body if it receives an error.
  2374  func (client BaseClient) GetTaggedImagesSender(req *http.Request) (*http.Response, error) {
  2375  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2376  }
  2377  
  2378  // GetTaggedImagesResponder handles the response to the GetTaggedImages request. The method always
  2379  // closes the http.Response Body.
  2380  func (client BaseClient) GetTaggedImagesResponder(resp *http.Response) (result ListImage, err error) {
  2381  	err = autorest.Respond(
  2382  		resp,
  2383  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2384  		autorest.ByUnmarshallingJSON(&result.Value),
  2385  		autorest.ByClosing())
  2386  	result.Response = autorest.Response{Response: resp}
  2387  	return
  2388  }
  2389  
  2390  // GetTags sends the get tags request.
  2391  // Parameters:
  2392  // projectID - the project id
  2393  // iterationID - the iteration id. Defaults to workspace
  2394  func (client BaseClient) GetTags(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (result ListTag, err error) {
  2395  	if tracing.IsEnabled() {
  2396  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetTags")
  2397  		defer func() {
  2398  			sc := -1
  2399  			if result.Response.Response != nil {
  2400  				sc = result.Response.Response.StatusCode
  2401  			}
  2402  			tracing.EndSpan(ctx, sc, err)
  2403  		}()
  2404  	}
  2405  	req, err := client.GetTagsPreparer(ctx, projectID, iterationID)
  2406  	if err != nil {
  2407  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTags", nil, "Failure preparing request")
  2408  		return
  2409  	}
  2410  
  2411  	resp, err := client.GetTagsSender(req)
  2412  	if err != nil {
  2413  		result.Response = autorest.Response{Response: resp}
  2414  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTags", resp, "Failure sending request")
  2415  		return
  2416  	}
  2417  
  2418  	result, err = client.GetTagsResponder(resp)
  2419  	if err != nil {
  2420  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetTags", resp, "Failure responding to request")
  2421  		return
  2422  	}
  2423  
  2424  	return
  2425  }
  2426  
  2427  // GetTagsPreparer prepares the GetTags request.
  2428  func (client BaseClient) GetTagsPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (*http.Request, error) {
  2429  	pathParameters := map[string]interface{}{
  2430  		"projectId": autorest.Encode("path", projectID),
  2431  	}
  2432  
  2433  	queryParameters := map[string]interface{}{}
  2434  	if iterationID != nil {
  2435  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2436  	}
  2437  
  2438  	preparer := autorest.CreatePreparer(
  2439  		autorest.AsGet(),
  2440  		autorest.WithBaseURL(client.BaseURI),
  2441  		autorest.WithPathParameters("/projects/{projectId}/tags", pathParameters),
  2442  		autorest.WithQueryParameters(queryParameters),
  2443  		autorest.WithHeader("Training-Key", client.APIKey))
  2444  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2445  }
  2446  
  2447  // GetTagsSender sends the GetTags request. The method will close the
  2448  // http.Response Body if it receives an error.
  2449  func (client BaseClient) GetTagsSender(req *http.Request) (*http.Response, error) {
  2450  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2451  }
  2452  
  2453  // GetTagsResponder handles the response to the GetTags request. The method always
  2454  // closes the http.Response Body.
  2455  func (client BaseClient) GetTagsResponder(resp *http.Response) (result ListTag, err error) {
  2456  	err = autorest.Respond(
  2457  		resp,
  2458  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2459  		autorest.ByUnmarshallingJSON(&result.Value),
  2460  		autorest.ByClosing())
  2461  	result.Response = autorest.Response{Response: resp}
  2462  	return
  2463  }
  2464  
  2465  // GetUntaggedImageCount this API returns the images which have no tags for a given project and optionally an
  2466  // iteration. If no iteration is specified the
  2467  // current workspace is used.
  2468  // Parameters:
  2469  // projectID - the project id
  2470  // iterationID - the iteration id. Defaults to workspace
  2471  func (client BaseClient) GetUntaggedImageCount(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (result Int32, err error) {
  2472  	if tracing.IsEnabled() {
  2473  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetUntaggedImageCount")
  2474  		defer func() {
  2475  			sc := -1
  2476  			if result.Response.Response != nil {
  2477  				sc = result.Response.Response.StatusCode
  2478  			}
  2479  			tracing.EndSpan(ctx, sc, err)
  2480  		}()
  2481  	}
  2482  	req, err := client.GetUntaggedImageCountPreparer(ctx, projectID, iterationID)
  2483  	if err != nil {
  2484  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImageCount", nil, "Failure preparing request")
  2485  		return
  2486  	}
  2487  
  2488  	resp, err := client.GetUntaggedImageCountSender(req)
  2489  	if err != nil {
  2490  		result.Response = autorest.Response{Response: resp}
  2491  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImageCount", resp, "Failure sending request")
  2492  		return
  2493  	}
  2494  
  2495  	result, err = client.GetUntaggedImageCountResponder(resp)
  2496  	if err != nil {
  2497  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImageCount", resp, "Failure responding to request")
  2498  		return
  2499  	}
  2500  
  2501  	return
  2502  }
  2503  
  2504  // GetUntaggedImageCountPreparer prepares the GetUntaggedImageCount request.
  2505  func (client BaseClient) GetUntaggedImageCountPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID) (*http.Request, error) {
  2506  	pathParameters := map[string]interface{}{
  2507  		"projectId": autorest.Encode("path", projectID),
  2508  	}
  2509  
  2510  	queryParameters := map[string]interface{}{}
  2511  	if iterationID != nil {
  2512  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2513  	}
  2514  
  2515  	preparer := autorest.CreatePreparer(
  2516  		autorest.AsGet(),
  2517  		autorest.WithBaseURL(client.BaseURI),
  2518  		autorest.WithPathParameters("/projects/{projectId}/images/untagged/count", pathParameters),
  2519  		autorest.WithQueryParameters(queryParameters),
  2520  		autorest.WithHeader("Training-Key", client.APIKey))
  2521  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2522  }
  2523  
  2524  // GetUntaggedImageCountSender sends the GetUntaggedImageCount request. The method will close the
  2525  // http.Response Body if it receives an error.
  2526  func (client BaseClient) GetUntaggedImageCountSender(req *http.Request) (*http.Response, error) {
  2527  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2528  }
  2529  
  2530  // GetUntaggedImageCountResponder handles the response to the GetUntaggedImageCount request. The method always
  2531  // closes the http.Response Body.
  2532  func (client BaseClient) GetUntaggedImageCountResponder(resp *http.Response) (result Int32, err error) {
  2533  	err = autorest.Respond(
  2534  		resp,
  2535  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2536  		autorest.ByUnmarshallingJSON(&result.Value),
  2537  		autorest.ByClosing())
  2538  	result.Response = autorest.Response{Response: resp}
  2539  	return
  2540  }
  2541  
  2542  // GetUntaggedImages this API supports batching and range selection. By default it will only return first 50 images
  2543  // matching images.
  2544  // Use the {take} and {skip} parameters to control how many images to return in a given batch.
  2545  // Parameters:
  2546  // projectID - the project id
  2547  // iterationID - the iteration id. Defaults to workspace
  2548  // orderBy - the ordering. Defaults to newest
  2549  // take - maximum number of images to return. Defaults to 50, limited to 256
  2550  // skip - number of images to skip before beginning the image batch. Defaults to 0
  2551  func (client BaseClient) GetUntaggedImages(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, orderBy string, take *int32, skip *int32) (result ListImage, err error) {
  2552  	if tracing.IsEnabled() {
  2553  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.GetUntaggedImages")
  2554  		defer func() {
  2555  			sc := -1
  2556  			if result.Response.Response != nil {
  2557  				sc = result.Response.Response.StatusCode
  2558  			}
  2559  			tracing.EndSpan(ctx, sc, err)
  2560  		}()
  2561  	}
  2562  	req, err := client.GetUntaggedImagesPreparer(ctx, projectID, iterationID, orderBy, take, skip)
  2563  	if err != nil {
  2564  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImages", nil, "Failure preparing request")
  2565  		return
  2566  	}
  2567  
  2568  	resp, err := client.GetUntaggedImagesSender(req)
  2569  	if err != nil {
  2570  		result.Response = autorest.Response{Response: resp}
  2571  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImages", resp, "Failure sending request")
  2572  		return
  2573  	}
  2574  
  2575  	result, err = client.GetUntaggedImagesResponder(resp)
  2576  	if err != nil {
  2577  		err = autorest.NewErrorWithError(err, "training.BaseClient", "GetUntaggedImages", resp, "Failure responding to request")
  2578  		return
  2579  	}
  2580  
  2581  	return
  2582  }
  2583  
  2584  // GetUntaggedImagesPreparer prepares the GetUntaggedImages request.
  2585  func (client BaseClient) GetUntaggedImagesPreparer(ctx context.Context, projectID uuid.UUID, iterationID *uuid.UUID, orderBy string, take *int32, skip *int32) (*http.Request, error) {
  2586  	pathParameters := map[string]interface{}{
  2587  		"projectId": autorest.Encode("path", projectID),
  2588  	}
  2589  
  2590  	queryParameters := map[string]interface{}{}
  2591  	if iterationID != nil {
  2592  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2593  	}
  2594  	if len(string(orderBy)) > 0 {
  2595  		queryParameters["orderBy"] = autorest.Encode("query", orderBy)
  2596  	}
  2597  	if take != nil {
  2598  		queryParameters["take"] = autorest.Encode("query", *take)
  2599  	} else {
  2600  		queryParameters["take"] = autorest.Encode("query", 50)
  2601  	}
  2602  	if skip != nil {
  2603  		queryParameters["skip"] = autorest.Encode("query", *skip)
  2604  	} else {
  2605  		queryParameters["skip"] = autorest.Encode("query", 0)
  2606  	}
  2607  
  2608  	preparer := autorest.CreatePreparer(
  2609  		autorest.AsGet(),
  2610  		autorest.WithBaseURL(client.BaseURI),
  2611  		autorest.WithPathParameters("/projects/{projectId}/images/untagged", pathParameters),
  2612  		autorest.WithQueryParameters(queryParameters),
  2613  		autorest.WithHeader("Training-Key", client.APIKey))
  2614  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2615  }
  2616  
  2617  // GetUntaggedImagesSender sends the GetUntaggedImages request. The method will close the
  2618  // http.Response Body if it receives an error.
  2619  func (client BaseClient) GetUntaggedImagesSender(req *http.Request) (*http.Response, error) {
  2620  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2621  }
  2622  
  2623  // GetUntaggedImagesResponder handles the response to the GetUntaggedImages request. The method always
  2624  // closes the http.Response Body.
  2625  func (client BaseClient) GetUntaggedImagesResponder(resp *http.Response) (result ListImage, err error) {
  2626  	err = autorest.Respond(
  2627  		resp,
  2628  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2629  		autorest.ByUnmarshallingJSON(&result.Value),
  2630  		autorest.ByClosing())
  2631  	result.Response = autorest.Response{Response: resp}
  2632  	return
  2633  }
  2634  
  2635  // QueryPredictions sends the query predictions request.
  2636  // Parameters:
  2637  // projectID - the project id
  2638  // query - parameters used to query the predictions. Limited to combining 2 tags
  2639  func (client BaseClient) QueryPredictions(ctx context.Context, projectID uuid.UUID, query PredictionQueryToken) (result PredictionQueryResult, err error) {
  2640  	if tracing.IsEnabled() {
  2641  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QueryPredictions")
  2642  		defer func() {
  2643  			sc := -1
  2644  			if result.Response.Response != nil {
  2645  				sc = result.Response.Response.StatusCode
  2646  			}
  2647  			tracing.EndSpan(ctx, sc, err)
  2648  		}()
  2649  	}
  2650  	req, err := client.QueryPredictionsPreparer(ctx, projectID, query)
  2651  	if err != nil {
  2652  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QueryPredictions", nil, "Failure preparing request")
  2653  		return
  2654  	}
  2655  
  2656  	resp, err := client.QueryPredictionsSender(req)
  2657  	if err != nil {
  2658  		result.Response = autorest.Response{Response: resp}
  2659  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QueryPredictions", resp, "Failure sending request")
  2660  		return
  2661  	}
  2662  
  2663  	result, err = client.QueryPredictionsResponder(resp)
  2664  	if err != nil {
  2665  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QueryPredictions", resp, "Failure responding to request")
  2666  		return
  2667  	}
  2668  
  2669  	return
  2670  }
  2671  
  2672  // QueryPredictionsPreparer prepares the QueryPredictions request.
  2673  func (client BaseClient) QueryPredictionsPreparer(ctx context.Context, projectID uuid.UUID, query PredictionQueryToken) (*http.Request, error) {
  2674  	pathParameters := map[string]interface{}{
  2675  		"projectId": autorest.Encode("path", projectID),
  2676  	}
  2677  
  2678  	preparer := autorest.CreatePreparer(
  2679  		autorest.AsContentType("application/json; charset=utf-8"),
  2680  		autorest.AsPost(),
  2681  		autorest.WithBaseURL(client.BaseURI),
  2682  		autorest.WithPathParameters("/projects/{projectId}/predictions/query", pathParameters),
  2683  		autorest.WithJSON(query),
  2684  		autorest.WithHeader("Training-Key", client.APIKey))
  2685  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2686  }
  2687  
  2688  // QueryPredictionsSender sends the QueryPredictions request. The method will close the
  2689  // http.Response Body if it receives an error.
  2690  func (client BaseClient) QueryPredictionsSender(req *http.Request) (*http.Response, error) {
  2691  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2692  }
  2693  
  2694  // QueryPredictionsResponder handles the response to the QueryPredictions request. The method always
  2695  // closes the http.Response Body.
  2696  func (client BaseClient) QueryPredictionsResponder(resp *http.Response) (result PredictionQueryResult, err error) {
  2697  	err = autorest.Respond(
  2698  		resp,
  2699  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2700  		autorest.ByUnmarshallingJSON(&result),
  2701  		autorest.ByClosing())
  2702  	result.Response = autorest.Response{Response: resp}
  2703  	return
  2704  }
  2705  
  2706  // QuickTestImage sends the quick test image request.
  2707  // Parameters:
  2708  // projectID - the project id
  2709  // iterationID - optional. Specifies the id of a particular iteration to evaluate against.
  2710  // The default iteration for the project will be used when not specified.
  2711  func (client BaseClient) QuickTestImage(ctx context.Context, projectID uuid.UUID, imageData io.ReadCloser, iterationID *uuid.UUID) (result ImagePrediction, err error) {
  2712  	if tracing.IsEnabled() {
  2713  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QuickTestImage")
  2714  		defer func() {
  2715  			sc := -1
  2716  			if result.Response.Response != nil {
  2717  				sc = result.Response.Response.StatusCode
  2718  			}
  2719  			tracing.EndSpan(ctx, sc, err)
  2720  		}()
  2721  	}
  2722  	req, err := client.QuickTestImagePreparer(ctx, projectID, imageData, iterationID)
  2723  	if err != nil {
  2724  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImage", nil, "Failure preparing request")
  2725  		return
  2726  	}
  2727  
  2728  	resp, err := client.QuickTestImageSender(req)
  2729  	if err != nil {
  2730  		result.Response = autorest.Response{Response: resp}
  2731  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImage", resp, "Failure sending request")
  2732  		return
  2733  	}
  2734  
  2735  	result, err = client.QuickTestImageResponder(resp)
  2736  	if err != nil {
  2737  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImage", resp, "Failure responding to request")
  2738  		return
  2739  	}
  2740  
  2741  	return
  2742  }
  2743  
  2744  // QuickTestImagePreparer prepares the QuickTestImage request.
  2745  func (client BaseClient) QuickTestImagePreparer(ctx context.Context, projectID uuid.UUID, imageData io.ReadCloser, iterationID *uuid.UUID) (*http.Request, error) {
  2746  	pathParameters := map[string]interface{}{
  2747  		"projectId": autorest.Encode("path", projectID),
  2748  	}
  2749  
  2750  	queryParameters := map[string]interface{}{}
  2751  	if iterationID != nil {
  2752  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2753  	}
  2754  
  2755  	formDataParameters := map[string]interface{}{
  2756  		"imageData": imageData,
  2757  	}
  2758  
  2759  	preparer := autorest.CreatePreparer(
  2760  		autorest.AsPost(),
  2761  		autorest.WithBaseURL(client.BaseURI),
  2762  		autorest.WithPathParameters("/projects/{projectId}/quicktest/image", pathParameters),
  2763  		autorest.WithQueryParameters(queryParameters),
  2764  		autorest.WithMultiPartFormData(formDataParameters),
  2765  		autorest.WithHeader("Training-Key", client.APIKey))
  2766  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2767  }
  2768  
  2769  // QuickTestImageSender sends the QuickTestImage request. The method will close the
  2770  // http.Response Body if it receives an error.
  2771  func (client BaseClient) QuickTestImageSender(req *http.Request) (*http.Response, error) {
  2772  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2773  }
  2774  
  2775  // QuickTestImageResponder handles the response to the QuickTestImage request. The method always
  2776  // closes the http.Response Body.
  2777  func (client BaseClient) QuickTestImageResponder(resp *http.Response) (result ImagePrediction, err error) {
  2778  	err = autorest.Respond(
  2779  		resp,
  2780  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2781  		autorest.ByUnmarshallingJSON(&result),
  2782  		autorest.ByClosing())
  2783  	result.Response = autorest.Response{Response: resp}
  2784  	return
  2785  }
  2786  
  2787  // QuickTestImageURL sends the quick test image url request.
  2788  // Parameters:
  2789  // projectID - the project to evaluate against
  2790  // imageURL - an {Iris.Web.Api.Models.ImageUrl} that contains the url of the image to be evaluated
  2791  // iterationID - optional. Specifies the id of a particular iteration to evaluate against.
  2792  // The default iteration for the project will be used when not specified.
  2793  func (client BaseClient) QuickTestImageURL(ctx context.Context, projectID uuid.UUID, imageURL ImageURL, iterationID *uuid.UUID) (result ImagePrediction, err error) {
  2794  	if tracing.IsEnabled() {
  2795  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.QuickTestImageURL")
  2796  		defer func() {
  2797  			sc := -1
  2798  			if result.Response.Response != nil {
  2799  				sc = result.Response.Response.StatusCode
  2800  			}
  2801  			tracing.EndSpan(ctx, sc, err)
  2802  		}()
  2803  	}
  2804  	req, err := client.QuickTestImageURLPreparer(ctx, projectID, imageURL, iterationID)
  2805  	if err != nil {
  2806  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImageURL", nil, "Failure preparing request")
  2807  		return
  2808  	}
  2809  
  2810  	resp, err := client.QuickTestImageURLSender(req)
  2811  	if err != nil {
  2812  		result.Response = autorest.Response{Response: resp}
  2813  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImageURL", resp, "Failure sending request")
  2814  		return
  2815  	}
  2816  
  2817  	result, err = client.QuickTestImageURLResponder(resp)
  2818  	if err != nil {
  2819  		err = autorest.NewErrorWithError(err, "training.BaseClient", "QuickTestImageURL", resp, "Failure responding to request")
  2820  		return
  2821  	}
  2822  
  2823  	return
  2824  }
  2825  
  2826  // QuickTestImageURLPreparer prepares the QuickTestImageURL request.
  2827  func (client BaseClient) QuickTestImageURLPreparer(ctx context.Context, projectID uuid.UUID, imageURL ImageURL, iterationID *uuid.UUID) (*http.Request, error) {
  2828  	pathParameters := map[string]interface{}{
  2829  		"projectId": autorest.Encode("path", projectID),
  2830  	}
  2831  
  2832  	queryParameters := map[string]interface{}{}
  2833  	if iterationID != nil {
  2834  		queryParameters["iterationId"] = autorest.Encode("query", *iterationID)
  2835  	}
  2836  
  2837  	preparer := autorest.CreatePreparer(
  2838  		autorest.AsContentType("application/json; charset=utf-8"),
  2839  		autorest.AsPost(),
  2840  		autorest.WithBaseURL(client.BaseURI),
  2841  		autorest.WithPathParameters("/projects/{projectId}/quicktest/url", pathParameters),
  2842  		autorest.WithJSON(imageURL),
  2843  		autorest.WithQueryParameters(queryParameters),
  2844  		autorest.WithHeader("Training-Key", client.APIKey))
  2845  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2846  }
  2847  
  2848  // QuickTestImageURLSender sends the QuickTestImageURL request. The method will close the
  2849  // http.Response Body if it receives an error.
  2850  func (client BaseClient) QuickTestImageURLSender(req *http.Request) (*http.Response, error) {
  2851  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2852  }
  2853  
  2854  // QuickTestImageURLResponder handles the response to the QuickTestImageURL request. The method always
  2855  // closes the http.Response Body.
  2856  func (client BaseClient) QuickTestImageURLResponder(resp *http.Response) (result ImagePrediction, err error) {
  2857  	err = autorest.Respond(
  2858  		resp,
  2859  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2860  		autorest.ByUnmarshallingJSON(&result),
  2861  		autorest.ByClosing())
  2862  	result.Response = autorest.Response{Response: resp}
  2863  	return
  2864  }
  2865  
  2866  // TrainProject sends the train project request.
  2867  // Parameters:
  2868  // projectID - the project id
  2869  func (client BaseClient) TrainProject(ctx context.Context, projectID uuid.UUID) (result Iteration, err error) {
  2870  	if tracing.IsEnabled() {
  2871  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.TrainProject")
  2872  		defer func() {
  2873  			sc := -1
  2874  			if result.Response.Response != nil {
  2875  				sc = result.Response.Response.StatusCode
  2876  			}
  2877  			tracing.EndSpan(ctx, sc, err)
  2878  		}()
  2879  	}
  2880  	req, err := client.TrainProjectPreparer(ctx, projectID)
  2881  	if err != nil {
  2882  		err = autorest.NewErrorWithError(err, "training.BaseClient", "TrainProject", nil, "Failure preparing request")
  2883  		return
  2884  	}
  2885  
  2886  	resp, err := client.TrainProjectSender(req)
  2887  	if err != nil {
  2888  		result.Response = autorest.Response{Response: resp}
  2889  		err = autorest.NewErrorWithError(err, "training.BaseClient", "TrainProject", resp, "Failure sending request")
  2890  		return
  2891  	}
  2892  
  2893  	result, err = client.TrainProjectResponder(resp)
  2894  	if err != nil {
  2895  		err = autorest.NewErrorWithError(err, "training.BaseClient", "TrainProject", resp, "Failure responding to request")
  2896  		return
  2897  	}
  2898  
  2899  	return
  2900  }
  2901  
  2902  // TrainProjectPreparer prepares the TrainProject request.
  2903  func (client BaseClient) TrainProjectPreparer(ctx context.Context, projectID uuid.UUID) (*http.Request, error) {
  2904  	pathParameters := map[string]interface{}{
  2905  		"projectId": autorest.Encode("path", projectID),
  2906  	}
  2907  
  2908  	preparer := autorest.CreatePreparer(
  2909  		autorest.AsPost(),
  2910  		autorest.WithBaseURL(client.BaseURI),
  2911  		autorest.WithPathParameters("/projects/{projectId}/train", pathParameters),
  2912  		autorest.WithHeader("Training-Key", client.APIKey))
  2913  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2914  }
  2915  
  2916  // TrainProjectSender sends the TrainProject request. The method will close the
  2917  // http.Response Body if it receives an error.
  2918  func (client BaseClient) TrainProjectSender(req *http.Request) (*http.Response, error) {
  2919  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  2920  }
  2921  
  2922  // TrainProjectResponder handles the response to the TrainProject request. The method always
  2923  // closes the http.Response Body.
  2924  func (client BaseClient) TrainProjectResponder(resp *http.Response) (result Iteration, err error) {
  2925  	err = autorest.Respond(
  2926  		resp,
  2927  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  2928  		autorest.ByUnmarshallingJSON(&result),
  2929  		autorest.ByClosing())
  2930  	result.Response = autorest.Response{Response: resp}
  2931  	return
  2932  }
  2933  
  2934  // UpdateIteration sends the update iteration request.
  2935  // Parameters:
  2936  // projectID - project id
  2937  // iterationID - iteration id
  2938  // updatedIteration - the updated iteration model
  2939  func (client BaseClient) UpdateIteration(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, updatedIteration Iteration) (result Iteration, err error) {
  2940  	if tracing.IsEnabled() {
  2941  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.UpdateIteration")
  2942  		defer func() {
  2943  			sc := -1
  2944  			if result.Response.Response != nil {
  2945  				sc = result.Response.Response.StatusCode
  2946  			}
  2947  			tracing.EndSpan(ctx, sc, err)
  2948  		}()
  2949  	}
  2950  	req, err := client.UpdateIterationPreparer(ctx, projectID, iterationID, updatedIteration)
  2951  	if err != nil {
  2952  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateIteration", nil, "Failure preparing request")
  2953  		return
  2954  	}
  2955  
  2956  	resp, err := client.UpdateIterationSender(req)
  2957  	if err != nil {
  2958  		result.Response = autorest.Response{Response: resp}
  2959  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateIteration", resp, "Failure sending request")
  2960  		return
  2961  	}
  2962  
  2963  	result, err = client.UpdateIterationResponder(resp)
  2964  	if err != nil {
  2965  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateIteration", resp, "Failure responding to request")
  2966  		return
  2967  	}
  2968  
  2969  	return
  2970  }
  2971  
  2972  // UpdateIterationPreparer prepares the UpdateIteration request.
  2973  func (client BaseClient) UpdateIterationPreparer(ctx context.Context, projectID uuid.UUID, iterationID uuid.UUID, updatedIteration Iteration) (*http.Request, error) {
  2974  	pathParameters := map[string]interface{}{
  2975  		"iterationId": autorest.Encode("path", iterationID),
  2976  		"projectId":   autorest.Encode("path", projectID),
  2977  	}
  2978  
  2979  	updatedIteration.ID = nil
  2980  	updatedIteration.Status = nil
  2981  	updatedIteration.Created = nil
  2982  	updatedIteration.LastModified = nil
  2983  	updatedIteration.TrainedAt = nil
  2984  	updatedIteration.ProjectID = nil
  2985  	updatedIteration.Exportable = nil
  2986  	updatedIteration.DomainID = nil
  2987  	updatedIteration.ClassificationType = ""
  2988  	preparer := autorest.CreatePreparer(
  2989  		autorest.AsContentType("application/json; charset=utf-8"),
  2990  		autorest.AsPatch(),
  2991  		autorest.WithBaseURL(client.BaseURI),
  2992  		autorest.WithPathParameters("/projects/{projectId}/iterations/{iterationId}", pathParameters),
  2993  		autorest.WithJSON(updatedIteration),
  2994  		autorest.WithHeader("Training-Key", client.APIKey))
  2995  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  2996  }
  2997  
  2998  // UpdateIterationSender sends the UpdateIteration request. The method will close the
  2999  // http.Response Body if it receives an error.
  3000  func (client BaseClient) UpdateIterationSender(req *http.Request) (*http.Response, error) {
  3001  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3002  }
  3003  
  3004  // UpdateIterationResponder handles the response to the UpdateIteration request. The method always
  3005  // closes the http.Response Body.
  3006  func (client BaseClient) UpdateIterationResponder(resp *http.Response) (result Iteration, err error) {
  3007  	err = autorest.Respond(
  3008  		resp,
  3009  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3010  		autorest.ByUnmarshallingJSON(&result),
  3011  		autorest.ByClosing())
  3012  	result.Response = autorest.Response{Response: resp}
  3013  	return
  3014  }
  3015  
  3016  // UpdateProject sends the update project request.
  3017  // Parameters:
  3018  // projectID - the id of the project to update
  3019  // updatedProject - the updated project model
  3020  func (client BaseClient) UpdateProject(ctx context.Context, projectID uuid.UUID, updatedProject Project) (result Project, err error) {
  3021  	if tracing.IsEnabled() {
  3022  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.UpdateProject")
  3023  		defer func() {
  3024  			sc := -1
  3025  			if result.Response.Response != nil {
  3026  				sc = result.Response.Response.StatusCode
  3027  			}
  3028  			tracing.EndSpan(ctx, sc, err)
  3029  		}()
  3030  	}
  3031  	req, err := client.UpdateProjectPreparer(ctx, projectID, updatedProject)
  3032  	if err != nil {
  3033  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateProject", nil, "Failure preparing request")
  3034  		return
  3035  	}
  3036  
  3037  	resp, err := client.UpdateProjectSender(req)
  3038  	if err != nil {
  3039  		result.Response = autorest.Response{Response: resp}
  3040  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateProject", resp, "Failure sending request")
  3041  		return
  3042  	}
  3043  
  3044  	result, err = client.UpdateProjectResponder(resp)
  3045  	if err != nil {
  3046  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateProject", resp, "Failure responding to request")
  3047  		return
  3048  	}
  3049  
  3050  	return
  3051  }
  3052  
  3053  // UpdateProjectPreparer prepares the UpdateProject request.
  3054  func (client BaseClient) UpdateProjectPreparer(ctx context.Context, projectID uuid.UUID, updatedProject Project) (*http.Request, error) {
  3055  	pathParameters := map[string]interface{}{
  3056  		"projectId": autorest.Encode("path", projectID),
  3057  	}
  3058  
  3059  	updatedProject.ID = nil
  3060  	updatedProject.Created = nil
  3061  	updatedProject.LastModified = nil
  3062  	updatedProject.ThumbnailURI = nil
  3063  	preparer := autorest.CreatePreparer(
  3064  		autorest.AsContentType("application/json; charset=utf-8"),
  3065  		autorest.AsPatch(),
  3066  		autorest.WithBaseURL(client.BaseURI),
  3067  		autorest.WithPathParameters("/projects/{projectId}", pathParameters),
  3068  		autorest.WithJSON(updatedProject),
  3069  		autorest.WithHeader("Training-Key", client.APIKey))
  3070  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3071  }
  3072  
  3073  // UpdateProjectSender sends the UpdateProject request. The method will close the
  3074  // http.Response Body if it receives an error.
  3075  func (client BaseClient) UpdateProjectSender(req *http.Request) (*http.Response, error) {
  3076  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3077  }
  3078  
  3079  // UpdateProjectResponder handles the response to the UpdateProject request. The method always
  3080  // closes the http.Response Body.
  3081  func (client BaseClient) UpdateProjectResponder(resp *http.Response) (result Project, err error) {
  3082  	err = autorest.Respond(
  3083  		resp,
  3084  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3085  		autorest.ByUnmarshallingJSON(&result),
  3086  		autorest.ByClosing())
  3087  	result.Response = autorest.Response{Response: resp}
  3088  	return
  3089  }
  3090  
  3091  // UpdateTag sends the update tag request.
  3092  // Parameters:
  3093  // projectID - the project id
  3094  // tagID - the id of the target tag
  3095  // updatedTag - the updated tag model
  3096  func (client BaseClient) UpdateTag(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, updatedTag Tag) (result Tag, err error) {
  3097  	if tracing.IsEnabled() {
  3098  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.UpdateTag")
  3099  		defer func() {
  3100  			sc := -1
  3101  			if result.Response.Response != nil {
  3102  				sc = result.Response.Response.StatusCode
  3103  			}
  3104  			tracing.EndSpan(ctx, sc, err)
  3105  		}()
  3106  	}
  3107  	req, err := client.UpdateTagPreparer(ctx, projectID, tagID, updatedTag)
  3108  	if err != nil {
  3109  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateTag", nil, "Failure preparing request")
  3110  		return
  3111  	}
  3112  
  3113  	resp, err := client.UpdateTagSender(req)
  3114  	if err != nil {
  3115  		result.Response = autorest.Response{Response: resp}
  3116  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateTag", resp, "Failure sending request")
  3117  		return
  3118  	}
  3119  
  3120  	result, err = client.UpdateTagResponder(resp)
  3121  	if err != nil {
  3122  		err = autorest.NewErrorWithError(err, "training.BaseClient", "UpdateTag", resp, "Failure responding to request")
  3123  		return
  3124  	}
  3125  
  3126  	return
  3127  }
  3128  
  3129  // UpdateTagPreparer prepares the UpdateTag request.
  3130  func (client BaseClient) UpdateTagPreparer(ctx context.Context, projectID uuid.UUID, tagID uuid.UUID, updatedTag Tag) (*http.Request, error) {
  3131  	pathParameters := map[string]interface{}{
  3132  		"projectId": autorest.Encode("path", projectID),
  3133  		"tagId":     autorest.Encode("path", tagID),
  3134  	}
  3135  
  3136  	updatedTag.ID = nil
  3137  	updatedTag.ImageCount = nil
  3138  	preparer := autorest.CreatePreparer(
  3139  		autorest.AsContentType("application/json; charset=utf-8"),
  3140  		autorest.AsPatch(),
  3141  		autorest.WithBaseURL(client.BaseURI),
  3142  		autorest.WithPathParameters("/projects/{projectId}/tags/{tagId}", pathParameters),
  3143  		autorest.WithJSON(updatedTag),
  3144  		autorest.WithHeader("Training-Key", client.APIKey))
  3145  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  3146  }
  3147  
  3148  // UpdateTagSender sends the UpdateTag request. The method will close the
  3149  // http.Response Body if it receives an error.
  3150  func (client BaseClient) UpdateTagSender(req *http.Request) (*http.Response, error) {
  3151  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
  3152  }
  3153  
  3154  // UpdateTagResponder handles the response to the UpdateTag request. The method always
  3155  // closes the http.Response Body.
  3156  func (client BaseClient) UpdateTagResponder(resp *http.Response) (result Tag, err error) {
  3157  	err = autorest.Respond(
  3158  		resp,
  3159  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  3160  		autorest.ByUnmarshallingJSON(&result),
  3161  		autorest.ByClosing())
  3162  	result.Response = autorest.Response{Response: resp}
  3163  	return
  3164  }
  3165  

View as plain text