path: root/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_generated_blob.go

package azblob

// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

import (
    "context"
    "encoding/base64"
    "io"
    "io/ioutil"
    "net/http"
    "net/url"
    "strconv"
    "time"

    "github.com/Azure/azure-pipeline-go/pipeline"
)

// blobClient is the client for the Blob methods of the Azblob service.
type blobClient struct {
    managementClient
}

// newBlobClient creates an instance of the blobClient client.
func newBlobClient(url url.URL, p pipeline.Pipeline) blobClient {
    return blobClient{newManagementClient(url, p)}
}

// AbortCopyFromURL the Abort Copy From URL operation aborts a pending Copy From URL operation, and leaves a
// destination blob with zero length and full metadata.
//
// copyID is the copy identifier provided in the x-ms-copy-id header of the original Copy Blob operation. timeout is
// the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
// lease is active and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character
// limit that is recorded in the analytics logs when storage analytics logging is enabled.
func (client blobClient) AbortCopyFromURL(ctx context.Context, copyID string, timeout *int32, leaseID *string, requestID *string) (*BlobAbortCopyFromURLResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.abortCopyFromURLPreparer(copyID, timeout, leaseID, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.abortCopyFromURLResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobAbortCopyFromURLResponse), err
}

// abortCopyFromURLPreparer prepares the AbortCopyFromURL request.
func (client blobClient) abortCopyFromURLPreparer(copyID string, timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    params.Set("copyid", copyID)
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "copy")
    req.URL.RawQuery = params.Encode()
    if leaseID != nil {
        req.Header.Set("x-ms-lease-id", *leaseID)
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    req.Header.Set("x-ms-copy-action", "abort")
    return req, nil
}

// abortCopyFromURLResponder handles the response to the AbortCopyFromURL request.
func (client blobClient) abortCopyFromURLResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK, http.StatusNoContent)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobAbortCopyFromURLResponse{rawResponse: resp.Response()}, err
}

// AcquireLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
// operations
//
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> duration is specifies the duration of the lease, in seconds, or negative
// one (-1) for a lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease duration
// cannot be changed using renew or change. proposedLeaseID is proposed lease ID, in a GUID string format. The Blob
// service returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid Constructor
// (String) for a list of valid GUID string formats. ifModifiedSince is specify this header value to operate only on a
// blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
// recorded in the analytics logs when storage analytics logging is enabled.
func (client blobClient) AcquireLease(ctx context.Context, timeout *int32, duration *int32, proposedLeaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobAcquireLeaseResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.acquireLeasePreparer(timeout, duration, proposedLeaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.acquireLeaseResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobAcquireLeaseResponse), err
}

// acquireLeasePreparer prepares the AcquireLease request.
func (client blobClient) acquireLeasePreparer(timeout *int32, duration *int32, proposedLeaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "lease")
    req.URL.RawQuery = params.Encode()
    if duration != nil {
        req.Header.Set("x-ms-lease-duration", strconv.FormatInt(int64(*duration), 10))
    }
    if proposedLeaseID != nil {
        req.Header.Set("x-ms-proposed-lease-id", *proposedLeaseID)
    }
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    req.Header.Set("x-ms-lease-action", "acquire")
    return req, nil
}

// acquireLeaseResponder handles the response to the AcquireLease request.
func (client blobClient) acquireLeaseResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK, http.StatusCreated)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobAcquireLeaseResponse{rawResponse: resp.Response()}, err
}

// BreakLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
// operations
//
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> breakPeriod is for a break operation, proposed duration the lease should
// continue before it is broken, in seconds, between 0 and 60. This break period is only used if it is shorter than the
// time remaining on the lease. If longer, the time remaining on the lease is used. A new lease will not be available
// before the break period has expired, but the lease may be held for longer than the break period. If this header does
// not appear with a break operation, a fixed-duration lease breaks after the remaining lease period elapses, and an
// infinite lease breaks immediately. ifModifiedSince is specify this header value to operate only on a blob if it has
// been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
// value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the
// analytics logs when storage analytics logging is enabled.
func (client blobClient) BreakLease(ctx context.Context, timeout *int32, breakPeriod *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobBreakLeaseResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.breakLeasePreparer(timeout, breakPeriod, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.breakLeaseResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobBreakLeaseResponse), err
}

// breakLeasePreparer prepares the BreakLease request.
func (client blobClient) breakLeasePreparer(timeout *int32, breakPeriod *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "lease")
    req.URL.RawQuery = params.Encode()
    if breakPeriod != nil {
        req.Header.Set("x-ms-lease-break-period", strconv.FormatInt(int64(*breakPeriod), 10))
    }
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    req.Header.Set("x-ms-lease-action", "break")
    return req, nil
}

// breakLeaseResponder handles the response to the BreakLease request.
func (client blobClient) breakLeaseResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobBreakLeaseResponse{rawResponse: resp.Response()}, err
}

// ChangeLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
// operations
//
// leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
// proposedLeaseID is proposed lease ID, in a GUID string format. The Blob service returns 400 (Invalid request) if the
// proposed lease ID is not in the correct format. See Guid Constructor (String) for a list of valid GUID string
// formats. timeout is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> ifModifiedSince is specify this header value to operate only on a blob if
// it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only
// on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate
// only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a
// matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded
// in the analytics logs when storage analytics logging is enabled.
func (client blobClient) ChangeLease(ctx context.Context, leaseID string, proposedLeaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobChangeLeaseResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.changeLeasePreparer(leaseID, proposedLeaseID, timeout, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.changeLeaseResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobChangeLeaseResponse), err
}

// changeLeasePreparer prepares the ChangeLease request.
func (client blobClient) changeLeasePreparer(leaseID string, proposedLeaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "lease")
    req.URL.RawQuery = params.Encode()
    req.Header.Set("x-ms-lease-id", leaseID)
    req.Header.Set("x-ms-proposed-lease-id", proposedLeaseID)
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    req.Header.Set("x-ms-lease-action", "change")
    return req, nil
}

// changeLeaseResponder handles the response to the ChangeLease request.
func (client blobClient) changeLeaseResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobChangeLeaseResponse{rawResponse: resp.Response()}, err
}

// CreateSnapshot the Create Snapshot operation creates a read-only snapshot of a blob
//
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> metadata is optional. Specifies a user-defined name-value pair associated
// with the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or
// file to the destination blob. If one or more name-value pairs are specified, the destination blob is created with
// the specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
// Containers, Blobs, and Metadata for more information. ifModifiedSince is specify this header value to operate only
// on a blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
// without a matching value. leaseID is if specified, the operation only succeeds if the container's lease is active
// and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
// recorded in the analytics logs when storage analytics logging is enabled.
func (client blobClient) CreateSnapshot(ctx context.Context, timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, requestID *string) (*BlobCreateSnapshotResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
        {targetValue: metadata,
            constraints: []constraint{{target: "metadata", name: null, rule: false,
                chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.createSnapshotPreparer(timeout, metadata, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, leaseID, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.createSnapshotResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobCreateSnapshotResponse), err
}

// createSnapshotPreparer prepares the CreateSnapshot request.
func (client blobClient) createSnapshotPreparer(timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "snapshot")
    req.URL.RawQuery = params.Encode()
    if metadata != nil {
        for k, v := range metadata {
            req.Header.Set("x-ms-meta-"+k, v)
        }
    }
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    if leaseID != nil {
        req.Header.Set("x-ms-lease-id", *leaseID)
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    return req, nil
}

// createSnapshotResponder handles the response to the CreateSnapshot request.
func (client blobClient) createSnapshotResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK, http.StatusCreated)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobCreateSnapshotResponse{rawResponse: resp.Response()}, err
}

// Delete if the storage account's soft delete feature is disabled then, when a blob is deleted, it is permanently
// removed from the storage account. If the storage account's soft delete feature is enabled, then, when a blob is
// deleted, it is marked for deletion and becomes inaccessible immediately. However, the blob service retains the blob
// or snapshot for the number of days specified by the DeleteRetentionPolicy section of [Storage service properties]
// (Set-Blob-Service-Properties.md). After the specified number of days has passed, the blob's data is permanently
// removed from the storage account. Note that you continue to be charged for the soft-deleted blob's storage until it
// is permanently removed. Use the List Blobs API and specify the "include=deleted" query parameter to discover which
// blobs and snapshots have been soft deleted. You can then use the Undelete Blob API to restore a soft-deleted blob.
// All other operations on a soft-deleted blob or snapshot causes the service to return an HTTP status code of 404
// (ResourceNotFound).
//
// snapshot is the snapshot parameter is an opaque DateTime value that, when present, specifies the blob snapshot to
// retrieve. For more information on working with blob snapshots, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/creating-a-snapshot-of-a-blob">Creating
// a Snapshot of a Blob.</a> timeout is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
// lease is active and matches this ID. deleteSnapshots is required if the blob has associated snapshots. Specify one
// of the following two options: include: Delete the base blob and all of its snapshots. only: Delete only the blob's
// snapshots and not the blob itself ifModifiedSince is specify this header value to operate only on a blob if it has
// been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
// value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the
// analytics logs when storage analytics logging is enabled.
func (client blobClient) Delete(ctx context.Context, snapshot *string, timeout *int32, leaseID *string, deleteSnapshots DeleteSnapshotsOptionType, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobDeleteResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.deletePreparer(snapshot, timeout, leaseID, deleteSnapshots, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.deleteResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobDeleteResponse), err
}

// deletePreparer prepares the Delete request.
func (client blobClient) deletePreparer(snapshot *string, timeout *int32, leaseID *string, deleteSnapshots DeleteSnapshotsOptionType, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("DELETE", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if snapshot != nil && len(*snapshot) > 0 {
        params.Set("snapshot", *snapshot)
    }
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    req.URL.RawQuery = params.Encode()
    if leaseID != nil {
        req.Header.Set("x-ms-lease-id", *leaseID)
    }
    if deleteSnapshots != DeleteSnapshotsOptionNone {
        req.Header.Set("x-ms-delete-snapshots", string(deleteSnapshots))
    }
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    return req, nil
}

// deleteResponder handles the response to the Delete request.
func (client blobClient) deleteResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobDeleteResponse{rawResponse: resp.Response()}, err
}

// Download the Download operation reads or downloads a blob from the system, including its metadata and properties.
// You can also call Download to read a snapshot.
//
// snapshot is the snapshot parameter is an opaque DateTime value that, when present, specifies the blob snapshot to
// retrieve. For more information on working with blob snapshots, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/creating-a-snapshot-of-a-blob">Creating
// a Snapshot of a Blob.</a> timeout is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> rangeParameter is return only the bytes of the blob in the specified
// range. leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
// rangeGetContentMD5 is when set to true and specified together with the Range, the service returns the MD5 hash for
// the range, as long as the range is less than or equal to 4 MB in size. ifModifiedSince is specify this header value
// to operate only on a blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this
// header value to operate only on a blob if it has not been modified since the specified date/time. ifMatches is
// specify an ETag value to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to
// operate only on blobs without a matching value. requestID is provides a client-generated, opaque value with a 1 KB
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
func (client blobClient) Download(ctx context.Context, snapshot *string, timeout *int32, rangeParameter *string, leaseID *string, rangeGetContentMD5 *bool, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*downloadResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.downloadPreparer(snapshot, timeout, rangeParameter, leaseID, rangeGetContentMD5, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.downloadResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*downloadResponse), err
}

// downloadPreparer prepares the Download request.
func (client blobClient) downloadPreparer(snapshot *string, timeout *int32, rangeParameter *string, leaseID *string, rangeGetContentMD5 *bool, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("GET", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if snapshot != nil && len(*snapshot) > 0 {
        params.Set("snapshot", *snapshot)
    }
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    req.URL.RawQuery = params.Encode()
    if rangeParameter != nil {
        req.Header.Set("x-ms-range", *rangeParameter)
    }
    if leaseID != nil {
        req.Header.Set("x-ms-lease-id", *leaseID)
    }
    if rangeGetContentMD5 != nil {
        req.Header.Set("x-ms-range-get-content-md5", strconv.FormatBool(*rangeGetContentMD5))
    }
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    return req, nil
}

// downloadResponder handles the response to the Download request.
func (client blobClient) downloadResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK, http.StatusPartialContent)
    if resp == nil {
        return nil, err
    }
    return &downloadResponse{rawResponse: resp.Response()}, err
}

// GetProperties the Get Properties operation returns all user-defined metadata, standard HTTP properties, and system
// properties for the blob. It does not return the content of the blob.
//
// snapshot is the snapshot parameter is an opaque DateTime value that, when present, specifies the blob snapshot to
// retrieve. For more information on working with blob snapshots, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/creating-a-snapshot-of-a-blob">Creating
// a Snapshot of a Blob.</a> timeout is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
// lease is active and matches this ID. ifModifiedSince is specify this header value to operate only on a blob if it
// has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
// value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the
// analytics logs when storage analytics logging is enabled.
func (client blobClient) GetProperties(ctx context.Context, snapshot *string, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobGetPropertiesResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.getPropertiesPreparer(snapshot, timeout, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getPropertiesResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobGetPropertiesResponse), err
}

// getPropertiesPreparer prepares the GetProperties request.
func (client blobClient) getPropertiesPreparer(snapshot *string, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("HEAD", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if snapshot != nil && len(*snapshot) > 0 {
        params.Set("snapshot", *snapshot)
    }
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    req.URL.RawQuery = params.Encode()
    if leaseID != nil {
        req.Header.Set("x-ms-lease-id", *leaseID)
    }
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    return req, nil
}

// getPropertiesResponder handles the response to the GetProperties request.
func (client blobClient) getPropertiesResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobGetPropertiesResponse{rawResponse: resp.Response()}, err
}

// ReleaseLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
// operations
//
// leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID. timeout
// is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> ifModifiedSince is specify this header value to operate only on a blob if
// it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only
// on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate
// only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a
// matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded
// in the analytics logs when storage analytics logging is enabled.
func (client blobClient) ReleaseLease(ctx context.Context, leaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobReleaseLeaseResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.releaseLeasePreparer(leaseID, timeout, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.releaseLeaseResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobReleaseLeaseResponse), err
}

// releaseLeasePreparer prepares the ReleaseLease request.
func (client blobClient) releaseLeasePreparer(leaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "lease")
    req.URL.RawQuery = params.Encode()
    req.Header.Set("x-ms-lease-id", leaseID)
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    req.Header.Set("x-ms-lease-action", "release")
    return req, nil
}

// releaseLeaseResponder handles the response to the ReleaseLease request.
func (client blobClient) releaseLeaseResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobReleaseLeaseResponse{rawResponse: resp.Response()}, err
}

// RenewLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
// operations
//
// leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID. timeout
// is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> ifModifiedSince is specify this header value to operate only on a blob if
// it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only
// on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate
// only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a
// matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded
// in the analytics logs when storage analytics logging is enabled.
func (client blobClient) RenewLease(ctx context.Context, leaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobRenewLeaseResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.renewLeasePreparer(leaseID, timeout, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.renewLeaseResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobRenewLeaseResponse), err
}

// renewLeasePreparer prepares the RenewLease request.
func (client blobClient) renewLeasePreparer(leaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "lease")
    req.URL.RawQuery = params.Encode()
    req.Header.Set("x-ms-lease-id", leaseID)
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    req.Header.Set("x-ms-lease-action", "renew")
    return req, nil
}

// renewLeaseResponder handles the response to the RenewLease request.
func (client blobClient) renewLeaseResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobRenewLeaseResponse{rawResponse: resp.Response()}, err
}

// SetHTTPHeaders the Set HTTP Headers operation sets system properties on the blob
//
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> blobCacheControl is optional. Sets the blob's cache control. If specified,
// this property is stored with the blob and returned with a read request. blobContentType is optional. Sets the blob's
// content type. If specified, this property is stored with the blob and returned with a read request. blobContentMD5
// is optional. An MD5 hash of the blob content. Note that this hash is not validated, as the hashes for the individual
// blocks were validated when each was uploaded. blobContentEncoding is optional. Sets the blob's content encoding. If
// specified, this property is stored with the blob and returned with a read request. blobContentLanguage is optional.
// Set the blob's content language. If specified, this property is stored with the blob and returned with a read
// request. leaseID is if specified, the operation only succeeds if the container's lease is active and matches this
// ID. ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the
// specified date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been
// modified since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching
// value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching value.
// blobContentDisposition is optional. Sets the blob's Content-Disposition header. requestID is provides a
// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
// analytics logging is enabled.
func (client blobClient) SetHTTPHeaders(ctx context.Context, timeout *int32, blobCacheControl *string, blobContentType *string, blobContentMD5 []byte, blobContentEncoding *string, blobContentLanguage *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobContentDisposition *string, requestID *string) (*BlobSetHTTPHeadersResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.setHTTPHeadersPreparer(timeout, blobCacheControl, blobContentType, blobContentMD5, blobContentEncoding, blobContentLanguage, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, blobContentDisposition, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setHTTPHeadersResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobSetHTTPHeadersResponse), err
}

// setHTTPHeadersPreparer prepares the SetHTTPHeaders request.
func (client blobClient) setHTTPHeadersPreparer(timeout *int32, blobCacheControl *string, blobContentType *string, blobContentMD5 []byte, blobContentEncoding *string, blobContentLanguage *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobContentDisposition *string, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "properties")
    req.URL.RawQuery = params.Encode()
    if blobCacheControl != nil {
        req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
    }
    if blobContentType != nil {
        req.Header.Set("x-ms-blob-content-type", *blobContentType)
    }
    if blobContentMD5 != nil {
        req.Header.Set("x-ms-blob-content-md5", base64.StdEncoding.EncodeToString(blobContentMD5))
    }
    if blobContentEncoding != nil {
        req.Header.Set("x-ms-blob-content-encoding", *blobContentEncoding)
    }
    if blobContentLanguage != nil {
        req.Header.Set("x-ms-blob-content-language", *blobContentLanguage)
    }
    if leaseID != nil {
        req.Header.Set("x-ms-lease-id", *leaseID)
    }
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    if blobContentDisposition != nil {
        req.Header.Set("x-ms-blob-content-disposition", *blobContentDisposition)
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    return req, nil
}

// setHTTPHeadersResponder handles the response to the SetHTTPHeaders request.
func (client blobClient) setHTTPHeadersResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobSetHTTPHeadersResponse{rawResponse: resp.Response()}, err
}

// SetMetadata the Set Blob Metadata operation sets user-defined metadata for the specified blob as one or more
// name-value pairs
//
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> metadata is optional. Specifies a user-defined name-value pair associated
// with the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or
// file to the destination blob. If one or more name-value pairs are specified, the destination blob is created with
// the specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
// Containers, Blobs, and Metadata for more information. leaseID is if specified, the operation only succeeds if the
// container's lease is active and matches this ID. ifModifiedSince is specify this header value to operate only on a
// blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
// recorded in the analytics logs when storage analytics logging is enabled.
func (client blobClient) SetMetadata(ctx context.Context, timeout *int32, metadata map[string]string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobSetMetadataResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
        {targetValue: metadata,
            constraints: []constraint{{target: "metadata", name: null, rule: false,
                chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.setMetadataPreparer(timeout, metadata, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setMetadataResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobSetMetadataResponse), err
}

// setMetadataPreparer prepares the SetMetadata request.
func (client blobClient) setMetadataPreparer(timeout *int32, metadata map[string]string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "metadata")
    req.URL.RawQuery = params.Encode()
    if metadata != nil {
        for k, v := range metadata {
            req.Header.Set("x-ms-meta-"+k, v)
        }
    }
    if leaseID != nil {
        req.Header.Set("x-ms-lease-id", *leaseID)
    }
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    return req, nil
}

// setMetadataResponder handles the response to the SetMetadata request.
func (client blobClient) setMetadataResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobSetMetadataResponse{rawResponse: resp.Response()}, err
}

// SetTier the Set Tier operation sets the tier on a blob. The operation is allowed on a page blob in a premium storage
// account and on a block blob in a blob storage account (locally redundant storage only). A premium page blob's tier
// determines the allowed size, IOPS, and bandwidth of the blob. A block blob's tier determines Hot/Cool/Archive
// storage type. This operation does not update the blob's ETag.
//
// tier is indicates the tier to be set on the blob. timeout is the timeout parameter is expressed in seconds. For more
// information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> requestID is provides a client-generated, opaque value with a 1 KB
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
func (client blobClient) SetTier(ctx context.Context, tier AccessTierType, timeout *int32, requestID *string) (*BlobSetTierResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.setTierPreparer(tier, timeout, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setTierResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobSetTierResponse), err
}

// setTierPreparer prepares the SetTier request.
func (client blobClient) setTierPreparer(tier AccessTierType, timeout *int32, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "tier")
    req.URL.RawQuery = params.Encode()
    req.Header.Set("x-ms-access-tier", string(tier))
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    return req, nil
}

// setTierResponder handles the response to the SetTier request.
func (client blobClient) setTierResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobSetTierResponse{rawResponse: resp.Response()}, err
}

// StartCopyFromURL the Start Copy From URL operation copies a blob or an internet resource to a new blob.
//
// copySource is specifies the name of the source page blob snapshot. This value is a URL of up to 2 KB in length that
// specifies a page blob snapshot. The value should be URL-encoded as it would appear in a request URI. The source blob
// must either be public or must be authenticated via a shared access signature. timeout is the timeout parameter is
// expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> metadata is optional. Specifies a user-defined name-value pair associated
// with the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or
// file to the destination blob. If one or more name-value pairs are specified, the destination blob is created with
// the specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
// Containers, Blobs, and Metadata for more information. sourceIfModifiedSince is specify this header value to operate
// only on a blob if it has been modified since the specified date/time. sourceIfUnmodifiedSince is specify this header
// value to operate only on a blob if it has not been modified since the specified date/time. sourceIfMatches is
// specify an ETag value to operate only on blobs with a matching value. sourceIfNoneMatch is specify an ETag value to
// operate only on blobs without a matching value. ifModifiedSince is specify this header value to operate only on a
// blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
// without a matching value. leaseID is if specified, the operation only succeeds if the container's lease is active
// and matches this ID. sourceLeaseID is specify this header to perform the operation only if the lease ID given
// matches the active lease ID of the source blob. requestID is provides a client-generated, opaque value with a 1 KB
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
func (client blobClient) StartCopyFromURL(ctx context.Context, copySource string, timeout *int32, metadata map[string]string, sourceIfModifiedSince *time.Time, sourceIfUnmodifiedSince *time.Time, sourceIfMatches *ETag, sourceIfNoneMatch *ETag, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, sourceLeaseID *string, requestID *string) (*BlobStartCopyFromURLResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
        {targetValue: metadata,
            constraints: []constraint{{target: "metadata", name: null, rule: false,
                chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.startCopyFromURLPreparer(copySource, timeout, metadata, sourceIfModifiedSince, sourceIfUnmodifiedSince, sourceIfMatches, sourceIfNoneMatch, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, leaseID, sourceLeaseID, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.startCopyFromURLResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobStartCopyFromURLResponse), err
}

// startCopyFromURLPreparer prepares the StartCopyFromURL request.
func (client blobClient) startCopyFromURLPreparer(copySource string, timeout *int32, metadata map[string]string, sourceIfModifiedSince *time.Time, sourceIfUnmodifiedSince *time.Time, sourceIfMatches *ETag, sourceIfNoneMatch *ETag, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, sourceLeaseID *string, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    req.URL.RawQuery = params.Encode()
    if metadata != nil {
        for k, v := range metadata {
            req.Header.Set("x-ms-meta-"+k, v)
        }
    }
    if sourceIfModifiedSince != nil {
        req.Header.Set("x-ms-source-if-modified-since", (*sourceIfModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if sourceIfUnmodifiedSince != nil {
        req.Header.Set("x-ms-source-if-unmodified-since", (*sourceIfUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if sourceIfMatches != nil {
        req.Header.Set("x-ms-source-if-match", string(*sourceIfMatches))
    }
    if sourceIfNoneMatch != nil {
        req.Header.Set("x-ms-source-if-none-match", string(*sourceIfNoneMatch))
    }
    if ifModifiedSince != nil {
        req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifUnmodifiedSince != nil {
        req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
    }
    if ifMatches != nil {
        req.Header.Set("If-Match", string(*ifMatches))
    }
    if ifNoneMatch != nil {
        req.Header.Set("If-None-Match", string(*ifNoneMatch))
    }
    req.Header.Set("x-ms-copy-source", copySource)
    if leaseID != nil {
        req.Header.Set("x-ms-lease-id", *leaseID)
    }
    if sourceLeaseID != nil {
        req.Header.Set("x-ms-source-lease-id", *sourceLeaseID)
    }
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    return req, nil
}

// startCopyFromURLResponder handles the response to the StartCopyFromURL request.
func (client blobClient) startCopyFromURLResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobStartCopyFromURLResponse{rawResponse: resp.Response()}, err
}

// Undelete undelete a blob that was previously soft deleted
//
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
// Timeouts for Blob Service Operations.</a> requestID is provides a client-generated, opaque value with a 1 KB
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
func (client blobClient) Undelete(ctx context.Context, timeout *int32, requestID *string) (*BlobUndeleteResponse, error) {
    if err := validate([]validation{
        {targetValue: timeout,
            constraints: []constraint{{target: "timeout", name: null, rule: false,
                chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
        return nil, err
    }
    req, err := client.undeletePreparer(timeout, requestID)
    if err != nil {
        return nil, err
    }
    resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.undeleteResponder}, req)
    if err != nil {
        return nil, err
    }
    return resp.(*BlobUndeleteResponse), err
}

// undeletePreparer prepares the Undelete request.
func (client blobClient) undeletePreparer(timeout *int32, requestID *string) (pipeline.Request, error) {
    req, err := pipeline.NewRequest("PUT", client.url, nil)
    if err != nil {
        return req, pipeline.NewError(err, "failed to create request")
    }
    params := req.URL.Query()
    if timeout != nil {
        params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
    }
    params.Set("comp", "undelete")
    req.URL.RawQuery = params.Encode()
    req.Header.Set("x-ms-version", ServiceVersion)
    if requestID != nil {
        req.Header.Set("x-ms-client-request-id", *requestID)
    }
    return req, nil
}

// undeleteResponder handles the response to the Undelete request.
func (client blobClient) undeleteResponder(resp pipeline.Response) (pipeline.Response, error) {
    err := validateResponse(resp, http.StatusOK)
    if resp == nil {
        return nil, err
    }
    io.Copy(ioutil.Discard, resp.Response().Body)
    resp.Response().Body.Close()
    return &BlobUndeleteResponse{rawResponse: resp.Response()}, err
}