func (s *Bucket) GetACLRequest() (*request.Request, *GetBucketACLOutput, error) {
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "GET Bucket ACL",
		RequestMethod: "GET",
		RequestURI:    "/<bucket-name>?acl",
		StatusCodes: []int{
			200,  
		},
	}
	x := &GetBucketACLOutput{}
	r, err := request.New(o, nil, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
GetACLRequest creates request and output object of GetBucketACL.
package service
import (
	"context"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"
	"github.com/qingstor/qingstor-sdk-go/v4/config"
	"github.com/qingstor/qingstor-sdk-go/v4/request"
	"github.com/qingstor/qingstor-sdk-go/v4/request/data"
	"github.com/qingstor/qingstor-sdk-go/v4/request/errors"
	"github.com/qingstor/qingstor-sdk-go/v4/utils"
)
var _ fmt.State
var _ io.Reader
var _ http.Header
var _ strings.Reader
var _ time.Time
var _ config.Config
var _ utils.Conn
type Bucket struct {
	Config     *config.Config
	Properties *Properties
}
func (s *Service) Bucket(bucketName string, zone string) (*Bucket, error) {
	zone = strings.ToLower(zone)
	properties := &Properties{
		BucketName: &bucketName,
		Zone:       &zone,
	}
	return &Bucket{Config: s.Config, Properties: properties}, nil
}
func (s *Bucket) Delete() (*DeleteBucketOutput, error) {
	return s.DeleteWithContext(context.Background())
}
func (s *Bucket) DeleteWithContext(ctx context.Context) (*DeleteBucketOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.DeleteRequest()
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}
func (s *Bucket) DeleteRequest() (*request.Request, *DeleteBucketOutput, error) {
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "DELETE Bucket",
		RequestMethod: "DELETE",
		RequestURI:    "/<bucket-name>",
		StatusCodes: []int{
			204,  
		},
	}
	x := &DeleteBucketOutput{}
	r, err := request.New(o, nil, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
type DeleteBucketOutput struct {
	StatusCode *int `location:"statusCode"`
	RequestID *string `location:"requestID"`
}
func (s *Bucket) DeleteCNAME(input *DeleteBucketCNAMEInput) (*DeleteBucketCNAMEOutput, error) {
	return s.DeleteCNAMEWithContext(context.Background(), input)
}
func (s *Bucket) DeleteCNAMEWithContext(ctx context.Context, input *DeleteBucketCNAMEInput) (*DeleteBucketCNAMEOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.DeleteCNAMERequest(input)
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}
func (s *Bucket) DeleteCNAMERequest(input *DeleteBucketCNAMEInput) (*request.Request, *DeleteBucketCNAMEOutput, error) {
	if input == nil {
		input = &DeleteBucketCNAMEInput{}
	}
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "DELETE Bucket CNAME",
		RequestMethod: "DELETE",
		RequestURI:    "/<bucket-name>?cname",
		StatusCodes: []int{
			204,  
		},
	}
	x := &DeleteBucketCNAMEOutput{}
	r, err := request.New(o, input, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
type DeleteBucketCNAMEInput struct {
	Domain *string `json:"domain" name:"domain" location:"elements"`  
}
func (v *DeleteBucketCNAMEInput) Validate() error {
	if v.Domain == nil {
		return errors.ParameterRequiredError{
			ParameterName: "Domain",
			ParentName:    "DeleteBucketCNAMEInput",
		}
	}
	return nil
}
type DeleteBucketCNAMEOutput struct {
	StatusCode *int `location:"statusCode"`
	RequestID *string `location:"requestID"`
}
func (s *Bucket) DeleteCORS() (*DeleteBucketCORSOutput, error) {
	return s.DeleteCORSWithContext(context.Background())
}
func (s *Bucket) DeleteCORSWithContext(ctx context.Context) (*DeleteBucketCORSOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.DeleteCORSRequest()
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}
func (s *Bucket) DeleteCORSRequest() (*request.Request, *DeleteBucketCORSOutput, error) {
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "DELETE Bucket CORS",
		RequestMethod: "DELETE",
		RequestURI:    "/<bucket-name>?cors",
		StatusCodes: []int{
			204,  
		},
	}
	x := &DeleteBucketCORSOutput{}
	r, err := request.New(o, nil, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
type DeleteBucketCORSOutput struct {
	StatusCode *int `location:"statusCode"`
	RequestID *string `location:"requestID"`
}
func (s *Bucket) DeleteExternalMirror() (*DeleteBucketExternalMirrorOutput, error) {
	return s.DeleteExternalMirrorWithContext(context.Background())
}
func (s *Bucket) DeleteExternalMirrorWithContext(ctx context.Context) (*DeleteBucketExternalMirrorOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.DeleteExternalMirrorRequest()
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}
func (s *Bucket) DeleteExternalMirrorRequest() (*request.Request, *DeleteBucketExternalMirrorOutput, error) {
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "DELETE Bucket External Mirror",
		RequestMethod: "DELETE",
		RequestURI:    "/<bucket-name>?mirror",
		StatusCodes: []int{
			204,  
		},
	}
	x := &DeleteBucketExternalMirrorOutput{}
	r, err := request.New(o, nil, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
type DeleteBucketExternalMirrorOutput struct {
	StatusCode *int `location:"statusCode"`
	RequestID *string `location:"requestID"`
}
func (s *Bucket) DeleteLifecycle() (*DeleteBucketLifecycleOutput, error) {
	return s.DeleteLifecycleWithContext(context.Background())
}
func (s *Bucket) DeleteLifecycleWithContext(ctx context.Context) (*DeleteBucketLifecycleOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.DeleteLifecycleRequest()
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}
func (s *Bucket) DeleteLifecycleRequest() (*request.Request, *DeleteBucketLifecycleOutput, error) {
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "DELETE Bucket Lifecycle",
		RequestMethod: "DELETE",
		RequestURI:    "/<bucket-name>?lifecycle",
		StatusCodes: []int{
			204,  
		},
	}
	x := &DeleteBucketLifecycleOutput{}
	r, err := request.New(o, nil, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
type DeleteBucketLifecycleOutput struct {
	StatusCode *int `location:"statusCode"`
	RequestID *string `location:"requestID"`
}
func (s *Bucket) DeleteLogging() (*DeleteBucketLoggingOutput, error) {
	return s.DeleteLoggingWithContext(context.Background())
}
func (s *Bucket) DeleteLoggingWithContext(ctx context.Context) (*DeleteBucketLoggingOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.DeleteLoggingRequest()
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}
func (s *Bucket) DeleteLoggingRequest() (*request.Request, *DeleteBucketLoggingOutput, error) {
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "DELETE Bucket Logging",
		RequestMethod: "DELETE",
		RequestURI:    "/<bucket-name>?logging",
		StatusCodes: []int{
			204,  
		},
	}
	x := &DeleteBucketLoggingOutput{}
	r, err := request.New(o, nil, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
type DeleteBucketLoggingOutput struct {
	StatusCode *int `location:"statusCode"`
	RequestID *string `location:"requestID"`
}
func (s *Bucket) DeleteNotification() (*DeleteBucketNotificationOutput, error) {
	return s.DeleteNotificationWithContext(context.Background())
}
func (s *Bucket) DeleteNotificationWithContext(ctx context.Context) (*DeleteBucketNotificationOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.DeleteNotificationRequest()
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}
func (s *Bucket) DeleteNotificationRequest() (*request.Request, *DeleteBucketNotificationOutput, error) {
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "DELETE Bucket Notification",
		RequestMethod: "DELETE",
		RequestURI:    "/<bucket-name>?notification",
		StatusCodes: []int{
			204,  
		},
	}
	x := &DeleteBucketNotificationOutput{}
	r, err := request.New(o, nil, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
type DeleteBucketNotificationOutput struct {
	StatusCode *int `location:"statusCode"`
	RequestID *string `location:"requestID"`
}
func (s *Bucket) DeletePolicy() (*DeleteBucketPolicyOutput, error) {
	return s.DeletePolicyWithContext(context.Background())
}
func (s *Bucket) DeletePolicyWithContext(ctx context.Context) (*DeleteBucketPolicyOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.DeletePolicyRequest()
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}
func (s *Bucket) DeletePolicyRequest() (*request.Request, *DeleteBucketPolicyOutput, error) {
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "DELETE Bucket Policy",
		RequestMethod: "DELETE",
		RequestURI:    "/<bucket-name>?policy",
		StatusCodes: []int{
			204,  
		},
	}
	x := &DeleteBucketPolicyOutput{}
	r, err := request.New(o, nil, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
type DeleteBucketPolicyOutput struct {
	StatusCode *int `location:"statusCode"`
	RequestID *string `location:"requestID"`
}
func (s *Bucket) DeleteReplication() (*DeleteBucketReplicationOutput, error) {
	return s.DeleteReplicationWithContext(context.Background())
}
func (s *Bucket) DeleteReplicationWithContext(ctx context.Context) (*DeleteBucketReplicationOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.DeleteReplicationRequest()
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}
func (s *Bucket) DeleteReplicationRequest() (*request.Request, *DeleteBucketReplicationOutput, error) {
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "DELETE Bucket Replication",
		RequestMethod: "DELETE",
		RequestURI:    "/<bucket-name>?replication",
		StatusCodes: []int{
			204,  
		},
	}
	x := &DeleteBucketReplicationOutput{}
	r, err := request.New(o, nil, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
type DeleteBucketReplicationOutput struct {
	StatusCode *int `location:"statusCode"`
	RequestID *string `location:"requestID"`
}
func (s *Bucket) DeleteMultipleObjects(input *DeleteMultipleObjectsInput) (*DeleteMultipleObjectsOutput, error) {
	return s.DeleteMultipleObjectsWithContext(context.Background(), input)
}
func (s *Bucket) DeleteMultipleObjectsWithContext(ctx context.Context, input *DeleteMultipleObjectsInput) (*DeleteMultipleObjectsOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.DeleteMultipleObjectsRequest(input)
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}
func (s *Bucket) DeleteMultipleObjectsRequest(input *DeleteMultipleObjectsInput) (*request.Request, *DeleteMultipleObjectsOutput, error) {
	if input == nil {
		input = &DeleteMultipleObjectsInput{}
	}
	properties := *s.Properties
	o := &data.Operation{
		Config:        s.Config,
		Properties:    &properties,
		APIName:       "Delete Multiple Objects",
		RequestMethod: "POST",
		RequestURI:    "/<bucket-name>?delete",
		StatusCodes: []int{
			200,  
		},
	}
	x := &DeleteMultipleObjectsOutput{}
	r, err := request.New(o, input, x)
	if err != nil {
		return nil, nil, err
	}
	return r, x, nil
}
type DeleteMultipleObjectsInput struct {
	Objects []*KeyType `json:"objects" name:"objects" location:"elements"`  
	Quiet *bool `json:"quiet,omitempty" name:"quiet" location:"elements"`
}
func (v *DeleteMultipleObjectsInput) Validate() error {
	if len(v.Objects) == 0 {
		return errors.ParameterRequiredError{
			ParameterName: "Objects",
			ParentName:    "DeleteMultipleObjectsInput",
		}
	}
	if len(v.Objects) > 0 {
		for _, property := range v.Objects {
			if err := property.Validate(); err != nil {
				return err
			}
		}
	}
	return nil
}
type DeleteMultipleObjectsOutput struct {
	StatusCode *int `location:"statusCode"`
	RequestID *string `location:"requestID"`
	Deleted []*KeyType `json:"deleted,omitempty" name:"deleted" location:"elements"`
	Errors []*KeyDeleteErrorType `json:"errors,omitempty" name:"errors" location:"elements"`
}
func (s *Bucket) GetACL() (*GetBucketACLOutput, error) {
	return s.GetACLWithContext(context.Background())
}
func (s *Bucket) GetACLWithContext(ctx context.Context) (*GetBucketACLOutput, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	r, x, err := s.GetACLRequest()
	if err != nil {
		return x, err
	}
	err = r.SendWithContext(ctx)
	if err != nil {
		return nil, err
	}
	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID
	return x, err
}