صفحهٔ اصلی گشت‌و‌گذار راهنما
ورود
TC
/
alanyeung-s3
mirrorاز https://gitlab.alanyeung.co/yeungalan/aws/
1
0
انشعاب 0

5 کامیت‌ها 3d7eaa7f58 ... d65e55b1e8

نویسنده SHA1 پیام تاریخ
  Alan Yeung d65e55b1e8 update sigv4 6 روز پیش
  Alan Yeung f2f3b93733 p 6 روز پیش
  Alan Yeung 9ed05327fa sigv4 6 روز پیش
  Alan Yeung 72c746804c added multipart 6 روز پیش
  Alan Yeung 4788c04cc6 fixed multipart upload 6 روز پیش
19فایلهای تغییر یافته به همراه12762 افزوده شده و 175 حذف شده
مشاهده تقسیم شده نمایش آمار تفاوت ها
  1. BIN
      aws/DSC01472 copy.jpg
  2. BIN
      aws/data/bolt.db
  3. 63 25
      aws/internal/handler/public_view.go
  4. 505 6
      aws/internal/handler/s3.go
  5. 0 25
      aws/internal/handler/utils.go
  6. 50 10
      aws/internal/kvdb/bolt.go
  7. 183 12
      aws/internal/kvdb/kvdb.go
  8. 4 0
      aws/internal/kvdb/types.go
  9. 79 0
      aws/internal/service/s3.go
  10. 278 0
      aws/internal/storage/multipart.go
  11. 65 2
      aws/internal/storage/user_aware.go
  12. 31 19
      aws/main.go
  13. 27 0
      aws/output.txt
  14. 425 0
      aws/pkg/checksum/checksum.go
  15. 96 0
      aws/pkg/s3/types.go
  16. 80 76
      aws/pkg/sigv4/sigv4.go
  17. 10872 0
      aws/s3.json
  18. 4 0
      aws/test.bat
  19. BIN
      aws/uploads/123456789012/my-test-bucket/DSC01472 copy.jpg

BIN
aws/DSC01472 copy.jpg
مشاهده فایل


BIN
aws/data/bolt.db
مشاهده فایل


+ 63 - 25
aws/internal/handler/public_view.go
مشاهده فایل 

@@ -16,11 +16,11 @@ import (
 
 // PublicViewHandler handles public viewing of S3 bucket contents
 
 type PublicViewHandler struct {
 
 	storage *storage.UserAwareStorage
 
-	db      *kvdb.BoltKVDB
 
+	db      kvdb.KVDB
 
 }
 
 
 // NewPublicViewHandler creates a new public view handler
 
-func NewPublicViewHandler(storage *storage.UserAwareStorage, db *kvdb.BoltKVDB) *PublicViewHandler {
 
+func NewPublicViewHandler(storage *storage.UserAwareStorage, db kvdb.KVDB) *PublicViewHandler {
 
 	return &PublicViewHandler{
 
 		storage: storage,
 
 		db:      db,
 
@@ -28,22 +28,28 @@ func NewPublicViewHandler(storage *storage.UserAwareStorage, db *kvdb.BoltKVDB)
 
 }
 
 
 // Handle processes public view requests
 
-// URL format: /s3/{accountID}/{bucketID}/{key...}
 
+// URL format: /{bucketName}/{key...}
 
 func (h *PublicViewHandler) Handle(w http.ResponseWriter, r *http.Request) {
 
-	// Parse path: /s3/{accountID}/{bucketID}/{key...}
 
-	path := strings.TrimPrefix(r.URL.Path, "/s3/")
 
-	parts := strings.SplitN(path, "/", 3)
 
-
 
-	if len(parts) < 2 {
 
-		http.Error(w, "Invalid path format. Expected: /s3/{accountID}/{bucketID}/{key}", http.StatusBadRequest)
 
+	// Parse path: /{bucketName}/{key...}
 
+	path := strings.TrimPrefix(r.URL.Path, "/")
 
+	if path == "" {
 
+		http.Error(w, "Invalid path format. Expected: /{bucketName}/{key}", http.StatusBadRequest)
 
 		return
 
 	}
 
 
-	accountID := parts[0]
 
-	bucketID := parts[1]
 
+	parts := strings.SplitN(path, "/", 2)
 
+	bucketName := parts[0]
 
 	key := ""
 
-	if len(parts) > 2 {
 
-		key = parts[2]
 
+	if len(parts) > 1 {
 
+		key = parts[1]
 
+	}
 
+
 
+	// Resolve bucket name to accountID and bucketID
 
+	accountID, bucketID, err := h.db.ResolveBucketName(bucketName)
 
+	if err != nil {
 
+		log.Printf("Failed to resolve bucket name %s: %v", bucketName, err)
 
+		http.Error(w, "Bucket not found", http.StatusNotFound)
 
+		return
 
 	}
 
 
 	// Check if bucket has public viewing enabled
 
@@ -66,7 +72,7 @@ func (h *PublicViewHandler) Handle(w http.ResponseWriter, r *http.Request) {
 
 	}
 
 
 	// Serve the file
 
-	h.handleFileDownload(w, r, accountID, bucketID, key)
 
+	h.handleFileDownload(w, r, accountID, bucketID, bucketName, key)
 
 }
 
 
 func (h *PublicViewHandler) handleBucketListing(w http.ResponseWriter, r *http.Request, accountID, bucketID string, config *kvdb.BucketConfig) {
 
@@ -79,14 +85,14 @@ func (h *PublicViewHandler) handleBucketListing(w http.ResponseWriter, r *http.R
 
 	}
 
 
 	// Generate HTML page
 
-	html := h.generateBucketListingHTML(accountID, bucketID, config.BucketName, objects)
 
+	htmlContent := h.generateBucketListingHTML(config.BucketName, objects)
 
 
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 
 	w.WriteHeader(http.StatusOK)
 
-	w.Write([]byte(html))
 
+	w.Write([]byte(htmlContent))
 
 }
 
 
-func (h *PublicViewHandler) handleFileDownload(w http.ResponseWriter, r *http.Request, accountID, bucketID, key string) {
 
+func (h *PublicViewHandler) handleFileDownload(w http.ResponseWriter, r *http.Request, accountID, bucketID, bucketName, key string) {
 
 	// Get the file
 
 	file, info, err := h.storage.GetObjectByBucketIDForUser(accountID, bucketID, key)
 
 	if err != nil {
 
@@ -120,7 +126,7 @@ func (h *PublicViewHandler) handleFileDownload(w http.ResponseWriter, r *http.Re
 
 	http.ServeContent(w, r, filepath.Base(key), info.LastModified, file.(io.ReadSeeker))
 
 }
 
 
-func (h *PublicViewHandler) generateBucketListingHTML(accountID, bucketID, bucketName string, objects []storage.ObjectInfo) string {
 
+func (h *PublicViewHandler) generateBucketListingHTML(bucketName string, objects []storage.ObjectInfo) string {
 
 	var sb strings.Builder
 
 
 	sb.WriteString(`<!DOCTYPE html>
 
@@ -294,15 +300,14 @@ func (h *PublicViewHandler) generateBucketListingHTML(accountID, bucketID, bucke
 
 			icon := getFileIcon(ext)
 
 
 			sb.WriteString(fmt.Sprintf(`
 
-            <a href="/s3/%s/%s/%s" class="file-item">
 
+            <a href="/%s/%s" class="file-item">
 
                 <div class="file-icon">%s</div>
 
                 <div class="file-info">
 
                     <div class="file-name">%s</div>
 
                     <div class="file-meta">%s • %s</div>
 
                 </div>
 
             </a>`,
 
-				accountID,
 
-				bucketID,
 
+				bucketName,
 
 				obj.Key,
 
 				icon,
 
 				html.EscapeString(obj.Key),
 
@@ -315,12 +320,9 @@ func (h *PublicViewHandler) generateBucketListingHTML(accountID, bucketID, bucke
 
 	sb.WriteString(`
 
         </div>
 
         <div class="footer">
 
-            <p>Powered by AWS S3 Mock Server | Bucket ID: `)
 
-	sb.WriteString(bucketID)
 
-	sb.WriteString(`</p>
 
+            <p>Powered by AWS S3 Mock Server</p>
 
         </div>
 
     </div>
 
-</body>
 
 </html>`)
 
 
 	return sb.String()
 
@@ -364,6 +366,42 @@ func getFileIcon(ext string) string {
 
 	}
 
 }
 
 
+func getContentType(filename string) string {
 
+	ext := strings.ToLower(filepath.Ext(filename))
 
+	switch ext {
 
+	case ".jpg", ".jpeg":
 
+		return "image/jpeg"
 
+	case ".png":
 
+		return "image/png"
 
+	case ".gif":
 
+		return "image/gif"
 
+	case ".webp":
 
+		return "image/webp"
 
+	case ".svg":
 
+		return "image/svg+xml"
 
+	case ".pdf":
 
+		return "application/pdf"
 
+	case ".json":
 
+		return "application/json"
 
+	case ".xml":
 
+		return "application/xml"
 
+	case ".txt":
 
+		return "text/plain"
 
+	case ".html":
 
+		return "text/html"
 
+	case ".css":
 
+		return "text/css"
 
+	case ".js":
 
+		return "application/javascript"
 
+	case ".mp4":
 
+		return "video/mp4"
 
+	case ".mp3":
 
+		return "audio/mpeg"
 
+	default:
 
+		return "application/octet-stream"
 
+	}
 
+}
 
+
 
 func isImage(ext string) bool {
 
 	switch ext {
 
 	case ".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".bmp":

+ 505 - 6
aws/internal/handler/s3.go
مشاهده فایل 

@@ -11,6 +11,7 @@ import (
 
 
 	"aws-sts-mock/internal/service"
 
 	"aws-sts-mock/internal/storage"
 
+	"aws-sts-mock/pkg/checksum"
 
 	"aws-sts-mock/pkg/s3"
 
 	"aws-sts-mock/pkg/sigv4"
 
 )
 
@@ -68,6 +69,20 @@ func (h *S3Handler) getUserFromContext(r *http.Request) (sigv4.AWSCredentials, e
 
 }
 
 
 func (h *S3Handler) handleBucketOperation(w http.ResponseWriter, r *http.Request, bucketName string) {
 
+	query := r.URL.Query()
 
+
 
+	// Check for list multipart uploads
 
+	if query.Has("uploads") && r.Method == "GET" {
 
+		h.handleListMultipartUploads(w, r, bucketName)
 
+		return
 
+	}
 
+
 
+	// Check for delete query parameter (for DeleteObjects)
 
+	if r.Method == "POST" && query.Get("delete") != "" {
 
+		h.handleDeleteObjects(w, r, bucketName)
 
+		return
 
+	}
 
+
 
 	switch r.Method {
 
 	case "PUT":
 
 		h.handleCreateBucket(w, r, bucketName)
 
@@ -83,6 +98,35 @@ func (h *S3Handler) handleBucketOperation(w http.ResponseWriter, r *http.Request
 
 }
 
 
 func (h *S3Handler) handleObjectOperation(w http.ResponseWriter, r *http.Request, bucketName, objectKey string) {
 
+	query := r.URL.Query()
 
+
 
+	// Check for multipart operations
 
+	if query.Has("uploads") && r.Method == "POST" {
 
+		h.handleCreateMultipartUpload(w, r, bucketName, objectKey)
 
+		return
 
+	}
 
+
 
+	uploadID := query.Get("uploadId")
 
+	if uploadID != "" {
 
+		if r.Method == "PUT" && query.Has("partNumber") {
 
+			h.handleUploadPart(w, r, bucketName, objectKey)
 
+			return
 
+		}
 
+		if r.Method == "POST" {
 
+			h.handleCompleteMultipartUpload(w, r, bucketName, objectKey)
 
+			return
 
+		}
 
+		if r.Method == "DELETE" {
 
+			h.handleAbortMultipartUpload(w, r, bucketName, objectKey)
 
+			return
 
+		}
 
+		if r.Method == "GET" {
 
+			h.handleListParts(w, r, bucketName, objectKey)
 
+			return
 
+		}
 
+	}
 
+
 
+	// Regular object operations
 
 	switch r.Method {
 
 	case "PUT":
 
 		h.handlePutObject(w, r, bucketName, objectKey)
 
@@ -279,7 +323,28 @@ func (h *S3Handler) handlePutObject(w http.ResponseWriter, r *http.Request, buck
 
 		return
 
 	}
 
 
-	err = h.service.PutObject(creds.AccountID, bucketName, objectKey, r.Body)
 
+	// Extract checksum headers
 
+	checksumHeaders := extractChecksumHeaders(r)
 
+	validator := checksum.NewValidator(checksumHeaders)
 
+
 
+	// Validate and store the object
 
+	result, data, err := validator.ValidateStream(r.Body)
 
+	if err != nil {
 
+		log.Printf("Failed to read object data %s/%s for user %s: %v", bucketName, objectKey, creds.AccountID, err)
 
+		h.writeError(w, "InternalError", "Failed to read object data", objectKey, http.StatusInternalServerError)
 
+		return
 
+	}
 
+
 
+	// Check if validation failed
 
+	if !result.Valid {
 
+		log.Printf("Checksum validation failed for %s/%s: %s", bucketName, objectKey, result.ErrorMessage)
 
+		h.writeError(w, "InvalidDigest", result.ErrorMessage, objectKey, http.StatusBadRequest)
 
+		return
 
+	}
 
+
 
+	// Store the object
 
+	reader := strings.NewReader(string(data))
 
+	err = h.service.PutObject(creds.AccountID, bucketName, objectKey, reader)
 
 	if err != nil {
 
 		if err == storage.ErrBucketNotFound {
 
 			h.writeError(w, "NoSuchBucket", "The specified bucket does not exist", bucketName, http.StatusNotFound)
 
@@ -290,9 +355,15 @@ func (h *S3Handler) handlePutObject(w http.ResponseWriter, r *http.Request, buck
 
 		return
 
 	}
 
 
-	log.Printf("Created object: %s/%s for user: %s", bucketName, objectKey, creds.AccountID)
 
+	log.Printf("Created object: %s/%s for user: %s (validated with %s)",
 
+		bucketName, objectKey, creds.AccountID, result.ValidatedWith)
 
+
 
+	// Set response headers including checksums
 
+	responseHeaders := result.GetResponseHeaders()
 
+	for key, value := range responseHeaders {
 
+		w.Header().Set(key, value)
 
+	}
 
 
-	w.Header().Set("ETag", fmt.Sprintf("\"%d\"", time.Now().Unix()))
 
 	w.Header().Set("x-amz-request-id", generateRequestId())
 
 	w.WriteHeader(http.StatusOK)
 
 }
 
@@ -316,16 +387,35 @@ func (h *S3Handler) handleGetObject(w http.ResponseWriter, r *http.Request, buck
 
 	}
 
 	defer file.Close()
 
 
+	// Read file data to compute checksums
 
+	data, err := io.ReadAll(file)
 
+	if err != nil {
 
+		log.Printf("Failed to read object data %s/%s: %v", bucketName, objectKey, err)
 
+		h.writeError(w, "InternalError", "Failed to read object data", objectKey, http.StatusInternalServerError)
 
+		return
 
+	}
 
+
 
+	// Compute checksums for the response
 
+	validator := checksum.NewValidator(map[string]string{})
 
+	result := validator.ComputeChecksums(data)
 
+
 
 	log.Printf("Retrieved object: %s/%s for user: %s", bucketName, objectKey, creds.AccountID)
 
 
+	// Set standard headers
 
 	w.Header().Set("Content-Type", getContentType(objectKey))
 
 	w.Header().Set("Content-Length", fmt.Sprintf("%d", info.Size))
 
 	w.Header().Set("Last-Modified", info.LastModified.UTC().Format(http.TimeFormat))
 
-	w.Header().Set("ETag", fmt.Sprintf("\"%s\"", info.ETag))
 
 	w.Header().Set("x-amz-request-id", generateRequestId())
 
-	w.WriteHeader(http.StatusOK)
 
 
-	io.Copy(w, file)
 
+	// Set checksum headers
 
+	w.Header().Set("ETag", fmt.Sprintf(`"%s"`, result.MD5))
 
+	w.Header().Set("x-amz-checksum-crc32", result.CRC32)
 
+	w.Header().Set("x-amz-checksum-crc32c", result.CRC32C)
 
+	w.Header().Set("x-amz-checksum-sha1", result.SHA1)
 
+	w.Header().Set("x-amz-checksum-sha256", result.SHA256)
 
+
 
+	w.WriteHeader(http.StatusOK)
 
+	w.Write(data)
 
 }
 
 
 func (h *S3Handler) handleDeleteObject(w http.ResponseWriter, r *http.Request, bucketName, objectKey string) {
 
@@ -502,3 +592,412 @@ func (h *S3Handler) handleDeleteObjects(w http.ResponseWriter, r *http.Request,
 
 		log.Printf("Error encoding delete objects response: %v", err)
 
 	}
 
 }
 
+
 
+// Add these methods to S3Handler
 
+
 
+func (h *S3Handler) handleCreateMultipartUpload(w http.ResponseWriter, r *http.Request, bucketName, objectKey string) {
 
+	creds, err := h.getUserFromContext(r)
 
+	if err != nil {
 
+		h.writeError(w, "AccessDenied", "Failed to retrieve credentials", "", http.StatusForbidden)
 
+		return
 
+	}
 
+
 
+	uploadID, err := h.service.CreateMultipartUpload(creds.AccountID, bucketName, objectKey)
 
+	if err != nil {
 
+		if err == storage.ErrBucketNotFound {
 
+			h.writeError(w, "NoSuchBucket", "The specified bucket does not exist", bucketName, http.StatusNotFound)
 
+			return
 
+		}
 
+		log.Printf("Failed to create multipart upload for %s/%s: %v", bucketName, objectKey, err)
 
+		h.writeError(w, "InternalError", "Failed to initiate multipart upload", objectKey, http.StatusInternalServerError)
 
+		return
 
+	}
 
+
 
+	log.Printf("Created multipart upload: %s for %s/%s, user: %s", uploadID, bucketName, objectKey, creds.AccountID)
 
+
 
+	result := s3.InitiateMultipartUploadResult{
 
+		XMLName:  xml.Name{Space: "http://s3.amazonaws.com/doc/2006-03-01/", Local: "InitiateMultipartUploadResult"},
 
+		Bucket:   bucketName,
 
+		Key:      objectKey,
 
+		UploadId: uploadID,
 
+	}
 
+
 
+	w.Header().Set("Content-Type", "application/xml")
 
+	w.Header().Set("x-amz-request-id", generateRequestId())
 
+	w.WriteHeader(http.StatusOK)
 
+
 
+	encoder := xml.NewEncoder(w)
 
+	encoder.Indent("", "  ")
 
+	if err := encoder.Encode(result); err != nil {
 
+		log.Printf("Error encoding response: %v", err)
 
+	}
 
+}
 
+
 
+func (h *S3Handler) handleUploadPart(w http.ResponseWriter, r *http.Request, bucketName, objectKey string) {
 
+	creds, err := h.getUserFromContext(r)
 
+	if err != nil {
 
+		h.writeError(w, "AccessDenied", "Failed to retrieve credentials", "", http.StatusForbidden)
 
+		return
 
+	}
 
+
 
+	// Get query parameters
 
+	uploadID := r.URL.Query().Get("uploadId")
 
+	partNumberStr := r.URL.Query().Get("partNumber")
 
+
 
+	if uploadID == "" || partNumberStr == "" {
 
+		h.writeError(w, "InvalidRequest", "Missing uploadId or partNumber", "", http.StatusBadRequest)
 
+		return
 
+	}
 
+
 
+	partNumber := 0
 
+	fmt.Sscanf(partNumberStr, "%d", &partNumber)
 
+
 
+	// Verify upload belongs to user
 
+	upload, err := h.service.GetMultipartUpload(uploadID)
 
+	if err != nil {
 
+		h.writeError(w, "NoSuchUpload", "The specified upload does not exist", uploadID, http.StatusNotFound)
 
+		return
 
+	}
 
+
 
+	if upload.AccountID != creds.AccountID || upload.Bucket != bucketName || upload.Key != objectKey {
 
+		h.writeError(w, "AccessDenied", "Access denied to this upload", uploadID, http.StatusForbidden)
 
+		return
 
+	}
 
+
 
+	// Extract checksum headers and validate
 
+	checksumHeaders := extractChecksumHeaders(r)
 
+	validator := checksum.NewValidator(checksumHeaders)
 
+
 
+	// Validate the part data
 
+	result, data, err := validator.ValidateStream(r.Body)
 
+	if err != nil {
 
+		log.Printf("Failed to read part data for upload %s: %v", uploadID, err)
 
+		h.writeError(w, "InternalError", "Failed to read part data", "", http.StatusInternalServerError)
 
+		return
 
+	}
 
+
 
+	// Check if validation failed
 
+	if !result.Valid {
 
+		log.Printf("Checksum validation failed for part %d of upload %s: %s",
 
+			partNumber, uploadID, result.ErrorMessage)
 
+		h.writeError(w, "InvalidDigest", result.ErrorMessage, "", http.StatusBadRequest)
 
+		return
 
+	}
 
+
 
+	// Upload the part
 
+	reader := strings.NewReader(string(data))
 
+	etag, err := h.service.UploadPart(uploadID, partNumber, reader)
 
+	if err != nil {
 
+		log.Printf("Failed to upload part %d for upload %s: %v", partNumber, uploadID, err)
 
+		h.writeError(w, "InternalError", "Failed to upload part", "", http.StatusInternalServerError)
 
+		return
 
+	}
 
+
 
+	log.Printf("Uploaded part %d for upload %s, user: %s (validated with %s)",
 
+		partNumber, uploadID, creds.AccountID, result.ValidatedWith)
 
+
 
+	// Set response headers including checksums
 
+	w.Header().Set("ETag", etag)
 
+	responseHeaders := result.GetResponseHeaders()
 
+	for key, value := range responseHeaders {
 
+		if key != "ETag" { // Don't override the ETag
 
+			w.Header().Set(key, value)
 
+		}
 
+	}
 
+
 
+	w.Header().Set("x-amz-request-id", generateRequestId())
 
+	w.WriteHeader(http.StatusOK)
 
+}
 
+
 
+func (h *S3Handler) handleCompleteMultipartUpload(w http.ResponseWriter, r *http.Request, bucketName, objectKey string) {
 
+	creds, err := h.getUserFromContext(r)
 
+	if err != nil {
 
+		h.writeError(w, "AccessDenied", "Failed to retrieve credentials", "", http.StatusForbidden)
 
+		return
 
+	}
 
+
 
+	uploadID := r.URL.Query().Get("uploadId")
 
+	if uploadID == "" {
 
+		h.writeError(w, "InvalidRequest", "Missing uploadId", "", http.StatusBadRequest)
 
+		return
 
+	}
 
+
 
+	// Verify upload belongs to user
 
+	upload, err := h.service.GetMultipartUpload(uploadID)
 
+	if err != nil {
 
+		h.writeError(w, "NoSuchUpload", "The specified upload does not exist", uploadID, http.StatusNotFound)
 
+		return
 
+	}
 
+
 
+	if upload.AccountID != creds.AccountID || upload.Bucket != bucketName || upload.Key != objectKey {
 
+		h.writeError(w, "AccessDenied", "Access denied to this upload", uploadID, http.StatusForbidden)
 
+		return
 
+	}
 
+
 
+	// Parse request
 
+	var req s3.CompleteMultipartUploadRequest
 
+	if err := xml.NewDecoder(r.Body).Decode(&req); err != nil {
 
+		log.Printf("Error decoding complete multipart upload request: %v", err)
 
+		h.writeError(w, "MalformedXML", "The XML you provided was not well-formed", "", http.StatusBadRequest)
 
+		return
 
+	}
 
+
 
+	// Extract part numbers
 
+	parts := make([]int, len(req.Parts))
 
+	for i, part := range req.Parts {
 
+		parts[i] = part.PartNumber
 
+	}
 
+
 
+	// Complete the upload
 
+	if err := h.service.CompleteMultipartUpload(uploadID, parts); err != nil {
 
+		log.Printf("Failed to complete multipart upload %s: %v", uploadID, err)
 
+		h.writeError(w, "InternalError", "Failed to complete multipart upload", "", http.StatusInternalServerError)
 
+		return
 
+	}
 
+
 
+	log.Printf("Completed multipart upload: %s for %s/%s, user: %s", uploadID, bucketName, objectKey, creds.AccountID)
 
+
 
+	result := s3.CompleteMultipartUploadResult{
 
+		XMLName:  xml.Name{Space: "http://s3.amazonaws.com/doc/2006-03-01/", Local: "CompleteMultipartUploadResult"},
 
+		Location: fmt.Sprintf("/%s/%s", bucketName, objectKey),
 
+		Bucket:   bucketName,
 
+		Key:      objectKey,
 
+		ETag:     fmt.Sprintf("\"%d\"", time.Now().Unix()),
 
+	}
 
+
 
+	w.Header().Set("Content-Type", "application/xml")
 
+	w.Header().Set("x-amz-request-id", generateRequestId())
 
+	w.WriteHeader(http.StatusOK)
 
+
 
+	encoder := xml.NewEncoder(w)
 
+	encoder.Indent("", "  ")
 
+	if err := encoder.Encode(result); err != nil {
 
+		log.Printf("Error encoding response: %v", err)
 
+	}
 
+}
 
+
 
+func (h *S3Handler) handleAbortMultipartUpload(w http.ResponseWriter, r *http.Request, bucketName, objectKey string) {
 
+	creds, err := h.getUserFromContext(r)
 
+	if err != nil {
 
+		h.writeError(w, "AccessDenied", "Failed to retrieve credentials", "", http.StatusForbidden)
 
+		return
 
+	}
 
+
 
+	uploadID := r.URL.Query().Get("uploadId")
 
+	if uploadID == "" {
 
+		h.writeError(w, "InvalidRequest", "Missing uploadId", "", http.StatusBadRequest)
 
+		return
 
+	}
 
+
 
+	// Verify upload belongs to user
 
+	upload, err := h.service.GetMultipartUpload(uploadID)
 
+	if err != nil {
 
+		h.writeError(w, "NoSuchUpload", "The specified upload does not exist", uploadID, http.StatusNotFound)
 
+		return
 
+	}
 
+
 
+	if upload.AccountID != creds.AccountID || upload.Bucket != bucketName || upload.Key != objectKey {
 
+		h.writeError(w, "AccessDenied", "Access denied to this upload", uploadID, http.StatusForbidden)
 
+		return
 
+	}
 
+
 
+	// Abort the upload
 
+	if err := h.service.AbortMultipartUpload(uploadID); err != nil {
 
+		log.Printf("Failed to abort multipart upload %s: %v", uploadID, err)
 
+		h.writeError(w, "InternalError", "Failed to abort multipart upload", "", http.StatusInternalServerError)
 
+		return
 
+	}
 
+
 
+	log.Printf("Aborted multipart upload: %s for %s/%s, user: %s", uploadID, bucketName, objectKey, creds.AccountID)
 
+
 
+	w.Header().Set("x-amz-request-id", generateRequestId())
 
+	w.WriteHeader(http.StatusNoContent)
 
+}
 
+
 
+func (h *S3Handler) handleListParts(w http.ResponseWriter, r *http.Request, bucketName, objectKey string) {
 
+	creds, err := h.getUserFromContext(r)
 
+	if err != nil {
 
+		h.writeError(w, "AccessDenied", "Failed to retrieve credentials", "", http.StatusForbidden)
 
+		return
 
+	}
 
+
 
+	uploadID := r.URL.Query().Get("uploadId")
 
+	if uploadID == "" {
 
+		h.writeError(w, "InvalidRequest", "Missing uploadId", "", http.StatusBadRequest)
 
+		return
 
+	}
 
+
 
+	// Verify upload belongs to user
 
+	upload, err := h.service.GetMultipartUpload(uploadID)
 
+	if err != nil {
 
+		h.writeError(w, "NoSuchUpload", "The specified upload does not exist", uploadID, http.StatusNotFound)
 
+		return
 
+	}
 
+
 
+	if upload.AccountID != creds.AccountID || upload.Bucket != bucketName || upload.Key != objectKey {
 
+		h.writeError(w, "AccessDenied", "Access denied to this upload", uploadID, http.StatusForbidden)
 
+		return
 
+	}
 
+
 
+	// Parse query parameters
 
+	maxParts := 1000
 
+	partNumberMarker := 0
 
+	if maxPartsStr := r.URL.Query().Get("max-parts"); maxPartsStr != "" {
 
+		fmt.Sscanf(maxPartsStr, "%d", &maxParts)
 
+	}
 
+	if markerStr := r.URL.Query().Get("part-number-marker"); markerStr != "" {
 
+		fmt.Sscanf(markerStr, "%d", &partNumberMarker)
 
+	}
 
+
 
+	// List parts
 
+	parts, nextMarker, isTruncated, err := h.service.ListParts(uploadID, maxParts, partNumberMarker)
 
+	if err != nil {
 
+		log.Printf("Failed to list parts for upload %s: %v", uploadID, err)
 
+		h.writeError(w, "InternalError", "Failed to list parts", "", http.StatusInternalServerError)
 
+		return
 
+	}
 
+
 
+	// Build response
 
+	s3Parts := make([]s3.Part, len(parts))
 
+	for i, part := range parts {
 
+		s3Parts[i] = s3.Part{
 
+			PartNumber:   part.PartNumber,
 
+			LastModified: part.LastModified.UTC().Format(time.RFC3339),
 
+			ETag:         part.ETag,
 
+			Size:         part.Size,
 
+		}
 
+	}
 
+
 
+	result := s3.ListPartsResult{
 
+		XMLName:              xml.Name{Space: "http://s3.amazonaws.com/doc/2006-03-01/", Local: "ListPartsResult"},
 
+		Bucket:               bucketName,
 
+		Key:                  objectKey,
 
+		UploadId:             uploadID,
 
+		Initiator:            s3.Initiator{ID: creds.AccountID, DisplayName: creds.AccessKeyID},
 
+		Owner:                s3.Owner{ID: creds.AccountID, DisplayName: creds.AccessKeyID},
 
+		StorageClass:         "STANDARD",
 
+		PartNumberMarker:     partNumberMarker,
 
+		NextPartNumberMarker: nextMarker,
 
+		MaxParts:             maxParts,
 
+		IsTruncated:          isTruncated,
 
+		Parts:                s3Parts,
 
+	}
 
+
 
+	w.Header().Set("Content-Type", "application/xml")
 
+	w.Header().Set("x-amz-request-id", generateRequestId())
 
+	w.WriteHeader(http.StatusOK)
 
+
 
+	encoder := xml.NewEncoder(w)
 
+	encoder.Indent("", "  ")
 
+	if err := encoder.Encode(result); err != nil {
 
+		log.Printf("Error encoding response: %v", err)
 
+	}
 
+}
 
+
 
+func (h *S3Handler) handleListMultipartUploads(w http.ResponseWriter, r *http.Request, bucketName string) {
 
+	creds, err := h.getUserFromContext(r)
 
+	if err != nil {
 
+		h.writeError(w, "AccessDenied", "Failed to retrieve credentials", "", http.StatusForbidden)
 
+		return
 
+	}
 
+
 
+	// Parse query parameters
 
+	maxUploads := 1000
 
+	keyMarker := r.URL.Query().Get("key-marker")
 
+	uploadIDMarker := r.URL.Query().Get("upload-id-marker")
 
+	prefix := r.URL.Query().Get("prefix")
 
+
 
+	if maxUploadsStr := r.URL.Query().Get("max-uploads"); maxUploadsStr != "" {
 
+		fmt.Sscanf(maxUploadsStr, "%d", &maxUploads)
 
+	}
 
+
 
+	// List uploads
 
+	uploads, nextKeyMarker, nextUploadIDMarker, isTruncated, err := h.service.ListMultipartUploads(
 
+		creds.AccountID, bucketName, maxUploads, keyMarker, uploadIDMarker,
 
+	)
 
+	if err != nil {
 
+		if err == storage.ErrBucketNotFound {
 
+			h.writeError(w, "NoSuchBucket", "The specified bucket does not exist", bucketName, http.StatusNotFound)
 
+			return
 
+		}
 
+		log.Printf("Failed to list multipart uploads for bucket %s: %v", bucketName, err)
 
+		h.writeError(w, "InternalError", "Failed to list uploads", "", http.StatusInternalServerError)
 
+		return
 
+	}
 
+
 
+	// Filter by prefix if provided
 
+	if prefix != "" {
 
+		filtered := []storage.MultipartUploadInfo{}
 
+		for _, upload := range uploads {
 
+			if len(upload.Key) >= len(prefix) && upload.Key[:len(prefix)] == prefix {
 
+				filtered = append(filtered, upload)
 
+			}
 
+		}
 
+		uploads = filtered
 
+	}
 
+
 
+	// Build response
 
+	s3Uploads := make([]s3.MultipartUpload, len(uploads))
 
+	for i, upload := range uploads {
 
+		s3Uploads[i] = s3.MultipartUpload{
 
+			Key:          upload.Key,
 
+			UploadId:     upload.UploadID,
 
+			Initiator:    s3.Initiator{ID: creds.AccountID, DisplayName: creds.AccessKeyID},
 
+			Owner:        s3.Owner{ID: creds.AccountID, DisplayName: creds.AccessKeyID},
 
+			StorageClass: "STANDARD",
 
+			Initiated:    upload.Initiated.UTC().Format(time.RFC3339),
 
+		}
 
+	}
 
+
 
+	result := s3.ListMultipartUploadsResult{
 
+		XMLName:            xml.Name{Space: "http://s3.amazonaws.com/doc/2006-03-01/", Local: "ListMultipartUploadsResult"},
 
+		Bucket:             bucketName,
 
+		KeyMarker:          keyMarker,
 
+		UploadIdMarker:     uploadIDMarker,
 
+		NextKeyMarker:      nextKeyMarker,
 
+		NextUploadIdMarker: nextUploadIDMarker,
 
+		MaxUploads:         maxUploads,
 
+		IsTruncated:        isTruncated,
 
+		Uploads:            s3Uploads,
 
+		Prefix:             prefix,
 
+	}
 
+
 
+	w.Header().Set("Content-Type", "application/xml")
 
+	w.Header().Set("x-amz-request-id", generateRequestId())
 
+	w.WriteHeader(http.StatusOK)
 
+
 
+	encoder := xml.NewEncoder(w)
 
+	encoder.Indent("", "  ")
 
+	if err := encoder.Encode(result); err != nil {
 
+		log.Printf("Error encoding response: %v", err)
 
+	}
 
+}
 
+
 
+func extractChecksumHeaders(r *http.Request) map[string]string {
 
+	headers := make(map[string]string)
 
+
 
+	// Extract all checksum-related headers
 
+	if val := r.Header.Get("Content-MD5"); val != "" {
 
+		headers["Content-MD5"] = val
 
+	}
 
+	if val := r.Header.Get("x-amz-sdk-checksum-algorithm"); val != "" {
 
+		headers["x-amz-sdk-checksum-algorithm"] = val
 
+	}
 
+	if val := r.Header.Get("x-amz-checksum-crc32"); val != "" {
 
+		headers["x-amz-checksum-crc32"] = val
 
+	}
 
+	if val := r.Header.Get("x-amz-checksum-crc32c"); val != "" {
 
+		headers["x-amz-checksum-crc32c"] = val
 
+	}
 
+	if val := r.Header.Get("x-amz-checksum-crc64nvme"); val != "" {
 
+		headers["x-amz-checksum-crc64nvme"] = val
 
+	}
 
+	if val := r.Header.Get("x-amz-checksum-sha1"); val != "" {
 
+		headers["x-amz-checksum-sha1"] = val
 
+	}
 
+	if val := r.Header.Get("x-amz-checksum-sha256"); val != "" {
 
+		headers["x-amz-checksum-sha256"] = val
 
+	}
 
+
 
+	return headers
 
+}

+ 0 - 25
aws/internal/handler/utils.go
مشاهده فایل 

@@ -2,8 +2,6 @@ package handler
 
 
 import (
 
 	"fmt"
 
-	"path/filepath"
 
-	"strings"
 
 	"time"
 
 )
 
 
@@ -11,26 +9,3 @@ import (
 
 func generateRequestId() string {
 
 	return fmt.Sprintf("%d-%d", time.Now().Unix(), time.Now().Nanosecond())
 
 }
 
-
 
-// getContentType returns the MIME type for a file based on its extension
 
-func getContentType(filename string) string {
 
-	ext := strings.ToLower(filepath.Ext(filename))
 
-	switch ext {
 
-	case ".txt":
 
-		return "text/plain"
 
-	case ".html", ".htm":
 
-		return "text/html"
 
-	case ".json":
 
-		return "application/json"
 
-	case ".xml":
 
-		return "application/xml"
 
-	case ".jpg", ".jpeg":
 
-		return "image/jpeg"
 
-	case ".png":
 
-		return "image/png"
 
-	case ".pdf":
 
-		return "application/pdf"
 
-	default:
 
-		return "application/octet-stream"
 
-	}
 
-}

+ 50 - 10
aws/internal/kvdb/bolt.go
مشاهده فایل 

@@ -3,14 +3,15 @@ package kvdb
 
 import (
 
 	"encoding/json"
 
 	"errors"
 
+	"fmt"
 
 	"time"
 
 
 	"go.etcd.io/bbolt"
 
 )
 
 
 var (
 
-	usersBucket        = []byte("users")
 
-	bucketConfigBucket = []byte("bucket_configs")
 
+	usersBucket   = []byte("users")
 
+	bucketsBucket = []byte("buckets")
 
 )
 
 
 // Ensure BoltKVDB implements KVDB interface
 
@@ -43,7 +44,7 @@ func NewBoltKVDB(path string) (*BoltKVDB, error) {
 
 		if err != nil {
 
 			return err
 
 		}
 
-		_, err = tx.CreateBucketIfNotExists(bucketConfigBucket)
 
+		_, err = tx.CreateBucketIfNotExists(bucketsBucket)
 
 		return err
 
 	})
 
 	if err != nil {
 
@@ -164,7 +165,7 @@ func (db *BoltKVDB) Close() error {
 
 // SetBucketConfig sets the configuration for a bucket
 
 func (db *BoltKVDB) SetBucketConfig(config *BucketConfig) error {
 
 	return db.db.Update(func(tx *bbolt.Tx) error {
 
-		b := tx.Bucket(bucketConfigBucket)
 
+		b := tx.Bucket(bucketsBucket)
 
 
 		// Key format: accountID:bucketID
 
 		key := config.AccountID + ":" + config.BucketID
 
@@ -181,27 +182,33 @@ func (db *BoltKVDB) SetBucketConfig(config *BucketConfig) error {
 
 // GetBucketConfig gets the configuration for a bucket
 
 func (db *BoltKVDB) GetBucketConfig(accountID, bucketID string) (*BucketConfig, error) {
 
 	var config BucketConfig
 
+
 
 	err := db.db.View(func(tx *bbolt.Tx) error {
 
-		b := tx.Bucket(bucketConfigBucket)
 
+		bucket := tx.Bucket(bucketsBucket)
 
+		if bucket == nil {
 
+			return fmt.Errorf("buckets bucket not found")
 
+		}
 
 
-		key := accountID + ":" + bucketID
 
-		data := b.Get([]byte(key))
 
+		key := fmt.Sprintf("%s:%s", accountID, bucketID)
 
+		data := bucket.Get([]byte(key))
 
 		if data == nil {
 
-			return errors.New("bucket config not found")
 
+			return fmt.Errorf("bucket config not found")
 
 		}
 
 
 		return json.Unmarshal(data, &config)
 
 	})
 
+
 
 	if err != nil {
 
 		return nil, err
 
 	}
 
+
 
 	return &config, nil
 
 }
 
 
 // DeleteBucketConfig deletes the configuration for a bucket
 
 func (db *BoltKVDB) DeleteBucketConfig(accountID, bucketID string) error {
 
 	return db.db.Update(func(tx *bbolt.Tx) error {
 
-		b := tx.Bucket(bucketConfigBucket)
 
+		b := tx.Bucket(bucketsBucket)
 
 		key := accountID + ":" + bucketID
 
 		return b.Delete([]byte(key))
 
 	})
 
@@ -213,7 +220,7 @@ func (db *BoltKVDB) ListBucketConfigs(accountID string) ([]*BucketConfig, error)
 
 	prefix := []byte(accountID + ":")
 
 
 	err := db.db.View(func(tx *bbolt.Tx) error {
 
-		b := tx.Bucket(bucketConfigBucket)
 
+		b := tx.Bucket(bucketsBucket)
 
 		c := b.Cursor()
 
 
 		for k, v := c.Seek(prefix); k != nil && len(k) >= len(prefix) && string(k[:len(prefix)]) == string(prefix); k, v = c.Next() {
 
@@ -229,6 +236,39 @@ func (db *BoltKVDB) ListBucketConfigs(accountID string) ([]*BucketConfig, error)
 
 	return configs, err
 
 }
 
 
+// ResolveBucketName resolves a bucket name to accountID and bucketID
 
+func (db *BoltKVDB) ResolveBucketName(bucketName string) (accountID string, bucketID string, err error) {
 
+	err = db.db.View(func(tx *bbolt.Tx) error {
 
+		bucket := tx.Bucket(bucketsBucket)
 
+		if bucket == nil {
 
+			return fmt.Errorf("buckets bucket not found")
 
+		}
 
+
 
+		// Iterate through all bucket configs to find matching bucket name
 
+		cursor := bucket.Cursor()
 
+		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
 
+			var config BucketConfig
 
+			if err := json.Unmarshal(v, &config); err != nil {
 
+				continue
 
+			}
 
+
 
+			if config.BucketName == bucketName {
 
+				accountID = config.AccountID
 
+				bucketID = config.BucketID
 
+				return nil
 
+			}
 
+		}
 
+
 
+		return fmt.Errorf("bucket not found: %s", bucketName)
 
+	})
 
+
 
+	if err != nil {
 
+		return "", "", err
 
+	}
 
+
 
+	return accountID, bucketID, nil
 
+}
 
+
 
 // InitializeDefaultUsers initializes hardcoded users
 
 func (db *BoltKVDB) InitializeDefaultUsers() error {
 
 	defaultUsers := []*User{

+ 183 - 12
aws/internal/kvdb/kvdb.go
مشاهده فایل 

@@ -3,6 +3,7 @@ package kvdb
 
 import (
 
 	"encoding/json"
 
 	"errors"
 
+	"fmt"
 
 	"os"
 
 	"path/filepath"
 
 	"sync"
 
@@ -10,14 +11,16 @@ import (
 
 
 // InMemoryKVDB is a simple in-memory key-value database
 
 type InMemoryKVDB struct {
 
-	users map[string]*User // key: AccessKeyID
 
-	mu    sync.RWMutex
 
+	users         map[string]*User         // key: AccessKeyID
 
+	bucketConfigs map[string]*BucketConfig // key: accountID:bucketID
 
+	mu            sync.RWMutex
 
 }
 
 
 // NewInMemoryKVDB creates a new in-memory key-value database
 
 func NewInMemoryKVDB() *InMemoryKVDB {
 
 	return &InMemoryKVDB{
 
-		users: make(map[string]*User),
 
+		users:         make(map[string]*User),
 
+		bucketConfigs: make(map[string]*BucketConfig),
 
 	}
 
 }
 
 
@@ -106,6 +109,78 @@ func (db *InMemoryKVDB) ValidateCredentials(accessKeyID, secretAccessKey string)
 
 	return user, nil
 
 }
 
 
+// SetBucketConfig sets the configuration for a bucket
 
+func (db *InMemoryKVDB) SetBucketConfig(config *BucketConfig) error {
 
+	db.mu.Lock()
 
+	defer db.mu.Unlock()
 
+
 
+	key := config.AccountID + ":" + config.BucketID
 
+	configCopy := *config
 
+	db.bucketConfigs[key] = &configCopy
 
+	return nil
 
+}
 
+
 
+// GetBucketConfig gets the configuration for a bucket
 
+func (db *InMemoryKVDB) GetBucketConfig(accountID, bucketID string) (*BucketConfig, error) {
 
+	db.mu.RLock()
 
+	defer db.mu.RUnlock()
 
+
 
+	key := accountID + ":" + bucketID
 
+	config, exists := db.bucketConfigs[key]
 
+	if !exists {
 
+		return nil, fmt.Errorf("bucket config not found")
 
+	}
 
+
 
+	configCopy := *config
 
+	return &configCopy, nil
 
+}
 
+
 
+// DeleteBucketConfig deletes the configuration for a bucket
 
+func (db *InMemoryKVDB) DeleteBucketConfig(accountID, bucketID string) error {
 
+	db.mu.Lock()
 
+	defer db.mu.Unlock()
 
+
 
+	key := accountID + ":" + bucketID
 
+	if _, exists := db.bucketConfigs[key]; !exists {
 
+		return fmt.Errorf("bucket config not found")
 
+	}
 
+
 
+	delete(db.bucketConfigs, key)
 
+	return nil
 
+}
 
+
 
+// ListBucketConfigs lists all bucket configurations for an account
 
+func (db *InMemoryKVDB) ListBucketConfigs(accountID string) ([]*BucketConfig, error) {
 
+	db.mu.RLock()
 
+	defer db.mu.RUnlock()
 
+
 
+	var configs []*BucketConfig
 
+	prefix := accountID + ":"
 
+
 
+	for key, config := range db.bucketConfigs {
 
+		if len(key) >= len(prefix) && key[:len(prefix)] == prefix {
 
+			configCopy := *config
 
+			configs = append(configs, &configCopy)
 
+		}
 
+	}
 
+
 
+	return configs, nil
 
+}
 
+
 
+// ResolveBucketName resolves a bucket name to accountID and bucketID
 
+func (db *InMemoryKVDB) ResolveBucketName(bucketName string) (string, string, error) {
 
+	db.mu.RLock()
 
+	defer db.mu.RUnlock()
 
+
 
+	for _, config := range db.bucketConfigs {
 
+		if config.BucketName == bucketName {
 
+			return config.AccountID, config.BucketID, nil
 
+		}
 
+	}
 
+
 
+	return "", "", fmt.Errorf("bucket not found: %s", bucketName)
 
+}
 
+
 
 // Close closes the database (no-op for in-memory)
 
 func (db *InMemoryKVDB) Close() error {
 
 	return nil
 
@@ -113,16 +188,18 @@ func (db *InMemoryKVDB) Close() error {
 
 
 // FileBasedKVDB is a file-based key-value database with persistence
 
 type FileBasedKVDB struct {
 
-	filePath string
 
-	users    map[string]*User
 
-	mu       sync.RWMutex
 
+	filePath      string
 
+	users         map[string]*User
 
+	bucketConfigs map[string]*BucketConfig
 
+	mu            sync.RWMutex
 
 }
 
 
 // NewFileBasedKVDB creates a new file-based key-value database
 
 func NewFileBasedKVDB(filePath string) (*FileBasedKVDB, error) {
 
 	db := &FileBasedKVDB{
 
-		filePath: filePath,
 
-		users:    make(map[string]*User),
 
+		filePath:      filePath,
 
+		users:         make(map[string]*User),
 
+		bucketConfigs: make(map[string]*BucketConfig),
 
 	}
 
 
 	// Create directory if it doesn't exist
 
@@ -139,6 +216,11 @@ func NewFileBasedKVDB(filePath string) (*FileBasedKVDB, error) {
 
 	return db, nil
 
 }
 
 
+type fileBasedData struct {
 
+	Users         []*User         `json:"users"`
 
+	BucketConfigs []*BucketConfig `json:"bucket_configs"`
 
+}
 
+
 
 // load reads the database from disk
 
 func (db *FileBasedKVDB) load() error {
 
 	data, err := os.ReadFile(db.filePath)
 
@@ -146,18 +228,23 @@ func (db *FileBasedKVDB) load() error {
 
 		return err
 
 	}
 
 
-	var users []*User
 
-	if err := json.Unmarshal(data, &users); err != nil {
 
+	var fileData fileBasedData
 
+	if err := json.Unmarshal(data, &fileData); err != nil {
 
 		return err
 
 	}
 
 
 	db.mu.Lock()
 
 	defer db.mu.Unlock()
 
 
-	for _, user := range users {
 
+	for _, user := range fileData.Users {
 
 		db.users[user.AccessKeyID] = user
 
 	}
 
 
+	for _, config := range fileData.BucketConfigs {
 
+		key := config.AccountID + ":" + config.BucketID
 
+		db.bucketConfigs[key] = config
 
+	}
 
+
 
 	return nil
 
 }
 
 
@@ -168,7 +255,17 @@ func (db *FileBasedKVDB) save() error {
 
 		users = append(users, user)
 
 	}
 
 
-	data, err := json.MarshalIndent(users, "", "  ")
 
+	configs := make([]*BucketConfig, 0, len(db.bucketConfigs))
 
+	for _, config := range db.bucketConfigs {
 
+		configs = append(configs, config)
 
+	}
 
+
 
+	fileData := fileBasedData{
 
+		Users:         users,
 
+		BucketConfigs: configs,
 
+	}
 
+
 
+	data, err := json.MarshalIndent(fileData, "", "  ")
 
 	if err != nil {
 
 		return err
 
 	}
 
@@ -262,6 +359,80 @@ func (db *FileBasedKVDB) ValidateCredentials(accessKeyID, secretAccessKey string
 
 	return user, nil
 
 }
 
 
+// SetBucketConfig sets the configuration for a bucket
 
+func (db *FileBasedKVDB) SetBucketConfig(config *BucketConfig) error {
 
+	db.mu.Lock()
 
+	defer db.mu.Unlock()
 
+
 
+	key := config.AccountID + ":" + config.BucketID
 
+	configCopy := *config
 
+	db.bucketConfigs[key] = &configCopy
 
+
 
+	return db.save()
 
+}
 
+
 
+// GetBucketConfig gets the configuration for a bucket
 
+func (db *FileBasedKVDB) GetBucketConfig(accountID, bucketID string) (*BucketConfig, error) {
 
+	db.mu.RLock()
 
+	defer db.mu.RUnlock()
 
+
 
+	key := accountID + ":" + bucketID
 
+	config, exists := db.bucketConfigs[key]
 
+	if !exists {
 
+		return nil, fmt.Errorf("bucket config not found")
 
+	}
 
+
 
+	configCopy := *config
 
+	return &configCopy, nil
 
+}
 
+
 
+// DeleteBucketConfig deletes the configuration for a bucket
 
+func (db *FileBasedKVDB) DeleteBucketConfig(accountID, bucketID string) error {
 
+	db.mu.Lock()
 
+	defer db.mu.Unlock()
 
+
 
+	key := accountID + ":" + bucketID
 
+	if _, exists := db.bucketConfigs[key]; !exists {
 
+		return fmt.Errorf("bucket config not found")
 
+	}
 
+
 
+	delete(db.bucketConfigs, key)
 
+
 
+	return db.save()
 
+}
 
+
 
+// ListBucketConfigs lists all bucket configurations for an account
 
+func (db *FileBasedKVDB) ListBucketConfigs(accountID string) ([]*BucketConfig, error) {
 
+	db.mu.RLock()
 
+	defer db.mu.RUnlock()
 
+
 
+	var configs []*BucketConfig
 
+	prefix := accountID + ":"
 
+
 
+	for key, config := range db.bucketConfigs {
 
+		if len(key) >= len(prefix) && key[:len(prefix)] == prefix {
 
+			configCopy := *config
 
+			configs = append(configs, &configCopy)
 
+		}
 
+	}
 
+
 
+	return configs, nil
 
+}
 
+
 
+// ResolveBucketName resolves a bucket name to accountID and bucketID
 
+func (db *FileBasedKVDB) ResolveBucketName(bucketName string) (string, string, error) {
 
+	db.mu.RLock()
 
+	defer db.mu.RUnlock()
 
+
 
+	for _, config := range db.bucketConfigs {
 
+		if config.BucketName == bucketName {
 
+			return config.AccountID, config.BucketID, nil
 
+		}
 
+	}
 
+
 
+	return "", "", fmt.Errorf("bucket not found: %s", bucketName)
 
+}
 
+
 
 // Close closes the database
 
 func (db *FileBasedKVDB) Close() error {
 
 	db.mu.Lock()

+ 4 - 0
aws/internal/kvdb/types.go
مشاهده فایل 

@@ -31,6 +31,10 @@ type KVDB interface {
 
 	// User validation
 
 	ValidateCredentials(accessKeyID, secretAccessKey string) (*User, error)
 
 
+	// Bucket operations
 
+	ResolveBucketName(bucketName string) (accountID string, bucketID string, err error)
 
+	GetBucketConfig(accountID, bucketID string) (*BucketConfig, error)
 
+
 
 	// Close the database
 
 	Close() error
 
 }

+ 79 - 0
aws/internal/service/s3.go
مشاهده فایل 

@@ -429,3 +429,82 @@ func (s *S3Service) MoveObject(accountID, srcBucket, srcKey, dstBucket, dstKey s
 
 	// Delete source object
 
 	return s.DeleteObject(accountID, srcBucket, srcKey)
 
 }
 
+
 
+// CreateMultipartUpload initiates a multipart upload
 
+func (s *S3Service) CreateMultipartUpload(accountID, bucket, key string) (string, error) {
 
+	// Check if bucket exists
 
+	exists, err := s.storage.BucketExistsForUser(accountID, bucket)
 
+	if err != nil {
 
+		return "", err
 
+	}
 
+	if !exists {
 
+		return "", storage.ErrBucketNotFound
 
+	}
 
+
 
+	return s.storage.CreateMultipartUpload(accountID, bucket, key)
 
+}
 
+
 
+// UploadPart uploads a part for a multipart upload
 
+func (s *S3Service) UploadPart(uploadID string, partNumber int, data io.Reader) (string, error) {
 
+	// Validate part number (1-10000)
 
+	if partNumber < 1 || partNumber > 10000 {
 
+		return "", fmt.Errorf("part number must be between 1 and 10000")
 
+	}
 
+
 
+	return s.storage.UploadPart(uploadID, partNumber, data)
 
+}
 
+
 
+// ListParts lists parts of a multipart upload
 
+func (s *S3Service) ListParts(uploadID string, maxParts, partNumberMarker int) ([]storage.PartInfo, int, bool, error) {
 
+	if maxParts <= 0 {
 
+		maxParts = 1000 // Default max parts
 
+	}
 
+	if maxParts > 1000 {
 
+		maxParts = 1000 // S3 limit
 
+	}
 
+
 
+	return s.storage.ListParts(uploadID, maxParts, partNumberMarker)
 
+}
 
+
 
+// GetMultipartUpload gets multipart upload information
 
+func (s *S3Service) GetMultipartUpload(uploadID string) (*storage.MultipartUploadInfo, error) {
 
+	return s.storage.GetMultipartUpload(uploadID)
 
+}
 
+
 
+// AbortMultipartUpload cancels a multipart upload
 
+func (s *S3Service) AbortMultipartUpload(uploadID string) error {
 
+	return s.storage.AbortMultipartUpload(uploadID)
 
+}
 
+
 
+// CompleteMultipartUpload finalizes a multipart upload
 
+func (s *S3Service) CompleteMultipartUpload(uploadID string, parts []int) error {
 
+	// Validate parts are in order
 
+	for i := 1; i < len(parts); i++ {
 
+		if parts[i] <= parts[i-1] {
 
+			return fmt.Errorf("parts must be in ascending order")
 
+		}
 
+	}
 
+
 
+	return s.storage.CompleteMultipartUpload(uploadID, parts)
 
+}
 
+
 
+// ListMultipartUploads lists in-progress multipart uploads for a bucket
 
+func (s *S3Service) ListMultipartUploads(accountID, bucket string, maxUploads int, keyMarker, uploadIDMarker string) ([]storage.MultipartUploadInfo, string, string, bool, error) {
 
+	// Check if bucket exists
 
+	exists, err := s.storage.BucketExistsForUser(accountID, bucket)
 
+	if err != nil {
 
+		return nil, "", "", false, err
 
+	}
 
+	if !exists {
 
+		return nil, "", "", false, storage.ErrBucketNotFound
 
+	}
 
+
 
+	if maxUploads <= 0 {
 
+		maxUploads = 1000
 
+	}
 
+	if maxUploads > 1000 {
 
+		maxUploads = 1000
 
+	}
 
+
 
+	return s.storage.ListMultipartUploads(accountID, bucket, maxUploads, keyMarker, uploadIDMarker)
 
+}

+ 278 - 0
aws/internal/storage/multipart.go
مشاهده فایل 

@@ -0,0 +1,278 @@
 
+package storage
 
+
 
+import (
 
+	"fmt"
 
+	"io"
 
+	"sync"
 
+	"time"
 
+)
 
+
 
+// MultipartUploadInfo stores information about an in-progress multipart upload
 
+type MultipartUploadInfo struct {
 
+	UploadID   string
 
+	Bucket     string
 
+	Key        string
 
+	AccountID  string
 
+	Initiated  time.Time
 
+	Parts      map[int]*PartInfo
 
+	PartsMutex sync.RWMutex
 
+}
 
+
 
+// PartInfo stores information about an uploaded part
 
+type PartInfo struct {
 
+	PartNumber   int
 
+	ETag         string
 
+	Size         int64
 
+	LastModified time.Time
 
+	Data         []byte // In-memory storage for simplicity
 
+}
 
+
 
+// MultipartStorage manages multipart uploads
 
+type MultipartStorage struct {
 
+	uploads map[string]*MultipartUploadInfo // key: uploadID
 
+	mutex   sync.RWMutex
 
+}
 
+
 
+// NewMultipartStorage creates a new multipart storage manager
 
+func NewMultipartStorage() *MultipartStorage {
 
+	return &MultipartStorage{
 
+		uploads: make(map[string]*MultipartUploadInfo),
 
+	}
 
+}
 
+
 
+// CreateMultipartUpload initiates a new multipart upload
 
+func (m *MultipartStorage) CreateMultipartUpload(accountID, bucket, key string) (string, error) {
 
+	m.mutex.Lock()
 
+	defer m.mutex.Unlock()
 
+
 
+	uploadID := generateUploadID()
 
+
 
+	upload := &MultipartUploadInfo{
 
+		UploadID:  uploadID,
 
+		Bucket:    bucket,
 
+		Key:       key,
 
+		AccountID: accountID,
 
+		Initiated: time.Now(),
 
+		Parts:     make(map[int]*PartInfo),
 
+	}
 
+
 
+	m.uploads[uploadID] = upload
 
+	return uploadID, nil
 
+}
 
+
 
+// UploadPart uploads a single part
 
+func (m *MultipartStorage) UploadPart(uploadID string, partNumber int, data io.Reader) (string, error) {
 
+	m.mutex.RLock()
 
+	upload, exists := m.uploads[uploadID]
 
+	m.mutex.RUnlock()
 
+
 
+	if !exists {
 
+		return "", fmt.Errorf("upload not found: %s", uploadID)
 
+	}
 
+
 
+	// Read part data
 
+	partData, err := io.ReadAll(data)
 
+	if err != nil {
 
+		return "", fmt.Errorf("failed to read part data: %w", err)
 
+	}
 
+
 
+	// Calculate ETag (MD5 hash in quotes)
 
+	etag := calculateETag(partData)
 
+
 
+	// Store part
 
+	upload.PartsMutex.Lock()
 
+	upload.Parts[partNumber] = &PartInfo{
 
+		PartNumber:   partNumber,
 
+		ETag:         etag,
 
+		Size:         int64(len(partData)),
 
+		LastModified: time.Now(),
 
+		Data:         partData,
 
+	}
 
+	upload.PartsMutex.Unlock()
 
+
 
+	return etag, nil
 
+}
 
+
 
+// ListParts lists all uploaded parts for a multipart upload
 
+func (m *MultipartStorage) ListParts(uploadID string, maxParts, partNumberMarker int) ([]PartInfo, int, bool, error) {
 
+	m.mutex.RLock()
 
+	upload, exists := m.uploads[uploadID]
 
+	m.mutex.RUnlock()
 
+
 
+	if !exists {
 
+		return nil, 0, false, fmt.Errorf("upload not found: %s", uploadID)
 
+	}
 
+
 
+	upload.PartsMutex.RLock()
 
+	defer upload.PartsMutex.RUnlock()
 
+
 
+	// Collect and sort parts
 
+	var parts []PartInfo
 
+	for partNum, part := range upload.Parts {
 
+		if partNum > partNumberMarker {
 
+			parts = append(parts, *part)
 
+		}
 
+	}
 
+
 
+	// Sort by part number
 
+	sortPartsByNumber(parts)
 
+
 
+	// Apply pagination
 
+	isTruncated := false
 
+	nextMarker := 0
 
+
 
+	if len(parts) > maxParts {
 
+		isTruncated = true
 
+		nextMarker = parts[maxParts-1].PartNumber
 
+		parts = parts[:maxParts]
 
+	}
 
+
 
+	return parts, nextMarker, isTruncated, nil
 
+}
 
+
 
+// GetUpload retrieves upload information
 
+func (m *MultipartStorage) GetUpload(uploadID string) (*MultipartUploadInfo, error) {
 
+	m.mutex.RLock()
 
+	defer m.mutex.RUnlock()
 
+
 
+	upload, exists := m.uploads[uploadID]
 
+	if !exists {
 
+		return nil, fmt.Errorf("upload not found: %s", uploadID)
 
+	}
 
+
 
+	return upload, nil
 
+}
 
+
 
+// AbortMultipartUpload cancels a multipart upload
 
+func (m *MultipartStorage) AbortMultipartUpload(uploadID string) error {
 
+	m.mutex.Lock()
 
+	defer m.mutex.Unlock()
 
+
 
+	if _, exists := m.uploads[uploadID]; !exists {
 
+		return fmt.Errorf("upload not found: %s", uploadID)
 
+	}
 
+
 
+	delete(m.uploads, uploadID)
 
+	return nil
 
+}
 
+
 
+// CompleteMultipartUpload finalizes a multipart upload
 
+func (m *MultipartStorage) CompleteMultipartUpload(uploadID string, parts []int) ([]byte, string, error) {
 
+	m.mutex.Lock()
 
+	upload, exists := m.uploads[uploadID]
 
+	if !exists {
 
+		m.mutex.Unlock()
 
+		return nil, "", fmt.Errorf("upload not found: %s", uploadID)
 
+	}
 
+
 
+	// Remove from active uploads
 
+	delete(m.uploads, uploadID)
 
+	m.mutex.Unlock()
 
+
 
+	upload.PartsMutex.RLock()
 
+	defer upload.PartsMutex.RUnlock()
 
+
 
+	// Validate all parts exist
 
+	for _, partNum := range parts {
 
+		if _, exists := upload.Parts[partNum]; !exists {
 
+			return nil, "", fmt.Errorf("part %d not found", partNum)
 
+		}
 
+	}
 
+
 
+	// Combine all parts in order
 
+	var combinedData []byte
 
+	for _, partNum := range parts {
 
+		part := upload.Parts[partNum]
 
+		combinedData = append(combinedData, part.Data...)
 
+	}
 
+
 
+	// Calculate final ETag
 
+	etag := calculateETag(combinedData)
 
+
 
+	return combinedData, etag, nil
 
+}
 
+
 
+// ListMultipartUploads lists all in-progress uploads for a bucket
 
+func (m *MultipartStorage) ListMultipartUploads(accountID, bucket string, maxUploads int, keyMarker, uploadIDMarker string) ([]MultipartUploadInfo, string, string, bool, error) {
 
+	m.mutex.RLock()
 
+	defer m.mutex.RUnlock()
 
+
 
+	var uploads []MultipartUploadInfo
 
+	for _, upload := range m.uploads {
 
+		if upload.AccountID == accountID && upload.Bucket == bucket {
 
+			// Apply marker filters
 
+			if keyMarker != "" && upload.Key <= keyMarker {
 
+				continue
 
+			}
 
+			if uploadIDMarker != "" && upload.UploadID <= uploadIDMarker {
 
+				continue
 
+			}
 
+			uploads = append(uploads, *upload)
 
+		}
 
+	}
 
+
 
+	// Sort uploads
 
+	sortUploadsByKey(uploads)
 
+
 
+	// Apply pagination
 
+	isTruncated := false
 
+	nextKeyMarker := ""
 
+	nextUploadIDMarker := ""
 
+
 
+	if len(uploads) > maxUploads {
 
+		isTruncated = true
 
+		nextKeyMarker = uploads[maxUploads-1].Key
 
+		nextUploadIDMarker = uploads[maxUploads-1].UploadID
 
+		uploads = uploads[:maxUploads]
 
+	}
 
+
 
+	return uploads, nextKeyMarker, nextUploadIDMarker, isTruncated, nil
 
+}
 
+
 
+// Helper functions
 
+
 
+func generateUploadID() string {
 
+	return fmt.Sprintf("%d-%s", time.Now().UnixNano(), randomString(32))
 
+}
 
+
 
+func calculateETag(data []byte) string {
 
+	// Simple hash for demonstration - in production use MD5
 
+	hash := 0
 
+	for _, b := range data {
 
+		hash = hash*31 + int(b)
 
+	}
 
+	return fmt.Sprintf("\"%x\"", hash)
 
+}
 
+
 
+func sortPartsByNumber(parts []PartInfo) {
 
+	// Simple bubble sort for demonstration
 
+	n := len(parts)
 
+	for i := 0; i < n-1; i++ {
 
+		for j := 0; j < n-i-1; j++ {
 
+			if parts[j].PartNumber > parts[j+1].PartNumber {
 
+				parts[j], parts[j+1] = parts[j+1], parts[j]
 
+			}
 
+		}
 
+	}
 
+}
 
+
 
+func sortUploadsByKey(uploads []MultipartUploadInfo) {
 
+	// Simple bubble sort for demonstration
 
+	n := len(uploads)
 
+	for i := 0; i < n-1; i++ {
 
+		for j := 0; j < n-i-1; j++ {
 
+			if uploads[j].Key > uploads[j+1].Key {
 
+				uploads[j], uploads[j+1] = uploads[j+1], uploads[j]
 
+			}
 
+		}
 
+	}
 
+}
 
+
 
+func randomString(length int) string {
 
+	const charset = "abcdefghijklmnopqrstuvwxyz0123456789"
 
+	result := make([]byte, length)
 
+	for i := range result {
 
+		result[i] = charset[time.Now().UnixNano()%int64(len(charset))]
 
+	}
 
+	return string(result)
 
+}

+ 65 - 2
aws/internal/storage/user_aware.go
مشاهده فایل 

@@ -1,15 +1,20 @@
 
 package storage
 
 
 import (
 
+	"bytes"
 
+	"fmt"
 
 	"io"
 
 	"os"
 
 	"path/filepath"
 
 	"strings"
 
+	"sync"
 
 )
 
 
 // UserAwareStorage wraps Storage with user isolation using accountID/bucketID structure
 
 type UserAwareStorage struct {
 
-	baseDir string
 
+	baseDir   string
 
+	multipart *MultipartStorage
 
+	mutex     sync.RWMutex
 
 }
 
 
 // NewUserAwareStorage creates a storage with user isolation
 
@@ -19,7 +24,8 @@ func NewUserAwareStorage(baseDir string) (*UserAwareStorage, error) {
 
 	}
 
 
 	return &UserAwareStorage{
 
-		baseDir: baseDir,
 
+		baseDir:   baseDir,
 
+		multipart: NewMultipartStorage(),
 
 	}, nil
 
 }
 
 
@@ -389,3 +395,60 @@ func sanitizePath(path string) string {
 
 	path = strings.ReplaceAll(path, "./", "")
 
 	return path
 
 }
 
+
 
+// Add these methods to UserAwareStorage
 
+
 
+// CreateMultipartUpload initiates a multipart upload
 
+func (s *UserAwareStorage) CreateMultipartUpload(accountID, bucket, key string) (string, error) {
 
+	return s.multipart.CreateMultipartUpload(accountID, bucket, key)
 
+}
 
+
 
+// UploadPart uploads a part for a multipart upload
 
+func (s *UserAwareStorage) UploadPart(uploadID string, partNumber int, data io.Reader) (string, error) {
 
+	return s.multipart.UploadPart(uploadID, partNumber, data)
 
+}
 
+
 
+// ListParts lists parts of a multipart upload
 
+func (s *UserAwareStorage) ListParts(uploadID string, maxParts, partNumberMarker int) ([]PartInfo, int, bool, error) {
 
+	return s.multipart.ListParts(uploadID, maxParts, partNumberMarker)
 
+}
 
+
 
+// GetMultipartUpload retrieves multipart upload info
 
+func (s *UserAwareStorage) GetMultipartUpload(uploadID string) (*MultipartUploadInfo, error) {
 
+	return s.multipart.GetUpload(uploadID)
 
+}
 
+
 
+// AbortMultipartUpload cancels a multipart upload
 
+func (s *UserAwareStorage) AbortMultipartUpload(uploadID string) error {
 
+	return s.multipart.AbortMultipartUpload(uploadID)
 
+}
 
+
 
+// CompleteMultipartUpload finalizes a multipart upload
 
+func (s *UserAwareStorage) CompleteMultipartUpload(uploadID string, parts []int) error {
 
+	// CRITICAL FIX: Get upload info BEFORE completing (which deletes it from active uploads)
 
+	upload, err := s.multipart.GetUpload(uploadID)
 
+	if err != nil {
 
+		return fmt.Errorf("upload not found: %s", uploadID)
 
+	}
 
+
 
+	// Get combined data (this also deletes the upload from active uploads map)
 
+	data, etag, err := s.multipart.CompleteMultipartUpload(uploadID, parts)
 
+	if err != nil {
 
+		return err
 
+	}
 
+
 
+	// Store the final object
 
+	reader := bytes.NewReader(data)
 
+	if err := s.PutObjectForUser(upload.AccountID, upload.Bucket, upload.Key, reader); err != nil {
 
+		return err
 
+	}
 
+
 
+	_ = etag // ETag could be stored in object metadata if needed
 
+
 
+	return nil
 
+}
 
+
 
+// ListMultipartUploads lists in-progress multipart uploads
 
+func (s *UserAwareStorage) ListMultipartUploads(accountID, bucket string, maxUploads int, keyMarker, uploadIDMarker string) ([]MultipartUploadInfo, string, string, bool, error) {
 
+	return s.multipart.ListMultipartUploads(accountID, bucket, maxUploads, keyMarker, uploadIDMarker)
 
+}

+ 31 - 19
aws/main.go
مشاهده فایل 

@@ -3,6 +3,7 @@ package main
 
 import (
 
 	"log"
 
 	"net/http"
 
+	"strings"
 
 
 	"aws-sts-mock/internal/config"
 
 	"aws-sts-mock/internal/handler"
 
@@ -61,24 +62,35 @@ func main() {
 
 	// Health check endpoint - no authentication
 
 	mux.HandleFunc("/health", healthHandler.Handle)
 
 
-	// Public viewing endpoint - no authentication required
 
-	mux.HandleFunc("/s3/", publicViewHandler.Handle)
 
-
 
-	// AWS S3/STS endpoints - with SigV4 and user validation
 
+	// Main endpoint - handles both authenticated and public requests
 
 	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 
-		// Apply SigV4 middleware
 
-		sigv4Handler := sigv4Middleware(func(w http.ResponseWriter, r *http.Request) {
 
-			// Apply user validation middleware
 
-			userValidationMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 
-				// Route to appropriate handler
 
-				if r.Method == "POST" && r.FormValue("Action") != "" {
 
-					stsHandler.Handle(w, r)
 
-				} else {
 
-					s3Handler.Handle(w, r)
 
-				}
 
-			})).ServeHTTP(w, r)
 
-		})
 
-		sigv4Handler(w, r)
 
+		// Check if Authorization header exists (indicates authenticated request)
 
+		authHeader := r.Header.Get("Authorization")
 
+
 
+		if authHeader != "" {
 
+			// Authenticated request - determine if STS or S3 based on Content-Type
 
+			// STS requests use application/x-www-form-urlencoded
 
+			// S3 requests typically don't, or use application/xml
 
+			contentType := r.Header.Get("Content-Type")
 
+
 
+			// If it's a POST with form-urlencoded content type, it's likely STS
 
+			if r.Method == "POST" && strings.Contains(contentType, "application/x-www-form-urlencoded") {
 
+				// STS request
 
+				sigv4Handler := sigv4Middleware(func(w http.ResponseWriter, r *http.Request) {
 
+					userValidationMiddleware(http.HandlerFunc(stsHandler.Handle)).ServeHTTP(w, r)
 
+				})
 
+				sigv4Handler(w, r)
 
+			} else {
 
+				// S3 request
 
+				sigv4Handler := sigv4Middleware(func(w http.ResponseWriter, r *http.Request) {
 
+					userValidationMiddleware(http.HandlerFunc(s3Handler.Handle)).ServeHTTP(w, r)
 
+				})
 
+				sigv4Handler(w, r)
 
+			}
 
+		} else {
 
+			// Unauthenticated request - try public viewing
 
+			publicViewHandler.Handle(w, r)
 
+		}
 
 	})
 
 
 	// Start server
 
@@ -92,8 +104,8 @@ func main() {
 
 	log.Printf("Folder structure: ./uploads/{accountID}/{bucketID}/")
 
 	log.Printf("")
 
 	log.Printf("Endpoints:")
 
-	log.Printf("  - AWS S3/STS: http://localhost:%s/", cfg.Port)
 
-	log.Printf("  - Public View: http://localhost:%s/s3/{accountID}/{bucketID}/", cfg.Port)
 
+	log.Printf("  - AWS S3/STS (authenticated): http://localhost:%s/", cfg.Port)
 
+	log.Printf("  - Public View (unauthenticated): http://localhost:%s/{bucketName}/{objectKey}", cfg.Port)
 
 	log.Printf("  - Health Check: http://localhost:%s/health", cfg.Port)
 
 	log.Printf("========================================")

تفاوت فایلی نمایش داده نمی شود زیرا این فایل بسیار بزرگ است
+ 27 - 0
aws/output.txt


+ 425 - 0
aws/pkg/checksum/checksum.go
مشاهده فایل 

@@ -0,0 +1,425 @@
 
+package checksum
 
+
 
+import (
 
+	"crypto/md5"
 
+	"crypto/sha1"
 
+	"crypto/sha256"
 
+	"encoding/base64"
 
+	"fmt"
 
+	"hash"
 
+	"hash/crc32"
 
+	"hash/crc64"
 
+	"io"
 
+)
 
+
 
+// ChecksumAlgorithm represents supported checksum algorithms
 
+type ChecksumAlgorithm string
 
+
 
+const (
 
+	AlgorithmMD5       ChecksumAlgorithm = "MD5"
 
+	AlgorithmCRC32     ChecksumAlgorithm = "CRC32"
 
+	AlgorithmCRC32C    ChecksumAlgorithm = "CRC32C"
 
+	AlgorithmCRC64NVME ChecksumAlgorithm = "CRC64NVME"
 
+	AlgorithmSHA1      ChecksumAlgorithm = "SHA1"
 
+	AlgorithmSHA256    ChecksumAlgorithm = "SHA256"
 
+)
 
+
 
+// ChecksumValidator validates data against provided checksums
 
+type ChecksumValidator struct {
 
+	// Algorithm specified in x-amz-sdk-checksum-algorithm header
 
+	Algorithm ChecksumAlgorithm
 
+
 
+	// Expected checksums from headers (base64 encoded)
 
+	ExpectedMD5       string // Content-MD5 header
 
+	ExpectedCRC32     string // x-amz-checksum-crc32 header
 
+	ExpectedCRC32C    string // x-amz-checksum-crc32c header
 
+	ExpectedCRC64NVME string // x-amz-checksum-crc64nvme header
 
+	ExpectedSHA1      string // x-amz-checksum-sha1 header
 
+	ExpectedSHA256    string // x-amz-checksum-sha256 header
 
+}
 
+
 
+// ChecksumResult contains computed checksums and validation results
 
+type ChecksumResult struct {
 
+	MD5       string // base64 encoded
 
+	CRC32     string // base64 encoded
 
+	CRC32C    string // base64 encoded
 
+	CRC64NVME string // base64 encoded
 
+	SHA1      string // base64 encoded
 
+	SHA256    string // base64 encoded
 
+
 
+	// Validation results
 
+	Valid         bool
 
+	ValidatedWith ChecksumAlgorithm
 
+	ErrorMessage  string
 
+}
 
+
 
+// NewValidator creates a new checksum validator from headers
 
+func NewValidator(headers map[string]string) *ChecksumValidator {
 
+	validator := &ChecksumValidator{
 
+		Algorithm:         ChecksumAlgorithm(headers["x-amz-sdk-checksum-algorithm"]),
 
+		ExpectedMD5:       headers["Content-MD5"],
 
+		ExpectedCRC32:     headers["x-amz-checksum-crc32"],
 
+		ExpectedCRC32C:    headers["x-amz-checksum-crc32c"],
 
+		ExpectedCRC64NVME: headers["x-amz-checksum-crc64nvme"],
 
+		ExpectedSHA1:      headers["x-amz-checksum-sha1"],
 
+		ExpectedSHA256:    headers["x-amz-checksum-sha256"],
 
+	}
 
+
 
+	// Normalize algorithm name
 
+	if validator.Algorithm == "" {
 
+		// If no algorithm specified but MD5 is present, use MD5
 
+		if validator.ExpectedMD5 != "" {
 
+			validator.Algorithm = AlgorithmMD5
 
+		}
 
+	}
 
+
 
+	return validator
 
+}
 
+
 
+// ValidateData validates data against expected checksums
 
+func (v *ChecksumValidator) ValidateData(data []byte) *ChecksumResult {
 
+	result := v.ComputeChecksums(data)
 
+
 
+	// Validate based on algorithm or any provided checksum
 
+	if v.Algorithm != "" {
 
+		result.ValidatedWith = v.Algorithm
 
+		result.Valid = v.validateAlgorithm(result, v.Algorithm)
 
+		if !result.Valid {
 
+			result.ErrorMessage = fmt.Sprintf("Checksum mismatch for algorithm %s", v.Algorithm)
 
+		}
 
+	} else {
 
+		// Try to validate with any available checksum
 
+		result.Valid = true // Assume valid if no checksums provided
 
+
 
+		if v.ExpectedMD5 != "" {
 
+			result.ValidatedWith = AlgorithmMD5
 
+			if !v.validateAlgorithm(result, AlgorithmMD5) {
 
+				result.Valid = false
 
+				result.ErrorMessage = "MD5 checksum mismatch"
 
+				return result
 
+			}
 
+		}
 
+
 
+		if v.ExpectedCRC32 != "" {
 
+			result.ValidatedWith = AlgorithmCRC32
 
+			if !v.validateAlgorithm(result, AlgorithmCRC32) {
 
+				result.Valid = false
 
+				result.ErrorMessage = "CRC32 checksum mismatch"
 
+				return result
 
+			}
 
+		}
 
+
 
+		if v.ExpectedCRC32C != "" {
 
+			result.ValidatedWith = AlgorithmCRC32C
 
+			if !v.validateAlgorithm(result, AlgorithmCRC32C) {
 
+				result.Valid = false
 
+				result.ErrorMessage = "CRC32C checksum mismatch"
 
+				return result
 
+			}
 
+		}
 
+
 
+		if v.ExpectedCRC64NVME != "" {
 
+			result.ValidatedWith = AlgorithmCRC64NVME
 
+			if !v.validateAlgorithm(result, AlgorithmCRC64NVME) {
 
+				result.Valid = false
 
+				result.ErrorMessage = "CRC64NVME checksum mismatch"
 
+				return result
 
+			}
 
+		}
 
+
 
+		if v.ExpectedSHA1 != "" {
 
+			result.ValidatedWith = AlgorithmSHA1
 
+			if !v.validateAlgorithm(result, AlgorithmSHA1) {
 
+				result.Valid = false
 
+				result.ErrorMessage = "SHA1 checksum mismatch"
 
+				return result
 
+			}
 
+		}
 
+
 
+		if v.ExpectedSHA256 != "" {
 
+			result.ValidatedWith = AlgorithmSHA256
 
+			if !v.validateAlgorithm(result, AlgorithmSHA256) {
 
+				result.Valid = false
 
+				result.ErrorMessage = "SHA256 checksum mismatch"
 
+				return result
 
+			}
 
+		}
 
+	}
 
+
 
+	return result
 
+}
 
+
 
+// ValidateStream validates a stream of data against expected checksums
 
+func (v *ChecksumValidator) ValidateStream(reader io.Reader) (*ChecksumResult, []byte, error) {
 
+	// Read all data
 
+	data, err := io.ReadAll(reader)
 
+	if err != nil {
 
+		return nil, nil, fmt.Errorf("failed to read data: %w", err)
 
+	}
 
+
 
+	result := v.ValidateData(data)
 
+	return result, data, nil
 
+}
 
+
 
+// validateAlgorithm validates a specific algorithm
 
+func (v *ChecksumValidator) validateAlgorithm(result *ChecksumResult, algorithm ChecksumAlgorithm) bool {
 
+	switch algorithm {
 
+	case AlgorithmMD5:
 
+		return v.ExpectedMD5 == "" || v.ExpectedMD5 == result.MD5
 
+	case AlgorithmCRC32:
 
+		return v.ExpectedCRC32 == "" || v.ExpectedCRC32 == result.CRC32
 
+	case AlgorithmCRC32C:
 
+		return v.ExpectedCRC32C == "" || v.ExpectedCRC32C == result.CRC32C
 
+	case AlgorithmCRC64NVME:
 
+		return v.ExpectedCRC64NVME == "" || v.ExpectedCRC64NVME == result.CRC64NVME
 
+	case AlgorithmSHA1:
 
+		return v.ExpectedSHA1 == "" || v.ExpectedSHA1 == result.SHA1
 
+	case AlgorithmSHA256:
 
+		return v.ExpectedSHA256 == "" || v.ExpectedSHA256 == result.SHA256
 
+	default:
 
+		return false
 
+	}
 
+}
 
+
 
+// ComputeChecksums computes all supported checksums for the data
 
+func (v *ChecksumValidator) ComputeChecksums(data []byte) *ChecksumResult {
 
+	result := &ChecksumResult{
 
+		Valid: true,
 
+	}
 
+
 
+	// Compute all checksums
 
+	result.MD5 = computeMD5(data)
 
+	result.CRC32 = computeCRC32(data)
 
+	result.CRC32C = computeCRC32C(data)
 
+	result.CRC64NVME = computeCRC64NVME(data)
 
+	result.SHA1 = computeSHA1(data)
 
+	result.SHA256 = computeSHA256(data)
 
+
 
+	return result
 
+}
 
+
 
+// GetResponseHeaders returns the appropriate checksum headers for the response
 
+func (r *ChecksumResult) GetResponseHeaders() map[string]string {
 
+	headers := make(map[string]string)
 
+
 
+	// Always include ETag (MD5)
 
+	headers["ETag"] = fmt.Sprintf(`"%s"`, r.MD5)
 
+
 
+	// Include checksum headers based on what was validated
 
+	switch r.ValidatedWith {
 
+	case AlgorithmCRC32:
 
+		headers["x-amz-checksum-crc32"] = r.CRC32
 
+		headers["x-amz-checksum-type"] = "COMPOSITE" // For multipart uploads
 
+	case AlgorithmCRC32C:
 
+		headers["x-amz-checksum-crc32c"] = r.CRC32C
 
+		headers["x-amz-checksum-type"] = "COMPOSITE"
 
+	case AlgorithmCRC64NVME:
 
+		headers["x-amz-checksum-crc64nvme"] = r.CRC64NVME
 
+		headers["x-amz-checksum-type"] = "COMPOSITE"
 
+	case AlgorithmSHA1:
 
+		headers["x-amz-checksum-sha1"] = r.SHA1
 
+		headers["x-amz-checksum-type"] = "COMPOSITE"
 
+	case AlgorithmSHA256:
 
+		headers["x-amz-checksum-sha256"] = r.SHA256
 
+		headers["x-amz-checksum-type"] = "COMPOSITE"
 
+	}
 
+
 
+	return headers
 
+}
 
+
 
+// Helper functions to compute individual checksums
 
+
 
+func computeMD5(data []byte) string {
 
+	h := md5.New()
 
+	h.Write(data)
 
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
 
+}
 
+
 
+func computeCRC32(data []byte) string {
 
+	h := crc32.NewIEEE()
 
+	h.Write(data)
 
+	sum := h.Sum32()
 
+	// Convert to 4-byte array
 
+	bytes := []byte{
 
+		byte(sum >> 24),
 
+		byte(sum >> 16),
 
+		byte(sum >> 8),
 
+		byte(sum),
 
+	}
 
+	return base64.StdEncoding.EncodeToString(bytes)
 
+}
 
+
 
+func computeCRC32C(data []byte) string {
 
+	// CRC32C uses Castagnoli polynomial
 
+	table := crc32.MakeTable(crc32.Castagnoli)
 
+	h := crc32.New(table)
 
+	h.Write(data)
 
+	sum := h.Sum32()
 
+	// Convert to 4-byte array
 
+	bytes := []byte{
 
+		byte(sum >> 24),
 
+		byte(sum >> 16),
 
+		byte(sum >> 8),
 
+		byte(sum),
 
+	}
 
+	return base64.StdEncoding.EncodeToString(bytes)
 
+}
 
+
 
+func computeCRC64NVME(data []byte) string {
 
+	// CRC64 with NVME polynomial
 
+	// Using ECMA polynomial as approximation (Go doesn't have NVME built-in)
 
+	table := crc64.MakeTable(crc64.ECMA)
 
+	h := crc64.New(table)
 
+	h.Write(data)
 
+	sum := h.Sum64()
 
+	// Convert to 8-byte array
 
+	bytes := []byte{
 
+		byte(sum >> 56),
 
+		byte(sum >> 48),
 
+		byte(sum >> 40),
 
+		byte(sum >> 32),
 
+		byte(sum >> 24),
 
+		byte(sum >> 16),
 
+		byte(sum >> 8),
 
+		byte(sum),
 
+	}
 
+	return base64.StdEncoding.EncodeToString(bytes)
 
+}
 
+
 
+func computeSHA1(data []byte) string {
 
+	h := sha1.New()
 
+	h.Write(data)
 
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
 
+}
 
+
 
+func computeSHA256(data []byte) string {
 
+	h := sha256.New()
 
+	h.Write(data)
 
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
 
+}
 
+
 
+// StreamingValidator allows computing checksums while streaming data
 
+type StreamingValidator struct {
 
+	md5Hash       hash.Hash
 
+	crc32Hash     hash.Hash32
 
+	crc32cHash    hash.Hash32
 
+	crc64nvmeHash hash.Hash64
 
+	sha1Hash      hash.Hash
 
+	sha256Hash    hash.Hash
 
+
 
+	bytesWritten int64
 
+}
 
+
 
+// NewStreamingValidator creates a new streaming validator
 
+func NewStreamingValidator() *StreamingValidator {
 
+	return &StreamingValidator{
 
+		md5Hash:       md5.New(),
 
+		crc32Hash:     crc32.NewIEEE(),
 
+		crc32cHash:    crc32.New(crc32.MakeTable(crc32.Castagnoli)),
 
+		crc64nvmeHash: crc64.New(crc64.MakeTable(crc64.ECMA)),
 
+		sha1Hash:      sha1.New(),
 
+		sha256Hash:    sha256.New(),
 
+	}
 
+}
 
+
 
+// Write implements io.Writer
 
+func (sv *StreamingValidator) Write(p []byte) (n int, err error) {
 
+	sv.md5Hash.Write(p)
 
+	sv.crc32Hash.Write(p)
 
+	sv.crc32cHash.Write(p)
 
+	sv.crc64nvmeHash.Write(p)
 
+	sv.sha1Hash.Write(p)
 
+	sv.sha256Hash.Write(p)
 
+	sv.bytesWritten += int64(len(p))
 
+	return len(p), nil
 
+}
 
+
 
+// GetResult returns the computed checksums
 
+func (sv *StreamingValidator) GetResult() *ChecksumResult {
 
+	result := &ChecksumResult{
 
+		MD5:    base64.StdEncoding.EncodeToString(sv.md5Hash.Sum(nil)),
 
+		SHA1:   base64.StdEncoding.EncodeToString(sv.sha1Hash.Sum(nil)),
 
+		SHA256: base64.StdEncoding.EncodeToString(sv.sha256Hash.Sum(nil)),
 
+	}
 
+
 
+	// CRC32
 
+	sum32 := sv.crc32Hash.Sum32()
 
+	result.CRC32 = base64.StdEncoding.EncodeToString([]byte{
 
+		byte(sum32 >> 24), byte(sum32 >> 16), byte(sum32 >> 8), byte(sum32),
 
+	})
 
+
 
+	// CRC32C
 
+	sum32c := sv.crc32cHash.Sum32()
 
+	result.CRC32C = base64.StdEncoding.EncodeToString([]byte{
 
+		byte(sum32c >> 24), byte(sum32c >> 16), byte(sum32c >> 8), byte(sum32c),
 
+	})
 
+
 
+	// CRC64NVME
 
+	sum64 := sv.crc64nvmeHash.Sum64()
 
+	result.CRC64NVME = base64.StdEncoding.EncodeToString([]byte{
 
+		byte(sum64 >> 56), byte(sum64 >> 48), byte(sum64 >> 40), byte(sum64 >> 32),
 
+		byte(sum64 >> 24), byte(sum64 >> 16), byte(sum64 >> 8), byte(sum64),
 
+	})
 
+
 
+	return result
 
+}
 
+
 
+// BytesWritten returns the total bytes written
 
+func (sv *StreamingValidator) BytesWritten() int64 {
 
+	return sv.bytesWritten
 
+}
 
+
 
+// ValidateWithExpected validates the computed checksums against expected values
 
+func (sv *StreamingValidator) ValidateWithExpected(validator *ChecksumValidator) *ChecksumResult {
 
+	result := sv.GetResult()
 
+
 
+	// Check each expected checksum
 
+	if validator.ExpectedMD5 != "" && validator.ExpectedMD5 != result.MD5 {
 
+		result.Valid = false
 
+		result.ValidatedWith = AlgorithmMD5
 
+		result.ErrorMessage = "MD5 checksum mismatch"
 
+		return result
 
+	}
 
+
 
+	if validator.ExpectedCRC32 != "" && validator.ExpectedCRC32 != result.CRC32 {
 
+		result.Valid = false
 
+		result.ValidatedWith = AlgorithmCRC32
 
+		result.ErrorMessage = "CRC32 checksum mismatch"
 
+		return result
 
+	}
 
+
 
+	if validator.ExpectedCRC32C != "" && validator.ExpectedCRC32C != result.CRC32C {
 
+		result.Valid = false
 
+		result.ValidatedWith = AlgorithmCRC32C
 
+		result.ErrorMessage = "CRC32C checksum mismatch"
 
+		return result
 
+	}
 
+
 
+	if validator.ExpectedCRC64NVME != "" && validator.ExpectedCRC64NVME != result.CRC64NVME {
 
+		result.Valid = false
 
+		result.ValidatedWith = AlgorithmCRC64NVME
 
+		result.ErrorMessage = "CRC64NVME checksum mismatch"
 
+		return result
 
+	}
 
+
 
+	if validator.ExpectedSHA1 != "" && validator.ExpectedSHA1 != result.SHA1 {
 
+		result.Valid = false
 
+		result.ValidatedWith = AlgorithmSHA1
 
+		result.ErrorMessage = "SHA1 checksum mismatch"
 
+		return result
 
+	}
 
+
 
+	if validator.ExpectedSHA256 != "" && validator.ExpectedSHA256 != result.SHA256 {
 
+		result.Valid = false
 
+		result.ValidatedWith = AlgorithmSHA256
 
+		result.ErrorMessage = "SHA256 checksum mismatch"
 
+		return result
 
+	}
 
+
 
+	result.Valid = true
 
+	if validator.Algorithm != "" {
 
+		result.ValidatedWith = validator.Algorithm
 
+	}
 
+
 
+	return result
 
+}

+ 96 - 0
aws/pkg/s3/types.go
مشاهده فایل 

@@ -76,3 +76,99 @@ type DeleteError struct {
 
 	Code      string `xml:"Code"`
 
 	Message   string `xml:"Message"`
 
 }
 
+
 
+// Multipart Upload structures
 
+
 
+// InitiateMultipartUploadResult represents the response for CreateMultipartUpload
 
+type InitiateMultipartUploadResult struct {
 
+	XMLName  xml.Name `xml:"InitiateMultipartUploadResult"`
 
+	Bucket   string   `xml:"Bucket"`
 
+	Key      string   `xml:"Key"`
 
+	UploadId string   `xml:"UploadId"`
 
+}
 
+
 
+// CompleteMultipartUploadRequest represents the request to complete a multipart upload
 
+type CompleteMultipartUploadRequest struct {
 
+	XMLName xml.Name       `xml:"CompleteMultipartUpload"`
 
+	Parts   []CompletePart `xml:"Part"`
 
+}
 
+
 
+// CompletePart represents a part in the complete request
 
+type CompletePart struct {
 
+	PartNumber int    `xml:"PartNumber"`
 
+	ETag       string `xml:"ETag"`
 
+}
 
+
 
+// CompleteMultipartUploadResult represents the response for CompleteMultipartUpload
 
+type CompleteMultipartUploadResult struct {
 
+	XMLName  xml.Name `xml:"CompleteMultipartUploadResult"`
 
+	Location string   `xml:"Location"`
 
+	Bucket   string   `xml:"Bucket"`
 
+	Key      string   `xml:"Key"`
 
+	ETag     string   `xml:"ETag"`
 
+}
 
+
 
+// AbortMultipartUploadOutput represents the response for AbortMultipartUpload
 
+type AbortMultipartUploadOutput struct {
 
+	XMLName xml.Name `xml:"AbortMultipartUploadOutput"`
 
+}
 
+
 
+// ListPartsResult represents the response for ListParts
 
+type ListPartsResult struct {
 
+	XMLName              xml.Name  `xml:"ListPartsResult"`
 
+	Bucket               string    `xml:"Bucket"`
 
+	Key                  string    `xml:"Key"`
 
+	UploadId             string    `xml:"UploadId"`
 
+	Initiator            Initiator `xml:"Initiator"`
 
+	Owner                Owner     `xml:"Owner"`
 
+	StorageClass         string    `xml:"StorageClass"`
 
+	PartNumberMarker     int       `xml:"PartNumberMarker"`
 
+	NextPartNumberMarker int       `xml:"NextPartNumberMarker"`
 
+	MaxParts             int       `xml:"MaxParts"`
 
+	IsTruncated          bool      `xml:"IsTruncated"`
 
+	Parts                []Part    `xml:"Part"`
 
+}
 
+
 
+// Initiator represents the initiator of a multipart upload
 
+type Initiator struct {
 
+	ID          string `xml:"ID"`
 
+	DisplayName string `xml:"DisplayName"`
 
+}
 
+
 
+// Part represents an uploaded part
 
+type Part struct {
 
+	PartNumber   int    `xml:"PartNumber"`
 
+	LastModified string `xml:"LastModified"`
 
+	ETag         string `xml:"ETag"`
 
+	Size         int64  `xml:"Size"`
 
+}
 
+
 
+// ListMultipartUploadsResult represents the response for ListMultipartUploads
 
+type ListMultipartUploadsResult struct {
 
+	XMLName            xml.Name          `xml:"ListMultipartUploadsResult"`
 
+	Bucket             string            `xml:"Bucket"`
 
+	KeyMarker          string            `xml:"KeyMarker,omitempty"`
 
+	UploadIdMarker     string            `xml:"UploadIdMarker,omitempty"`
 
+	NextKeyMarker      string            `xml:"NextKeyMarker,omitempty"`
 
+	NextUploadIdMarker string            `xml:"NextUploadIdMarker,omitempty"`
 
+	MaxUploads         int               `xml:"MaxUploads"`
 
+	IsTruncated        bool              `xml:"IsTruncated"`
 
+	Uploads            []MultipartUpload `xml:"Upload,omitempty"`
 
+	Prefix             string            `xml:"Prefix,omitempty"`
 
+	Delimiter          string            `xml:"Delimiter,omitempty"`
 
+}
 
+
 
+// MultipartUpload represents an in-progress multipart upload
 
+type MultipartUpload struct {
 
+	Key          string    `xml:"Key"`
 
+	UploadId     string    `xml:"UploadId"`
 
+	Initiator    Initiator `xml:"Initiator"`
 
+	Owner        Owner     `xml:"Owner"`
 
+	StorageClass string    `xml:"StorageClass"`
 
+	Initiated    string    `xml:"Initiated"`
 
+}
 
+
 
+// UploadPartOutput represents the response for UploadPart
 
+type UploadPartOutput struct {
 
+	ETag string `xml:"-"` // Returned in header
 
+}

+ 80 - 76
aws/pkg/sigv4/sigv4.go
مشاهده فایل 

@@ -45,17 +45,22 @@ var mockCredentials = map[string]AWSCredentials{
 
 
 // ValidateSigV4Middleware validates AWS Signature Version 4
 
 func ValidateSigV4Middleware(next http.HandlerFunc) http.HandlerFunc {
 
-	testHMAC()
 
-
 
 	return func(w http.ResponseWriter, r *http.Request) {
 
-		// Read the body
 
+		// Read the body FIRST before any processing
 
 		bodyBytes, err := io.ReadAll(r.Body)
 
 		if err != nil {
 
 			writeAuthError(w, "InvalidRequest", "Failed to read request body")
 
 			return
 
 		}
 
+		// Restore the body for downstream handlers
 
 		r.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
 
 
+		// Log the body for debugging
 
+		log.Printf("Request body length: %d bytes", len(bodyBytes))
 
+		//if len(bodyBytes) > 0 {
 
+		//log.Printf("Request body: %s", string(bodyBytes))
 
+		//}
 
+
 
 		// Parse authorization header
 
 		authHeader := r.Header.Get("Authorization")
 
 		if authHeader == "" {
 
@@ -70,12 +75,10 @@ func ValidateSigV4Middleware(next http.HandlerFunc) http.HandlerFunc {
 
 			return
 
 		}
 
 
-		log.Println(sigV4)
 
-		log.Println(sigV4.AccessKeyID)
 
 		// Validate credential
 
 		creds, ok := mockCredentials[sigV4.AccessKeyID]
 
 		if !ok {
 
-			writeAuthError(w, "InvalidClientTokenId", "The security token included in the request is invalid 1")
 
+			writeAuthError(w, "InvalidClientTokenId", "The security token included in the request is invalid")
 
 			return
 
 		}
 
 
@@ -103,7 +106,7 @@ func ValidateSigV4Middleware(next http.HandlerFunc) http.HandlerFunc {
 
 			return
 
 		}
 
 
-		// Calculate expected signature
 
+		// Calculate expected signature with the actual body bytes
 
 		expectedSig, err := calculateSignature(r, bodyBytes, creds, sigV4)
 
 		if err != nil {
 
 			writeAuthError(w, "InternalError", fmt.Sprintf("Failed to calculate signature: %v", err))
 
@@ -111,7 +114,9 @@ func ValidateSigV4Middleware(next http.HandlerFunc) http.HandlerFunc {
 
 		}
 
 
 		// Compare signatures
 
-		log.Println(expectedSig + " " + sigV4.Signature)
 
+		log.Printf("Expected signature: %s", expectedSig)
 
+		log.Printf("Provided signature: %s", sigV4.Signature)
 
+
 
 		if expectedSig != sigV4.Signature {
 
 			writeAuthError(w, "SignatureDoesNotMatch",
 
 				"The request signature we calculated does not match the signature you provided")
 
@@ -122,7 +127,7 @@ func ValidateSigV4Middleware(next http.HandlerFunc) http.HandlerFunc {
 
 		if creds.SessionToken != "" {
 
 			reqToken := r.Header.Get("X-Amz-Security-Token")
 
 			if reqToken != creds.SessionToken {
 
-				writeAuthError(w, "InvalidClientTokenId", "The security token included in the request is invalid 2")
 
+				writeAuthError(w, "InvalidClientTokenId", "The security token included in the request is invalid")
 
 				return
 
 			}
 
 		}
 
@@ -190,48 +195,18 @@ func parseSigV4Header(authHeader string) (*sigV4Components, error) {
 
 	return sig, nil
 
 }
 
 
-func testHMAC() {
 
-	fmt.Println("=== Testing with quotes in secret key ===")
 
-
 
-	// The secret key WITH quotes as it appears in environment variable
 
-	secretKeyWithQuotes := "\"wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY\""
 
-
 
-	kDate := hmacSHA256([]byte("AWS4"+secretKeyWithQuotes), "20251016")
 
-	fmt.Println("kDate with quotes:", hex.EncodeToString(kDate))
 
-
 
-	kRegion := hmacSHA256(kDate, "us-west-2")
 
-	kService := hmacSHA256(kRegion, "sts")
 
-	kSigning := hmacSHA256(kService, "aws4_request")
 
-
 
-	fmt.Println("Signing key with quotes:", hex.EncodeToString(kSigning))
 
-
 
-	stringToSign := "AWS4-HMAC-SHA256\n20251016T185909Z\n20251016/us-west-2/sts/aws4_request\nb1eade88f71175b2790108f7015d7ded65f982153aad655da6d50d5976ae14df"
 
-
 
-	signature := hmacSHA256(kSigning, stringToSign)
 
-
 
-	fmt.Println("Our signature:        ", hex.EncodeToString(signature))
 
-	fmt.Println("AWS CLI's signature:  ", "c434c79f1567cf160a5cb88d2ad710a5bc524bbb6d481ce51b4b63787f9c21a4")
 
-	fmt.Println("Match:", hex.EncodeToString(signature) == "c434c79f1567cf160a5cb88d2ad710a5bc524bbb6d481ce51b4b63787f9c21a4")
 
-}
 
-
 
 func calculateSignature(r *http.Request, body []byte, creds AWSCredentials, sigV4 *sigV4Components) (string, error) {
 
 	amzDate := r.Header.Get("X-Amz-Date")
 
 	canonicalRequest := buildCanonicalRequest(r, body, sigV4.SignedHeaders)
 
 	stringToSign := buildStringToSign(canonicalRequest, sigV4, amzDate)
 
 
-	signingKey := deriveSigningKey(creds.SecretAccessKey, sigV4.Date, sigV4.Region, sigV4.Service)
 
+	log.Printf("String to sign:\n%s", stringToSign)
 
 
-	log.Println("=== Final HMAC Input ===")
 
-	log.Printf("Key (hex): %s\n", hex.EncodeToString(signingKey))
 
-	log.Printf("Data (bytes): %v\n", []byte(stringToSign))
 
-	log.Printf("Data (hex): %s\n", hex.EncodeToString([]byte(stringToSign)))
 
+	signingKey := deriveSigningKey(creds.SecretAccessKey, sigV4.Date, sigV4.Region, sigV4.Service)
 
 
 	signature := hmacSHA256(signingKey, stringToSign)
 
 	finalSig := hex.EncodeToString(signature)
 
 
-	log.Printf("Signature (hex): %s\n", finalSig)
 
-	log.Println("=== End Final HMAC Input ===")
 
-
 
 	return finalSig, nil
 
 }
 
 
@@ -239,8 +214,12 @@ func buildCanonicalRequest(r *http.Request, body []byte, signedHeaders []string)
 
 	// Method
 
 	method := r.Method
 
 
-	// Canonical URI
 
-	canonicalURI := r.URL.Path
 
+	// Canonical URI - Use RequestURI which preserves URL encoding
 
+	// Split RequestURI to get just the path (before the query string)
 
+	canonicalURI := r.RequestURI
 
+	if idx := strings.Index(canonicalURI, "?"); idx != -1 {
 
+		canonicalURI = canonicalURI[:idx]
 
+	}
 
 	if canonicalURI == "" {
 
 		canonicalURI = "/"
 
 	}
 
@@ -254,8 +233,19 @@ func buildCanonicalRequest(r *http.Request, body []byte, signedHeaders []string)
 
 	// Signed headers
 
 	signedHeadersStr := strings.Join(signedHeaders, ";")
 
 
-	// Payload hash
 
-	payloadHash := sha256Hash(body)
 
+	// Payload hash - Check if client sent UNSIGNED-PAYLOAD
 
+	var payloadHash string
 
+	amzContentSha256 := r.Header.Get("X-Amz-Content-SHA256")
 
+	if amzContentSha256 == "UNSIGNED-PAYLOAD" {
 
+		// Use the literal string for streaming/multipart uploads
 
+		payloadHash = "UNSIGNED-PAYLOAD"
 
+	} else if amzContentSha256 != "" {
 
+		// Use the hash provided by the client
 
+		payloadHash = amzContentSha256
 
+	} else {
 
+		// Calculate hash from the actual body
 
+		payloadHash = sha256Hash(body)
 
+	}
 
 
 	canonicalRequest := fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n%s",
 
 		method,
 
@@ -266,6 +256,16 @@ func buildCanonicalRequest(r *http.Request, body []byte, signedHeaders []string)
 
 		payloadHash,
 
 	)
 
 
+	log.Printf("=== Canonical Request ===")
 
+	log.Printf("Method: %s", method)
 
+	log.Printf("Canonical URI: %s", canonicalURI)
 
+	log.Printf("Canonical Query String: %s", canonicalQueryString)
 
+	log.Printf("Canonical Headers:\n%s", canonicalHeaders)
 
+	log.Printf("Signed Headers: %s", signedHeadersStr)
 
+	log.Printf("Payload Hash: %s", payloadHash)
 
+	log.Printf("Full Canonical Request:\n%s", canonicalRequest)
 
+	log.Printf("========================")
 
+
 
 	return canonicalRequest
 
 }
 
 
@@ -274,14 +274,44 @@ func buildCanonicalQueryString(r *http.Request) string {
 
 		return ""
 
 	}
 
 
-	// Split the raw query string by '&'
 
+	// Split into key-value pairs
 
 	params := strings.Split(r.URL.RawQuery, "&")
 
 
-	// Sort the parameters
 
-	sort.Strings(params)
 
+	// Parse each parameter to separate key and value
 
+	type param struct {
 
+		key   string
 
+		value string
 
+	}
 
 
-	// Join them back with '&'
 
-	return strings.Join(params, "&")
 
+	parsedParams := make([]param, 0, len(params))
 
+	for _, p := range params {
 
+		parts := strings.SplitN(p, "=", 2)
 
+		if len(parts) == 2 {
 
+			parsedParams = append(parsedParams, param{key: parts[0], value: parts[1]})
 
+		} else {
 
+			parsedParams = append(parsedParams, param{key: parts[0], value: ""})
 
+		}
 
+	}
 
+
 
+	// Sort by key, then by value
 
+	sort.Slice(parsedParams, func(i, j int) bool {
 
+		if parsedParams[i].key == parsedParams[j].key {
 
+			return parsedParams[i].value < parsedParams[j].value
 
+		}
 
+		return parsedParams[i].key < parsedParams[j].key
 
+	})
 
+
 
+	// Rebuild the query string
 
+	result := make([]string, len(parsedParams))
 
+	for i, p := range parsedParams {
 
+		if p.value == "" {
 
+			result[i] = p.key + "="
 
+		} else {
 
+			result[i] = p.key + "=" + p.value
 
+		}
 
+	}
 
+
 
+	return strings.Join(result, "&")
 
 }
 
 
 func buildCanonicalHeaders(r *http.Request, signedHeaders []string) string {
 
@@ -293,7 +323,6 @@ func buildCanonicalHeaders(r *http.Request, signedHeaders []string) string {
 
 		// Special handling for Host header
 
 		if headerLower == "host" {
 
 			headers[headerLower] = r.Host
 
-			log.Printf("Header '%s' = '%s'", headerLower, r.Host)
 
 			continue
 
 		}
 
 
@@ -304,7 +333,6 @@ func buildCanonicalHeaders(r *http.Request, signedHeaders []string) string {
 
 				trimmedValues[i] = strings.TrimSpace(v)
 
 			}
 
 			headers[headerLower] = strings.Join(trimmedValues, ",")
 
-			log.Printf("Header '%s' = '%s'", headerLower, headers[headerLower])
 
 		}
 
 	}
 
 
@@ -328,12 +356,7 @@ func buildCanonicalHeaders(r *http.Request, signedHeaders []string) string {
 
 }
 
 
 func buildStringToSign(canonicalRequest string, sigV4 *sigV4Components, amzDate string) string {
 
-	log.Println("=== Canonical Request (raw) ===")
 
-	log.Printf("%q\n", canonicalRequest) // Using %q to show escape characters
 
-	log.Println("=== End Canonical Request (raw) ===")
 
-
 
 	canonicalRequestHash := sha256Hash([]byte(canonicalRequest))
 
-	log.Println("Canonical Request Hash:", canonicalRequestHash)
 
 
 	stringToSign := fmt.Sprintf("AWS4-HMAC-SHA256\n%s\n%s\n%s",
 
 		amzDate,
 
@@ -341,33 +364,14 @@ func buildStringToSign(canonicalRequest string, sigV4 *sigV4Components, amzDate
 
 		canonicalRequestHash,
 
 	)
 
 
-	log.Println("=== String to Sign ===")
 
-	log.Println(stringToSign)
 
-	log.Println("=== End String to Sign ===")
 
-
 
 	return stringToSign
 
 }
 
 
 func deriveSigningKey(secretKey, date, region, service string) []byte {
 
-	log.Println("=== Deriving Signing Key ===")
 
-	log.Println("Secret Key:", secretKey)
 
-	log.Println("Date:", date)
 
-	log.Println("Region:", region)
 
-	log.Println("Service:", service)
 
-
 
 	kDate := hmacSHA256([]byte("AWS4"+secretKey), date)
 
-	log.Println("kDate:", hex.EncodeToString(kDate))
 
-
 
 	kRegion := hmacSHA256(kDate, region)
 
-	log.Println("kRegion:", hex.EncodeToString(kRegion))
 
-
 
 	kService := hmacSHA256(kRegion, service)
 
-	log.Println("kService:", hex.EncodeToString(kService))
 
-
 
 	kSigning := hmacSHA256(kService, "aws4_request")
 
-	log.Println("kSigning:", hex.EncodeToString(kSigning))
 
-	log.Println("=== End Deriving Signing Key ===")
 
-
 
 	return kSigning
 
 }

+ 10872 - 0
aws/s3.json
مشاهده فایل 

@@ -0,0 +1,10872 @@
 
+{
 
+  "version":"2.0",
 
+  "metadata":{
 
+    "apiVersion":"2006-03-01",
 
+    "checksumFormat":"md5",
 
+    "endpointPrefix":"s3",
 
+    "globalEndpoint":"s3.amazonaws.com",
 
+    "protocol":"rest-xml",
 
+    "serviceAbbreviation":"Amazon S3",
 
+    "serviceFullName":"Amazon Simple Storage Service",
 
+    "serviceId":"S3",
 
+    "signatureVersion":"s3",
 
+    "uid":"s3-2006-03-01"
 
+  },
 
+  "operations":{
 
+    "AbortMultipartUpload":{
 
+      "name":"AbortMultipartUpload",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}/{Key+}",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"AbortMultipartUploadRequest"},
 
+      "output":{"shape":"AbortMultipartUploadOutput"},
 
+      "errors":[
 
+        {"shape":"NoSuchUpload"}
 
+      ],
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadAbort.html",
 
+      
+    },
 
+    "CompleteMultipartUpload":{
 
+      "name":"CompleteMultipartUpload",
 
+      "http":{
 
+        "method":"POST",
 
+        "requestUri":"/{Bucket}/{Key+}"
 
+      },
 
+      "input":{"shape":"CompleteMultipartUploadRequest"},
 
+      "output":{"shape":"CompleteMultipartUploadOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadComplete.html",
 
+      
+    },
 
+    "CopyObject":{
 
+      "name":"CopyObject",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}/{Key+}"
 
+      },
 
+      "input":{"shape":"CopyObjectRequest"},
 
+      "output":{"shape":"CopyObjectOutput"},
 
+      "errors":[
 
+        {"shape":"ObjectNotInActiveTierError"}
 
+      ],
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectCOPY.html",
 
+      
+      "alias":"PutObjectCopy"
 
+    },
 
+    "CreateBucket":{
 
+      "name":"CreateBucket",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}"
 
+      },
 
+      "input":{"shape":"CreateBucketRequest"},
 
+      "output":{"shape":"CreateBucketOutput"},
 
+      "errors":[
 
+        {"shape":"BucketAlreadyExists"},
 
+        {"shape":"BucketAlreadyOwnedByYou"}
 
+      ],
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUT.html",
 
+      
+      "alias":"PutBucket",
 
+      "staticContextParams":{
 
+        "DisableAccessPoints":{"value":true}
 
+      }
 
+    },
 
+    "CreateMultipartUpload":{
 
+      "name":"CreateMultipartUpload",
 
+      "http":{
 
+        "method":"POST",
 
+        "requestUri":"/{Bucket}/{Key+}?uploads"
 
+      },
 
+      "input":{"shape":"CreateMultipartUploadRequest"},
 
+      "output":{"shape":"CreateMultipartUploadOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadInitiate.html",
 
+      
+      "alias":"InitiateMultipartUpload"
 
+    },
 
+    "DeleteBucket":{
 
+      "name":"DeleteBucket",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETE.html",
 
+      
+    },
 
+    "DeleteBucketAnalyticsConfiguration":{
 
+      "name":"DeleteBucketAnalyticsConfiguration",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?analytics",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketAnalyticsConfigurationRequest"},
 
+      
+    },
 
+    "DeleteBucketCors":{
 
+      "name":"DeleteBucketCors",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?cors",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketCorsRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETEcors.html",
 
+      
+    },
 
+    "DeleteBucketEncryption":{
 
+      "name":"DeleteBucketEncryption",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?encryption",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketEncryptionRequest"},
 
+      
+    },
 
+    "DeleteBucketIntelligentTieringConfiguration":{
 
+      "name":"DeleteBucketIntelligentTieringConfiguration",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?intelligent-tiering",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketIntelligentTieringConfigurationRequest"},
 
+      
+    },
 
+    "DeleteBucketInventoryConfiguration":{
 
+      "name":"DeleteBucketInventoryConfiguration",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?inventory",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketInventoryConfigurationRequest"},
 
+      
+    },
 
+    "DeleteBucketLifecycle":{
 
+      "name":"DeleteBucketLifecycle",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?lifecycle",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketLifecycleRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETElifecycle.html",
 
+      
+    },
 
+    "DeleteBucketMetricsConfiguration":{
 
+      "name":"DeleteBucketMetricsConfiguration",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?metrics",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketMetricsConfigurationRequest"},
 
+      
+    },
 
+    "DeleteBucketOwnershipControls":{
 
+      "name":"DeleteBucketOwnershipControls",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?ownershipControls",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketOwnershipControlsRequest"},
 
+      
+    },
 
+    "DeleteBucketPolicy":{
 
+      "name":"DeleteBucketPolicy",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?policy",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketPolicyRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETEpolicy.html",
 
+      
+    },
 
+    "DeleteBucketReplication":{
 
+      "name":"DeleteBucketReplication",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?replication",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketReplicationRequest"},
 
+      
+    },
 
+    "DeleteBucketTagging":{
 
+      "name":"DeleteBucketTagging",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?tagging",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketTaggingRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETEtagging.html",
 
+      
+    },
 
+    "DeleteBucketWebsite":{
 
+      "name":"DeleteBucketWebsite",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?website",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteBucketWebsiteRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html",
 
+      
+    },
 
+    "DeleteObject":{
 
+      "name":"DeleteObject",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}/{Key+}",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteObjectRequest"},
 
+      "output":{"shape":"DeleteObjectOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectDELETE.html",
 
+      
+    },
 
+    "DeleteObjectTagging":{
 
+      "name":"DeleteObjectTagging",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}/{Key+}?tagging",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeleteObjectTaggingRequest"},
 
+      "output":{"shape":"DeleteObjectTaggingOutput"},
 
+      
+    },
 
+    "DeleteObjects":{
 
+      "name":"DeleteObjects",
 
+      "http":{
 
+        "method":"POST",
 
+        "requestUri":"/{Bucket}?delete"
 
+      },
 
+      "input":{"shape":"DeleteObjectsRequest"},
 
+      "output":{"shape":"DeleteObjectsOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/multiobjectdeleteapi.html",
 
+      
+      "alias":"DeleteMultipleObjects",
 
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "DeletePublicAccessBlock":{
 
+      "name":"DeletePublicAccessBlock",
 
+      "http":{
 
+        "method":"DELETE",
 
+        "requestUri":"/{Bucket}?publicAccessBlock",
 
+        "responseCode":204
 
+      },
 
+      "input":{"shape":"DeletePublicAccessBlockRequest"},
 
+      
+    },
 
+    "GetBucketAccelerateConfiguration":{
 
+      "name":"GetBucketAccelerateConfiguration",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?accelerate"
 
+      },
 
+      "input":{"shape":"GetBucketAccelerateConfigurationRequest"},
 
+      "output":{"shape":"GetBucketAccelerateConfigurationOutput"},
 
+      
+    },
 
+    "GetBucketAcl":{
 
+      "name":"GetBucketAcl",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?acl"
 
+      },
 
+      "input":{"shape":"GetBucketAclRequest"},
 
+      "output":{"shape":"GetBucketAclOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETacl.html",
 
+      
+    },
 
+    "GetBucketAnalyticsConfiguration":{
 
+      "name":"GetBucketAnalyticsConfiguration",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?analytics"
 
+      },
 
+      "input":{"shape":"GetBucketAnalyticsConfigurationRequest"},
 
+      "output":{"shape":"GetBucketAnalyticsConfigurationOutput"},
 
+      
+    },
 
+    "GetBucketCors":{
 
+      "name":"GetBucketCors",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?cors"
 
+      },
 
+      "input":{"shape":"GetBucketCorsRequest"},
 
+      "output":{"shape":"GetBucketCorsOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETcors.html",
 
+      
+    },
 
+    "GetBucketEncryption":{
 
+      "name":"GetBucketEncryption",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?encryption"
 
+      },
 
+      "input":{"shape":"GetBucketEncryptionRequest"},
 
+      "output":{"shape":"GetBucketEncryptionOutput"},
 
+      
+    },
 
+    "GetBucketIntelligentTieringConfiguration":{
 
+      "name":"GetBucketIntelligentTieringConfiguration",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?intelligent-tiering"
 
+      },
 
+      "input":{"shape":"GetBucketIntelligentTieringConfigurationRequest"},
 
+      "output":{"shape":"GetBucketIntelligentTieringConfigurationOutput"},
 
+      
+    },
 
+    "GetBucketInventoryConfiguration":{
 
+      "name":"GetBucketInventoryConfiguration",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?inventory"
 
+      },
 
+      "input":{"shape":"GetBucketInventoryConfigurationRequest"},
 
+      "output":{"shape":"GetBucketInventoryConfigurationOutput"},
 
+      
+    },
 
+    "GetBucketLifecycle":{
 
+      "name":"GetBucketLifecycle",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?lifecycle"
 
+      },
 
+      "input":{"shape":"GetBucketLifecycleRequest"},
 
+      "output":{"shape":"GetBucketLifecycleOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETlifecycle.html",
 
+      
+      "deprecated":true
 
+    },
 
+    "GetBucketLifecycleConfiguration":{
 
+      "name":"GetBucketLifecycleConfiguration",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?lifecycle"
 
+      },
 
+      "input":{"shape":"GetBucketLifecycleConfigurationRequest"},
 
+      "output":{"shape":"GetBucketLifecycleConfigurationOutput"},
 
+      
+    },
 
+    "GetBucketLocation":{
 
+      "name":"GetBucketLocation",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?location"
 
+      },
 
+      "input":{"shape":"GetBucketLocationRequest"},
 
+      "output":{"shape":"GetBucketLocationOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETlocation.html",
 
+      
+    },
 
+    "GetBucketLogging":{
 
+      "name":"GetBucketLogging",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?logging"
 
+      },
 
+      "input":{"shape":"GetBucketLoggingRequest"},
 
+      "output":{"shape":"GetBucketLoggingOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETlogging.html",
 
+      
+    },
 
+    "GetBucketMetricsConfiguration":{
 
+      "name":"GetBucketMetricsConfiguration",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?metrics"
 
+      },
 
+      "input":{"shape":"GetBucketMetricsConfigurationRequest"},
 
+      "output":{"shape":"GetBucketMetricsConfigurationOutput"},
 
+      
+    },
 
+    "GetBucketNotification":{
 
+      "name":"GetBucketNotification",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?notification"
 
+      },
 
+      "input":{"shape":"GetBucketNotificationConfigurationRequest"},
 
+      "output":{"shape":"NotificationConfigurationDeprecated"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETnotification.html",
 
+      
+      "deprecated":true
 
+    },
 
+    "GetBucketNotificationConfiguration":{
 
+      "name":"GetBucketNotificationConfiguration",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?notification"
 
+      },
 
+      "input":{"shape":"GetBucketNotificationConfigurationRequest"},
 
+      "output":{"shape":"NotificationConfiguration"},
 
+      
+    },
 
+    "GetBucketOwnershipControls":{
 
+      "name":"GetBucketOwnershipControls",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?ownershipControls"
 
+      },
 
+      "input":{"shape":"GetBucketOwnershipControlsRequest"},
 
+      "output":{"shape":"GetBucketOwnershipControlsOutput"},
 
+      
+    },
 
+    "GetBucketPolicy":{
 
+      "name":"GetBucketPolicy",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?policy"
 
+      },
 
+      "input":{"shape":"GetBucketPolicyRequest"},
 
+      "output":{"shape":"GetBucketPolicyOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETpolicy.html",
 
+      
+    },
 
+    "GetBucketPolicyStatus":{
 
+      "name":"GetBucketPolicyStatus",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?policyStatus"
 
+      },
 
+      "input":{"shape":"GetBucketPolicyStatusRequest"},
 
+      "output":{"shape":"GetBucketPolicyStatusOutput"},
 
+      
+    },
 
+    "GetBucketReplication":{
 
+      "name":"GetBucketReplication",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?replication"
 
+      },
 
+      "input":{"shape":"GetBucketReplicationRequest"},
 
+      "output":{"shape":"GetBucketReplicationOutput"},
 
+      
+    },
 
+    "GetBucketRequestPayment":{
 
+      "name":"GetBucketRequestPayment",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?requestPayment"
 
+      },
 
+      "input":{"shape":"GetBucketRequestPaymentRequest"},
 
+      "output":{"shape":"GetBucketRequestPaymentOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTrequestPaymentGET.html",
 
+      
+    },
 
+    "GetBucketTagging":{
 
+      "name":"GetBucketTagging",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?tagging"
 
+      },
 
+      "input":{"shape":"GetBucketTaggingRequest"},
 
+      "output":{"shape":"GetBucketTaggingOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETtagging.html",
 
+      
+    },
 
+    "GetBucketVersioning":{
 
+      "name":"GetBucketVersioning",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?versioning"
 
+      },
 
+      "input":{"shape":"GetBucketVersioningRequest"},
 
+      "output":{"shape":"GetBucketVersioningOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETversioningStatus.html",
 
+      
+    },
 
+    "GetBucketWebsite":{
 
+      "name":"GetBucketWebsite",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?website"
 
+      },
 
+      "input":{"shape":"GetBucketWebsiteRequest"},
 
+      "output":{"shape":"GetBucketWebsiteOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETwebsite.html",
 
+      
+    },
 
+    "GetObject":{
 
+      "name":"GetObject",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}/{Key+}"
 
+      },
 
+      "input":{"shape":"GetObjectRequest"},
 
+      "output":{"shape":"GetObjectOutput"},
 
+      "errors":[
 
+        {"shape":"NoSuchKey"},
 
+        {"shape":"InvalidObjectState"}
 
+      ],
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectGET.html",
 
+      
+      "httpChecksum":{
 
+        "requestValidationModeMember":"ChecksumMode",
 
+        "responseAlgorithms":[
 
+          "CRC32",
 
+          "CRC32C",
 
+          "SHA256",
 
+          "SHA1"
 
+        ]
 
+      }
 
+    },
 
+    "GetObjectAcl":{
 
+      "name":"GetObjectAcl",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}/{Key+}?acl"
 
+      },
 
+      "input":{"shape":"GetObjectAclRequest"},
 
+      "output":{"shape":"GetObjectAclOutput"},
 
+      "errors":[
 
+        {"shape":"NoSuchKey"}
 
+      ],
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectGETacl.html",
 
+      
+    },
 
+    "GetObjectAttributes":{
 
+      "name":"GetObjectAttributes",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}/{Key+}?attributes"
 
+      },
 
+      "input":{"shape":"GetObjectAttributesRequest"},
 
+      "output":{"shape":"GetObjectAttributesOutput"},
 
+      "errors":[
 
+        {"shape":"NoSuchKey"}
 
+      ],
 
+      
+    },
 
+    "GetObjectLegalHold":{
 
+      "name":"GetObjectLegalHold",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}/{Key+}?legal-hold"
 
+      },
 
+      "input":{"shape":"GetObjectLegalHoldRequest"},
 
+      "output":{"shape":"GetObjectLegalHoldOutput"},
 
+      
+    },
 
+    "GetObjectLockConfiguration":{
 
+      "name":"GetObjectLockConfiguration",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?object-lock"
 
+      },
 
+      "input":{"shape":"GetObjectLockConfigurationRequest"},
 
+      "output":{"shape":"GetObjectLockConfigurationOutput"},
 
+      
+    },
 
+    "GetObjectRetention":{
 
+      "name":"GetObjectRetention",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}/{Key+}?retention"
 
+      },
 
+      "input":{"shape":"GetObjectRetentionRequest"},
 
+      "output":{"shape":"GetObjectRetentionOutput"},
 
+      
+    },
 
+    "GetObjectTagging":{
 
+      "name":"GetObjectTagging",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}/{Key+}?tagging"
 
+      },
 
+      "input":{"shape":"GetObjectTaggingRequest"},
 
+      "output":{"shape":"GetObjectTaggingOutput"},
 
+      
+    },
 
+    "GetObjectTorrent":{
 
+      "name":"GetObjectTorrent",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}/{Key+}?torrent"
 
+      },
 
+      "input":{"shape":"GetObjectTorrentRequest"},
 
+      "output":{"shape":"GetObjectTorrentOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectGETtorrent.html",
 
+      
+    },
 
+    "GetPublicAccessBlock":{
 
+      "name":"GetPublicAccessBlock",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?publicAccessBlock"
 
+      },
 
+      "input":{"shape":"GetPublicAccessBlockRequest"},
 
+      "output":{"shape":"GetPublicAccessBlockOutput"},
 
+      
+    },
 
+    "HeadBucket":{
 
+      "name":"HeadBucket",
 
+      "http":{
 
+        "method":"HEAD",
 
+        "requestUri":"/{Bucket}"
 
+      },
 
+      "input":{"shape":"HeadBucketRequest"},
 
+      "errors":[
 
+        {"shape":"NoSuchBucket"}
 
+      ],
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketHEAD.html",
 
+      
+    },
 
+    "HeadObject":{
 
+      "name":"HeadObject",
 
+      "http":{
 
+        "method":"HEAD",
 
+        "requestUri":"/{Bucket}/{Key+}"
 
+      },
 
+      "input":{"shape":"HeadObjectRequest"},
 
+      "output":{"shape":"HeadObjectOutput"},
 
+      "errors":[
 
+        {"shape":"NoSuchKey"}
 
+      ],
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectHEAD.html",
 
+      
+    },
 
+    "ListBucketAnalyticsConfigurations":{
 
+      "name":"ListBucketAnalyticsConfigurations",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?analytics"
 
+      },
 
+      "input":{"shape":"ListBucketAnalyticsConfigurationsRequest"},
 
+      "output":{"shape":"ListBucketAnalyticsConfigurationsOutput"},
 
+      
+    },
 
+    "ListBucketIntelligentTieringConfigurations":{
 
+      "name":"ListBucketIntelligentTieringConfigurations",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?intelligent-tiering"
 
+      },
 
+      "input":{"shape":"ListBucketIntelligentTieringConfigurationsRequest"},
 
+      "output":{"shape":"ListBucketIntelligentTieringConfigurationsOutput"},
 
+      
+    },
 
+    "ListBucketInventoryConfigurations":{
 
+      "name":"ListBucketInventoryConfigurations",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?inventory"
 
+      },
 
+      "input":{"shape":"ListBucketInventoryConfigurationsRequest"},
 
+      "output":{"shape":"ListBucketInventoryConfigurationsOutput"},
 
+      
+    },
 
+    "ListBucketMetricsConfigurations":{
 
+      "name":"ListBucketMetricsConfigurations",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?metrics"
 
+      },
 
+      "input":{"shape":"ListBucketMetricsConfigurationsRequest"},
 
+      "output":{"shape":"ListBucketMetricsConfigurationsOutput"},
 
+      
+    },
 
+    "ListBuckets":{
 
+      "name":"ListBuckets",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/"
 
+      },
 
+      "output":{"shape":"ListBucketsOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTServiceGET.html",
 
+      
+      "alias":"GetService"
 
+    },
 
+    "ListMultipartUploads":{
 
+      "name":"ListMultipartUploads",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?uploads"
 
+      },
 
+      "input":{"shape":"ListMultipartUploadsRequest"},
 
+      "output":{"shape":"ListMultipartUploadsOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadListMPUpload.html",
 
+      
+    },
 
+    "ListObjectVersions":{
 
+      "name":"ListObjectVersions",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?versions"
 
+      },
 
+      "input":{"shape":"ListObjectVersionsRequest"},
 
+      "output":{"shape":"ListObjectVersionsOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETVersion.html",
 
+      
+      "alias":"GetBucketObjectVersions"
 
+    },
 
+    "ListObjects":{
 
+      "name":"ListObjects",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}"
 
+      },
 
+      "input":{"shape":"ListObjectsRequest"},
 
+      "output":{"shape":"ListObjectsOutput"},
 
+      "errors":[
 
+        {"shape":"NoSuchBucket"}
 
+      ],
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGET.html",
 
+      
+      "alias":"GetBucket"
 
+    },
 
+    "ListObjectsV2":{
 
+      "name":"ListObjectsV2",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}?list-type=2"
 
+      },
 
+      "input":{"shape":"ListObjectsV2Request"},
 
+      "output":{"shape":"ListObjectsV2Output"},
 
+      "errors":[
 
+        {"shape":"NoSuchBucket"}
 
+      ],
 
+      
+    },
 
+    "ListParts":{
 
+      "name":"ListParts",
 
+      "http":{
 
+        "method":"GET",
 
+        "requestUri":"/{Bucket}/{Key+}"
 
+      },
 
+      "input":{"shape":"ListPartsRequest"},
 
+      "output":{"shape":"ListPartsOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadListParts.html",
 
+      
+    },
 
+    "PutBucketAccelerateConfiguration":{
 
+      "name":"PutBucketAccelerateConfiguration",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?accelerate"
 
+      },
 
+      "input":{"shape":"PutBucketAccelerateConfigurationRequest"},
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":false
 
+      }
 
+    },
 
+    "PutBucketAcl":{
 
+      "name":"PutBucketAcl",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?acl"
 
+      },
 
+      "input":{"shape":"PutBucketAclRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTacl.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketAnalyticsConfiguration":{
 
+      "name":"PutBucketAnalyticsConfiguration",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?analytics"
 
+      },
 
+      "input":{"shape":"PutBucketAnalyticsConfigurationRequest"},
 
+      
+    },
 
+    "PutBucketCors":{
 
+      "name":"PutBucketCors",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?cors"
 
+      },
 
+      "input":{"shape":"PutBucketCorsRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTcors.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketEncryption":{
 
+      "name":"PutBucketEncryption",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?encryption"
 
+      },
 
+      "input":{"shape":"PutBucketEncryptionRequest"},
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketIntelligentTieringConfiguration":{
 
+      "name":"PutBucketIntelligentTieringConfiguration",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?intelligent-tiering"
 
+      },
 
+      "input":{"shape":"PutBucketIntelligentTieringConfigurationRequest"},
 
+      
+    },
 
+    "PutBucketInventoryConfiguration":{
 
+      "name":"PutBucketInventoryConfiguration",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?inventory"
 
+      },
 
+      "input":{"shape":"PutBucketInventoryConfigurationRequest"},
 
+      
+    },
 
+    "PutBucketLifecycle":{
 
+      "name":"PutBucketLifecycle",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?lifecycle"
 
+      },
 
+      "input":{"shape":"PutBucketLifecycleRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTlifecycle.html",
 
+      
+      "deprecated":true,
 
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketLifecycleConfiguration":{
 
+      "name":"PutBucketLifecycleConfiguration",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?lifecycle"
 
+      },
 
+      "input":{"shape":"PutBucketLifecycleConfigurationRequest"},
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketLogging":{
 
+      "name":"PutBucketLogging",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?logging"
 
+      },
 
+      "input":{"shape":"PutBucketLoggingRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTlogging.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketMetricsConfiguration":{
 
+      "name":"PutBucketMetricsConfiguration",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?metrics"
 
+      },
 
+      "input":{"shape":"PutBucketMetricsConfigurationRequest"},
 
+      
+    },
 
+    "PutBucketNotification":{
 
+      "name":"PutBucketNotification",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?notification"
 
+      },
 
+      "input":{"shape":"PutBucketNotificationRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTnotification.html",
 
+      
+      "deprecated":true,
 
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketNotificationConfiguration":{
 
+      "name":"PutBucketNotificationConfiguration",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?notification"
 
+      },
 
+      "input":{"shape":"PutBucketNotificationConfigurationRequest"},
 
+      
+    },
 
+    "PutBucketOwnershipControls":{
 
+      "name":"PutBucketOwnershipControls",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?ownershipControls"
 
+      },
 
+      "input":{"shape":"PutBucketOwnershipControlsRequest"},
 
+      
+      "httpChecksum":{"requestChecksumRequired":true}
 
+    },
 
+    "PutBucketPolicy":{
 
+      "name":"PutBucketPolicy",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?policy"
 
+      },
 
+      "input":{"shape":"PutBucketPolicyRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTpolicy.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketReplication":{
 
+      "name":"PutBucketReplication",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?replication"
 
+      },
 
+      "input":{"shape":"PutBucketReplicationRequest"},
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketRequestPayment":{
 
+      "name":"PutBucketRequestPayment",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?requestPayment"
 
+      },
 
+      "input":{"shape":"PutBucketRequestPaymentRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTrequestPaymentPUT.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketTagging":{
 
+      "name":"PutBucketTagging",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?tagging"
 
+      },
 
+      "input":{"shape":"PutBucketTaggingRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTtagging.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketVersioning":{
 
+      "name":"PutBucketVersioning",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?versioning"
 
+      },
 
+      "input":{"shape":"PutBucketVersioningRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTVersioningStatus.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutBucketWebsite":{
 
+      "name":"PutBucketWebsite",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?website"
 
+      },
 
+      "input":{"shape":"PutBucketWebsiteRequest"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTwebsite.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutObject":{
 
+      "name":"PutObject",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}/{Key+}"
 
+      },
 
+      "input":{"shape":"PutObjectRequest"},
 
+      "output":{"shape":"PutObjectOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectPUT.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":false
 
+      }
 
+    },
 
+    "PutObjectAcl":{
 
+      "name":"PutObjectAcl",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}/{Key+}?acl"
 
+      },
 
+      "input":{"shape":"PutObjectAclRequest"},
 
+      "output":{"shape":"PutObjectAclOutput"},
 
+      "errors":[
 
+        {"shape":"NoSuchKey"}
 
+      ],
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectPUTacl.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutObjectLegalHold":{
 
+      "name":"PutObjectLegalHold",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}/{Key+}?legal-hold"
 
+      },
 
+      "input":{"shape":"PutObjectLegalHoldRequest"},
 
+      "output":{"shape":"PutObjectLegalHoldOutput"},
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutObjectLockConfiguration":{
 
+      "name":"PutObjectLockConfiguration",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?object-lock"
 
+      },
 
+      "input":{"shape":"PutObjectLockConfigurationRequest"},
 
+      "output":{"shape":"PutObjectLockConfigurationOutput"},
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutObjectRetention":{
 
+      "name":"PutObjectRetention",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}/{Key+}?retention"
 
+      },
 
+      "input":{"shape":"PutObjectRetentionRequest"},
 
+      "output":{"shape":"PutObjectRetentionOutput"},
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutObjectTagging":{
 
+      "name":"PutObjectTagging",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}/{Key+}?tagging"
 
+      },
 
+      "input":{"shape":"PutObjectTaggingRequest"},
 
+      "output":{"shape":"PutObjectTaggingOutput"},
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "PutPublicAccessBlock":{
 
+      "name":"PutPublicAccessBlock",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}?publicAccessBlock"
 
+      },
 
+      "input":{"shape":"PutPublicAccessBlockRequest"},
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":true
 
+      }
 
+    },
 
+    "RestoreObject":{
 
+      "name":"RestoreObject",
 
+      "http":{
 
+        "method":"POST",
 
+        "requestUri":"/{Bucket}/{Key+}?restore"
 
+      },
 
+      "input":{"shape":"RestoreObjectRequest"},
 
+      "output":{"shape":"RestoreObjectOutput"},
 
+      "errors":[
 
+        {"shape":"ObjectAlreadyInActiveTierError"}
 
+      ],
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectRestore.html",
 
+      
+      "alias":"PostObjectRestore",
 
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":false
 
+      }
 
+    },
 
+    "SelectObjectContent":{
 
+      "name":"SelectObjectContent",
 
+      "http":{
 
+        "method":"POST",
 
+        "requestUri":"/{Bucket}/{Key+}?select&select-type=2"
 
+      },
 
+      "input":{
 
+        "shape":"SelectObjectContentRequest",
 
+        "locationName":"SelectObjectContentRequest",
 
+        "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+      },
 
+      "output":{"shape":"SelectObjectContentOutput"},
 
+      
+    },
 
+    "UploadPart":{
 
+      "name":"UploadPart",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}/{Key+}"
 
+      },
 
+      "input":{"shape":"UploadPartRequest"},
 
+      "output":{"shape":"UploadPartOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadUploadPart.html",
 
+      
+      "httpChecksum":{
 
+        "requestAlgorithmMember":"ChecksumAlgorithm",
 
+        "requestChecksumRequired":false
 
+      }
 
+    },
 
+    "UploadPartCopy":{
 
+      "name":"UploadPartCopy",
 
+      "http":{
 
+        "method":"PUT",
 
+        "requestUri":"/{Bucket}/{Key+}"
 
+      },
 
+      "input":{"shape":"UploadPartCopyRequest"},
 
+      "output":{"shape":"UploadPartCopyOutput"},
 
+      "documentationUrl":"http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html",
 
+      
+    },
 
+    "WriteGetObjectResponse":{
 
+      "name":"WriteGetObjectResponse",
 
+      "http":{
 
+        "method":"POST",
 
+        "requestUri":"/WriteGetObjectResponse"
 
+      },
 
+      "input":{"shape":"WriteGetObjectResponseRequest"},
 
+      
+      "authtype":"v4-unsigned-body",
 
+      "endpoint":{
 
+        "hostPrefix":"{RequestRoute}."
 
+      },
 
+      "staticContextParams":{
 
+        "UseObjectLambdaEndpoint":{"value":true}
 
+      }
 
+    }
 
+  },
 
+  "shapes":{
 
+    "AbortDate":{"type":"timestamp"},
 
+    "AbortIncompleteMultipartUpload":{
 
+      "type":"structure",
 
+      "members":{
 
+        "DaysAfterInitiation":{
 
+          "shape":"DaysAfterInitiation",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "AbortMultipartUploadOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      }
 
+    },
 
+    "AbortMultipartUploadRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key",
 
+        "UploadId"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "UploadId":{
 
+          "shape":"MultipartUploadId",
 
+          
+          "location":"querystring",
 
+          "locationName":"uploadId"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "AbortRuleId":{"type":"string"},
 
+    "AccelerateConfiguration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Status":{
 
+          "shape":"BucketAccelerateStatus",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "AcceptRanges":{"type":"string"},
 
+    "AccessControlPolicy":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Grants":{
 
+          "shape":"Grants",
 
+          
+          "locationName":"AccessControlList"
 
+        },
 
+        "Owner":{
 
+          "shape":"Owner",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "AccessControlTranslation":{
 
+      "type":"structure",
 
+      "required":["Owner"],
 
+      "members":{
 
+        "Owner":{
 
+          "shape":"OwnerOverride",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "AccessPointArn":{"type":"string"},
 
+    "AccountId":{"type":"string"},
 
+    "AllowQuotedRecordDelimiter":{"type":"boolean"},
 
+    "AllowedHeader":{"type":"string"},
 
+    "AllowedHeaders":{
 
+      "type":"list",
 
+      "member":{"shape":"AllowedHeader"},
 
+      "flattened":true
 
+    },
 
+    "AllowedMethod":{"type":"string"},
 
+    "AllowedMethods":{
 
+      "type":"list",
 
+      "member":{"shape":"AllowedMethod"},
 
+      "flattened":true
 
+    },
 
+    "AllowedOrigin":{"type":"string"},
 
+    "AllowedOrigins":{
 
+      "type":"list",
 
+      "member":{"shape":"AllowedOrigin"},
 
+      "flattened":true
 
+    },
 
+    "AnalyticsAndOperator":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Tags":{
 
+          "shape":"TagSet",
 
+          
+          "flattened":true,
 
+          "locationName":"Tag"
 
+        }
 
+      },
 
+      
+    },
 
+    "AnalyticsConfiguration":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Id",
 
+        "StorageClassAnalysis"
 
+      ],
 
+      "members":{
 
+        "Id":{
 
+          "shape":"AnalyticsId",
 
+          
+        },
 
+        "Filter":{
 
+          "shape":"AnalyticsFilter",
 
+          
+        },
 
+        "StorageClassAnalysis":{
 
+          "shape":"StorageClassAnalysis",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "AnalyticsConfigurationList":{
 
+      "type":"list",
 
+      "member":{"shape":"AnalyticsConfiguration"},
 
+      "flattened":true
 
+    },
 
+    "AnalyticsExportDestination":{
 
+      "type":"structure",
 
+      "required":["S3BucketDestination"],
 
+      "members":{
 
+        "S3BucketDestination":{
 
+          "shape":"AnalyticsS3BucketDestination",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "AnalyticsFilter":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Tag":{
 
+          "shape":"Tag",
 
+          
+        },
 
+        "And":{
 
+          "shape":"AnalyticsAndOperator",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "AnalyticsId":{"type":"string"},
 
+    "AnalyticsS3BucketDestination":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Format",
 
+        "Bucket"
 
+      ],
 
+      "members":{
 
+        "Format":{
 
+          "shape":"AnalyticsS3ExportFileFormat",
 
+          
+        },
 
+        "BucketAccountId":{
 
+          "shape":"AccountId",
 
+          
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "AnalyticsS3ExportFileFormat":{
 
+      "type":"string",
 
+      "enum":["CSV"]
 
+    },
 
+    "ArchiveStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "ARCHIVE_ACCESS",
 
+        "DEEP_ARCHIVE_ACCESS"
 
+      ]
 
+    },
 
+    "Body":{"type":"blob"},
 
+    "Bucket":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Name":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "CreationDate":{
 
+          "shape":"CreationDate",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "BucketAccelerateStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Suspended"
 
+      ]
 
+    },
 
+    "BucketAlreadyExists":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+      "exception":true
 
+    },
 
+    "BucketAlreadyOwnedByYou":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+      "exception":true
 
+    },
 
+    "BucketCannedACL":{
 
+      "type":"string",
 
+      "enum":[
 
+        "private",
 
+        "public-read",
 
+        "public-read-write",
 
+        "authenticated-read"
 
+      ]
 
+    },
 
+    "BucketKeyEnabled":{"type":"boolean"},
 
+    "BucketLifecycleConfiguration":{
 
+      "type":"structure",
 
+      "required":["Rules"],
 
+      "members":{
 
+        "Rules":{
 
+          "shape":"LifecycleRules",
 
+          
+          "locationName":"Rule"
 
+        }
 
+      },
 
+      
+    },
 
+    "BucketLocationConstraint":{
 
+      "type":"string",
 
+      "enum":[
 
+        "af-south-1",
 
+        "ap-east-1",
 
+        "ap-northeast-1",
 
+        "ap-northeast-2",
 
+        "ap-northeast-3",
 
+        "ap-south-1",
 
+        "ap-southeast-1",
 
+        "ap-southeast-2",
 
+        "ap-southeast-3",
 
+        "ca-central-1",
 
+        "cn-north-1",
 
+        "cn-northwest-1",
 
+        "EU",
 
+        "eu-central-1",
 
+        "eu-north-1",
 
+        "eu-south-1",
 
+        "eu-west-1",
 
+        "eu-west-2",
 
+        "eu-west-3",
 
+        "me-south-1",
 
+        "sa-east-1",
 
+        "us-east-2",
 
+        "us-gov-east-1",
 
+        "us-gov-west-1",
 
+        "us-west-1",
 
+        "us-west-2"
 
+      ]
 
+    },
 
+    "BucketLoggingStatus":{
 
+      "type":"structure",
 
+      "members":{
 
+        "LoggingEnabled":{"shape":"LoggingEnabled"}
 
+      },
 
+      
+    },
 
+    "BucketLogsPermission":{
 
+      "type":"string",
 
+      "enum":[
 
+        "FULL_CONTROL",
 
+        "READ",
 
+        "WRITE"
 
+      ]
 
+    },
 
+    "BucketName":{"type":"string"},
 
+    "BucketVersioningStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Suspended"
 
+      ]
 
+    },
 
+    "Buckets":{
 
+      "type":"list",
 
+      "member":{
 
+        "shape":"Bucket",
 
+        "locationName":"Bucket"
 
+      }
 
+    },
 
+    "BypassGovernanceRetention":{"type":"boolean"},
 
+    "BytesProcessed":{"type":"long"},
 
+    "BytesReturned":{"type":"long"},
 
+    "BytesScanned":{"type":"long"},
 
+    "CORSConfiguration":{
 
+      "type":"structure",
 
+      "required":["CORSRules"],
 
+      "members":{
 
+        "CORSRules":{
 
+          "shape":"CORSRules",
 
+          
+          "locationName":"CORSRule"
 
+        }
 
+      },
 
+      
+    },
 
+    "CORSRule":{
 
+      "type":"structure",
 
+      "required":[
 
+        "AllowedMethods",
 
+        "AllowedOrigins"
 
+      ],
 
+      "members":{
 
+        "ID":{
 
+          "shape":"ID",
 
+          
+        },
 
+        "AllowedHeaders":{
 
+          "shape":"AllowedHeaders",
 
+          
+          "locationName":"AllowedHeader"
 
+        },
 
+        "AllowedMethods":{
 
+          "shape":"AllowedMethods",
 
+          
+          "locationName":"AllowedMethod"
 
+        },
 
+        "AllowedOrigins":{
 
+          "shape":"AllowedOrigins",
 
+          
+          "locationName":"AllowedOrigin"
 
+        },
 
+        "ExposeHeaders":{
 
+          "shape":"ExposeHeaders",
 
+          
+          "locationName":"ExposeHeader"
 
+        },
 
+        "MaxAgeSeconds":{
 
+          "shape":"MaxAgeSeconds",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "CORSRules":{
 
+      "type":"list",
 
+      "member":{"shape":"CORSRule"},
 
+      "flattened":true
 
+    },
 
+    "CSVInput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "FileHeaderInfo":{
 
+          "shape":"FileHeaderInfo",
 
+          
+        },
 
+        "Comments":{
 
+          "shape":"Comments",
 
+          
+        },
 
+        "QuoteEscapeCharacter":{
 
+          "shape":"QuoteEscapeCharacter",
 
+          
+        },
 
+        "RecordDelimiter":{
 
+          "shape":"RecordDelimiter",
 
+          
+        },
 
+        "FieldDelimiter":{
 
+          "shape":"FieldDelimiter",
 
+          
+        },
 
+        "QuoteCharacter":{
 
+          "shape":"QuoteCharacter",
 
+          
+        },
 
+        "AllowQuotedRecordDelimiter":{
 
+          "shape":"AllowQuotedRecordDelimiter",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "CSVOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "QuoteFields":{
 
+          "shape":"QuoteFields",
 
+          
+        },
 
+        "QuoteEscapeCharacter":{
 
+          "shape":"QuoteEscapeCharacter",
 
+          
+        },
 
+        "RecordDelimiter":{
 
+          "shape":"RecordDelimiter",
 
+          
+        },
 
+        "FieldDelimiter":{
 
+          "shape":"FieldDelimiter",
 
+          
+        },
 
+        "QuoteCharacter":{
 
+          "shape":"QuoteCharacter",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "CacheControl":{"type":"string"},
 
+    "Checksum":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ChecksumAlgorithm":{
 
+      "type":"string",
 
+      "enum":[
 
+        "CRC32",
 
+        "CRC32C",
 
+        "SHA1",
 
+        "SHA256"
 
+      ]
 
+    },
 
+    "ChecksumAlgorithmList":{
 
+      "type":"list",
 
+      "member":{"shape":"ChecksumAlgorithm"},
 
+      "flattened":true
 
+    },
 
+    "ChecksumCRC32":{"type":"string"},
 
+    "ChecksumCRC32C":{"type":"string"},
 
+    "ChecksumMode":{
 
+      "type":"string",
 
+      "enum":["ENABLED"]
 
+    },
 
+    "ChecksumSHA1":{"type":"string"},
 
+    "ChecksumSHA256":{"type":"string"},
 
+    "CloudFunction":{"type":"string"},
 
+    "CloudFunctionConfiguration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Id":{"shape":"NotificationId"},
 
+        "Event":{
 
+          "shape":"Event",
 
+          "deprecated":true
 
+        },
 
+        "Events":{
 
+          "shape":"EventList",
 
+          
+          "locationName":"Event"
 
+        },
 
+        "CloudFunction":{
 
+          "shape":"CloudFunction",
 
+          
+        },
 
+        "InvocationRole":{
 
+          "shape":"CloudFunctionInvocationRole",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "CloudFunctionInvocationRole":{"type":"string"},
 
+    "Code":{"type":"string"},
 
+    "Comments":{"type":"string"},
 
+    "CommonPrefix":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "CommonPrefixList":{
 
+      "type":"list",
 
+      "member":{"shape":"CommonPrefix"},
 
+      "flattened":true
 
+    },
 
+    "CompleteMultipartUploadOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Location":{
 
+          "shape":"Location",
 
+          
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "Expiration":{
 
+          "shape":"Expiration",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expiration"
 
+        },
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-version-id"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      }
 
+    },
 
+    "CompleteMultipartUploadRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key",
 
+        "UploadId"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "MultipartUpload":{
 
+          "shape":"CompletedMultipartUpload",
 
+          
+          "locationName":"CompleteMultipartUpload",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "UploadId":{
 
+          "shape":"MultipartUploadId",
 
+          
+          "location":"querystring",
 
+          "locationName":"uploadId"
 
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32"
 
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32c"
 
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha1"
 
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha256"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        }
 
+      },
 
+      "payload":"MultipartUpload"
 
+    },
 
+    "CompletedMultipartUpload":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Parts":{
 
+          "shape":"CompletedPartList",
 
+          
+          "locationName":"Part"
 
+        }
 
+      },
 
+      
+    },
 
+    "CompletedPart":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+        },
 
+        "PartNumber":{
 
+          "shape":"PartNumber",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "CompletedPartList":{
 
+      "type":"list",
 
+      "member":{"shape":"CompletedPart"},
 
+      "flattened":true
 
+    },
 
+    "CompressionType":{
 
+      "type":"string",
 
+      "enum":[
 
+        "NONE",
 
+        "GZIP",
 
+        "BZIP2"
 
+      ]
 
+    },
 
+    "Condition":{
 
+      "type":"structure",
 
+      "members":{
 
+        "HttpErrorCodeReturnedEquals":{
 
+          "shape":"HttpErrorCodeReturnedEquals",
 
+          
+        },
 
+        "KeyPrefixEquals":{
 
+          "shape":"KeyPrefixEquals",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ConfirmRemoveSelfBucketAccess":{"type":"boolean"},
 
+    "ContentDisposition":{"type":"string"},
 
+    "ContentEncoding":{"type":"string"},
 
+    "ContentLanguage":{"type":"string"},
 
+    "ContentLength":{"type":"long"},
 
+    "ContentMD5":{"type":"string"},
 
+    "ContentRange":{"type":"string"},
 
+    "ContentType":{"type":"string"},
 
+    "ContinuationEvent":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+      "event":true
 
+    },
 
+    "CopyObjectOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "CopyObjectResult":{
 
+          "shape":"CopyObjectResult",
 
+          
+        },
 
+        "Expiration":{
 
+          "shape":"Expiration",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expiration"
 
+        },
 
+        "CopySourceVersionId":{
 
+          "shape":"CopySourceVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-version-id"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-version-id"
 
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "SSEKMSEncryptionContext":{
 
+          "shape":"SSEKMSEncryptionContext",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-context"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      },
 
+      "payload":"CopyObjectResult"
 
+    },
 
+    "CopyObjectRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "CopySource",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "ACL":{
 
+          "shape":"ObjectCannedACL",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-acl"
 
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "CacheControl":{
 
+          "shape":"CacheControl",
 
+          
+          "location":"header",
 
+          "locationName":"Cache-Control"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-algorithm"
 
+        },
 
+        "ContentDisposition":{
 
+          "shape":"ContentDisposition",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Disposition"
 
+        },
 
+        "ContentEncoding":{
 
+          "shape":"ContentEncoding",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Encoding"
 
+        },
 
+        "ContentLanguage":{
 
+          "shape":"ContentLanguage",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Language"
 
+        },
 
+        "ContentType":{
 
+          "shape":"ContentType",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Type"
 
+        },
 
+        "CopySource":{
 
+          "shape":"CopySource",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source"
 
+        },
 
+        "CopySourceIfMatch":{
 
+          "shape":"CopySourceIfMatch",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-if-match"
 
+        },
 
+        "CopySourceIfModifiedSince":{
 
+          "shape":"CopySourceIfModifiedSince",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-if-modified-since"
 
+        },
 
+        "CopySourceIfNoneMatch":{
 
+          "shape":"CopySourceIfNoneMatch",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-if-none-match"
 
+        },
 
+        "CopySourceIfUnmodifiedSince":{
 
+          "shape":"CopySourceIfUnmodifiedSince",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-if-unmodified-since"
 
+        },
 
+        "Expires":{
 
+          "shape":"Expires",
 
+          
+          "location":"header",
 
+          "locationName":"Expires"
 
+        },
 
+        "GrantFullControl":{
 
+          "shape":"GrantFullControl",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-full-control"
 
+        },
 
+        "GrantRead":{
 
+          "shape":"GrantRead",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read"
 
+        },
 
+        "GrantReadACP":{
 
+          "shape":"GrantReadACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read-acp"
 
+        },
 
+        "GrantWriteACP":{
 
+          "shape":"GrantWriteACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-write-acp"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "Metadata":{
 
+          "shape":"Metadata",
 
+          
+          "location":"headers",
 
+          "locationName":"x-amz-meta-"
 
+        },
 
+        "MetadataDirective":{
 
+          "shape":"MetadataDirective",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-metadata-directive"
 
+        },
 
+        "TaggingDirective":{
 
+          "shape":"TaggingDirective",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-tagging-directive"
 
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-storage-class"
 
+        },
 
+        "WebsiteRedirectLocation":{
 
+          "shape":"WebsiteRedirectLocation",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-website-redirect-location"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "SSEKMSEncryptionContext":{
 
+          "shape":"SSEKMSEncryptionContext",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-context"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "CopySourceSSECustomerAlgorithm":{
 
+          "shape":"CopySourceSSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-server-side-encryption-customer-algorithm"
 
+        },
 
+        "CopySourceSSECustomerKey":{
 
+          "shape":"CopySourceSSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-server-side-encryption-customer-key"
 
+        },
 
+        "CopySourceSSECustomerKeyMD5":{
 
+          "shape":"CopySourceSSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "Tagging":{
 
+          "shape":"TaggingHeader",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-tagging"
 
+        },
 
+        "ObjectLockMode":{
 
+          "shape":"ObjectLockMode",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-mode"
 
+        },
 
+        "ObjectLockRetainUntilDate":{
 
+          "shape":"ObjectLockRetainUntilDate",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-retain-until-date"
 
+        },
 
+        "ObjectLockLegalHoldStatus":{
 
+          "shape":"ObjectLockLegalHoldStatus",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-legal-hold"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "ExpectedSourceBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-source-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "CopyObjectResult":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+        },
 
+        "LastModified":{
 
+          "shape":"LastModified",
 
+          
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "CopyPartResult":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+        },
 
+        "LastModified":{
 
+          "shape":"LastModified",
 
+          
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "CopySource":{
 
+      "type":"string",
 
+      "pattern":"\\/.+\\/.+"
 
+    },
 
+    "CopySourceIfMatch":{"type":"string"},
 
+    "CopySourceIfModifiedSince":{"type":"timestamp"},
 
+    "CopySourceIfNoneMatch":{"type":"string"},
 
+    "CopySourceIfUnmodifiedSince":{"type":"timestamp"},
 
+    "CopySourceRange":{"type":"string"},
 
+    "CopySourceSSECustomerAlgorithm":{"type":"string"},
 
+    "CopySourceSSECustomerKey":{
 
+      "type":"string",
 
+      "sensitive":true
 
+    },
 
+    "CopySourceSSECustomerKeyMD5":{"type":"string"},
 
+    "CopySourceVersionId":{"type":"string"},
 
+    "CreateBucketConfiguration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "LocationConstraint":{
 
+          "shape":"BucketLocationConstraint",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "CreateBucketOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Location":{
 
+          "shape":"Location",
 
+          
+          "location":"header",
 
+          "locationName":"Location"
 
+        }
 
+      }
 
+    },
 
+    "CreateBucketRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "ACL":{
 
+          "shape":"BucketCannedACL",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-acl"
 
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "CreateBucketConfiguration":{
 
+          "shape":"CreateBucketConfiguration",
 
+          
+          "locationName":"CreateBucketConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "GrantFullControl":{
 
+          "shape":"GrantFullControl",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-full-control"
 
+        },
 
+        "GrantRead":{
 
+          "shape":"GrantRead",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read"
 
+        },
 
+        "GrantReadACP":{
 
+          "shape":"GrantReadACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read-acp"
 
+        },
 
+        "GrantWrite":{
 
+          "shape":"GrantWrite",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-write"
 
+        },
 
+        "GrantWriteACP":{
 
+          "shape":"GrantWriteACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-write-acp"
 
+        },
 
+        "ObjectLockEnabledForBucket":{
 
+          "shape":"ObjectLockEnabledForBucket",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-bucket-object-lock-enabled"
 
+        },
 
+        "ObjectOwnership":{
 
+          "shape":"ObjectOwnership",
 
+          "location":"header",
 
+          "locationName":"x-amz-object-ownership"
 
+        }
 
+      },
 
+      "payload":"CreateBucketConfiguration"
 
+    },
 
+    "CreateMultipartUploadOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "AbortDate":{
 
+          "shape":"AbortDate",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-abort-date"
 
+        },
 
+        "AbortRuleId":{
 
+          "shape":"AbortRuleId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-abort-rule-id"
 
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "UploadId":{
 
+          "shape":"MultipartUploadId",
 
+          
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "SSEKMSEncryptionContext":{
 
+          "shape":"SSEKMSEncryptionContext",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-context"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-algorithm"
 
+        }
 
+      }
 
+    },
 
+    "CreateMultipartUploadRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "ACL":{
 
+          "shape":"ObjectCannedACL",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-acl"
 
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "CacheControl":{
 
+          "shape":"CacheControl",
 
+          
+          "location":"header",
 
+          "locationName":"Cache-Control"
 
+        },
 
+        "ContentDisposition":{
 
+          "shape":"ContentDisposition",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Disposition"
 
+        },
 
+        "ContentEncoding":{
 
+          "shape":"ContentEncoding",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Encoding"
 
+        },
 
+        "ContentLanguage":{
 
+          "shape":"ContentLanguage",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Language"
 
+        },
 
+        "ContentType":{
 
+          "shape":"ContentType",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Type"
 
+        },
 
+        "Expires":{
 
+          "shape":"Expires",
 
+          
+          "location":"header",
 
+          "locationName":"Expires"
 
+        },
 
+        "GrantFullControl":{
 
+          "shape":"GrantFullControl",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-full-control"
 
+        },
 
+        "GrantRead":{
 
+          "shape":"GrantRead",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read"
 
+        },
 
+        "GrantReadACP":{
 
+          "shape":"GrantReadACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read-acp"
 
+        },
 
+        "GrantWriteACP":{
 
+          "shape":"GrantWriteACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-write-acp"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "Metadata":{
 
+          "shape":"Metadata",
 
+          
+          "location":"headers",
 
+          "locationName":"x-amz-meta-"
 
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-storage-class"
 
+        },
 
+        "WebsiteRedirectLocation":{
 
+          "shape":"WebsiteRedirectLocation",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-website-redirect-location"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "SSEKMSEncryptionContext":{
 
+          "shape":"SSEKMSEncryptionContext",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-context"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "Tagging":{
 
+          "shape":"TaggingHeader",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-tagging"
 
+        },
 
+        "ObjectLockMode":{
 
+          "shape":"ObjectLockMode",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-mode"
 
+        },
 
+        "ObjectLockRetainUntilDate":{
 
+          "shape":"ObjectLockRetainUntilDate",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-retain-until-date"
 
+        },
 
+        "ObjectLockLegalHoldStatus":{
 
+          "shape":"ObjectLockLegalHoldStatus",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-legal-hold"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-algorithm"
 
+        }
 
+      }
 
+    },
 
+    "CreationDate":{"type":"timestamp"},
 
+    "Date":{
 
+      "type":"timestamp",
 
+      "timestampFormat":"iso8601"
 
+    },
 
+    "Days":{"type":"integer"},
 
+    "DaysAfterInitiation":{"type":"integer"},
 
+    "DefaultRetention":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Mode":{
 
+          "shape":"ObjectLockRetentionMode",
 
+          
+        },
 
+        "Days":{
 
+          "shape":"Days",
 
+          
+        },
 
+        "Years":{
 
+          "shape":"Years",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "Delete":{
 
+      "type":"structure",
 
+      "required":["Objects"],
 
+      "members":{
 
+        "Objects":{
 
+          "shape":"ObjectIdentifierList",
 
+          
+          "locationName":"Object"
 
+        },
 
+        "Quiet":{
 
+          "shape":"Quiet",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "DeleteBucketAnalyticsConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"AnalyticsId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketCorsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketEncryptionRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketIntelligentTieringConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"IntelligentTieringId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketInventoryConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"InventoryId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketLifecycleRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketMetricsConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"MetricsId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketOwnershipControlsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketPolicyRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketReplicationRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketTaggingRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteBucketWebsiteRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteMarker":{"type":"boolean"},
 
+    "DeleteMarkerEntry":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Owner":{
 
+          "shape":"Owner",
 
+          
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+        },
 
+        "IsLatest":{
 
+          "shape":"IsLatest",
 
+          
+        },
 
+        "LastModified":{
 
+          "shape":"LastModified",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "DeleteMarkerReplication":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Status":{
 
+          "shape":"DeleteMarkerReplicationStatus",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "DeleteMarkerReplicationStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "DeleteMarkerVersionId":{"type":"string"},
 
+    "DeleteMarkers":{
 
+      "type":"list",
 
+      "member":{"shape":"DeleteMarkerEntry"},
 
+      "flattened":true
 
+    },
 
+    "DeleteObjectOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "DeleteMarker":{
 
+          "shape":"DeleteMarker",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-delete-marker"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-version-id"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      }
 
+    },
 
+    "DeleteObjectRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "MFA":{
 
+          "shape":"MFA",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-mfa"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "BypassGovernanceRetention":{
 
+          "shape":"BypassGovernanceRetention",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-bypass-governance-retention"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteObjectTaggingOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-version-id"
 
+        }
 
+      }
 
+    },
 
+    "DeleteObjectTaggingRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeleteObjectsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Deleted":{
 
+          "shape":"DeletedObjects",
 
+          
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        },
 
+        "Errors":{
 
+          "shape":"Errors",
 
+          
+          "locationName":"Error"
 
+        }
 
+      }
 
+    },
 
+    "DeleteObjectsRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Delete"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Delete":{
 
+          "shape":"Delete",
 
+          
+          "locationName":"Delete",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "MFA":{
 
+          "shape":"MFA",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-mfa"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "BypassGovernanceRetention":{
 
+          "shape":"BypassGovernanceRetention",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-bypass-governance-retention"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        }
 
+      },
 
+      "payload":"Delete"
 
+    },
 
+    "DeletePublicAccessBlockRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "DeletedObject":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+        },
 
+        "DeleteMarker":{
 
+          "shape":"DeleteMarker",
 
+          
+        },
 
+        "DeleteMarkerVersionId":{
 
+          "shape":"DeleteMarkerVersionId",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "DeletedObjects":{
 
+      "type":"list",
 
+      "member":{"shape":"DeletedObject"},
 
+      "flattened":true
 
+    },
 
+    "Delimiter":{"type":"string"},
 
+    "Description":{"type":"string"},
 
+    "Destination":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "Account":{
 
+          "shape":"AccountId",
 
+          
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+        },
 
+        "AccessControlTranslation":{
 
+          "shape":"AccessControlTranslation",
 
+          
+        },
 
+        "EncryptionConfiguration":{
 
+          "shape":"EncryptionConfiguration",
 
+          
+        },
 
+        "ReplicationTime":{
 
+          "shape":"ReplicationTime",
 
+          
+        },
 
+        "Metrics":{
 
+          "shape":"Metrics",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "DisplayName":{"type":"string"},
 
+    "ETag":{"type":"string"},
 
+    "EmailAddress":{"type":"string"},
 
+    "EnableRequestProgress":{"type":"boolean"},
 
+    "EncodingType":{
 
+      "type":"string",
 
+      
+      "enum":["url"]
 
+    },
 
+    "Encryption":{
 
+      "type":"structure",
 
+      "required":["EncryptionType"],
 
+      "members":{
 
+        "EncryptionType":{
 
+          "shape":"ServerSideEncryption",
 
+          
+        },
 
+        "KMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+        },
 
+        "KMSContext":{
 
+          "shape":"KMSContext",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "EncryptionConfiguration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ReplicaKmsKeyID":{
 
+          "shape":"ReplicaKmsKeyID",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "End":{"type":"long"},
 
+    "EndEvent":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+      "event":true
 
+    },
 
+    "Error":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+        },
 
+        "Code":{
 
+          "shape":"Code",
 
+          
+        },
 
+        "Message":{
 
+          "shape":"Message",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ErrorCode":{"type":"string"},
 
+    "ErrorDocument":{
 
+      "type":"structure",
 
+      "required":["Key"],
 
+      "members":{
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ErrorMessage":{"type":"string"},
 
+    "Errors":{
 
+      "type":"list",
 
+      "member":{"shape":"Error"},
 
+      "flattened":true
 
+    },
 
+    "Event":{
 
+      "type":"string",
 
+      
+      "enum":[
 
+        "s3:ReducedRedundancyLostObject",
 
+        "s3:ObjectCreated:*",
 
+        "s3:ObjectCreated:Put",
 
+        "s3:ObjectCreated:Post",
 
+        "s3:ObjectCreated:Copy",
 
+        "s3:ObjectCreated:CompleteMultipartUpload",
 
+        "s3:ObjectRemoved:*",
 
+        "s3:ObjectRemoved:Delete",
 
+        "s3:ObjectRemoved:DeleteMarkerCreated",
 
+        "s3:ObjectRestore:*",
 
+        "s3:ObjectRestore:Post",
 
+        "s3:ObjectRestore:Completed",
 
+        "s3:Replication:*",
 
+        "s3:Replication:OperationFailedReplication",
 
+        "s3:Replication:OperationNotTracked",
 
+        "s3:Replication:OperationMissedThreshold",
 
+        "s3:Replication:OperationReplicatedAfterThreshold",
 
+        "s3:ObjectRestore:Delete",
 
+        "s3:LifecycleTransition",
 
+        "s3:IntelligentTiering",
 
+        "s3:ObjectAcl:Put",
 
+        "s3:LifecycleExpiration:*",
 
+        "s3:LifecycleExpiration:Delete",
 
+        "s3:LifecycleExpiration:DeleteMarkerCreated",
 
+        "s3:ObjectTagging:*",
 
+        "s3:ObjectTagging:Put",
 
+        "s3:ObjectTagging:Delete"
 
+      ]
 
+    },
 
+    "EventBridgeConfiguration":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+    },
 
+    "EventList":{
 
+      "type":"list",
 
+      "member":{"shape":"Event"},
 
+      "flattened":true
 
+    },
 
+    "ExistingObjectReplication":{
 
+      "type":"structure",
 
+      "required":["Status"],
 
+      "members":{
 
+        "Status":{
 
+          "shape":"ExistingObjectReplicationStatus",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ExistingObjectReplicationStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "Expiration":{"type":"string"},
 
+    "ExpirationStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "ExpiredObjectDeleteMarker":{"type":"boolean"},
 
+    "Expires":{"type":"timestamp"},
 
+    "ExposeHeader":{"type":"string"},
 
+    "ExposeHeaders":{
 
+      "type":"list",
 
+      "member":{"shape":"ExposeHeader"},
 
+      "flattened":true
 
+    },
 
+    "Expression":{"type":"string"},
 
+    "ExpressionType":{
 
+      "type":"string",
 
+      "enum":["SQL"]
 
+    },
 
+    "FetchOwner":{"type":"boolean"},
 
+    "FieldDelimiter":{"type":"string"},
 
+    "FileHeaderInfo":{
 
+      "type":"string",
 
+      "enum":[
 
+        "USE",
 
+        "IGNORE",
 
+        "NONE"
 
+      ]
 
+    },
 
+    "FilterRule":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Name":{
 
+          "shape":"FilterRuleName",
 
+          
+        },
 
+        "Value":{
 
+          "shape":"FilterRuleValue",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "FilterRuleList":{
 
+      "type":"list",
 
+      "member":{"shape":"FilterRule"},
 
+      
+      "flattened":true
 
+    },
 
+    "FilterRuleName":{
 
+      "type":"string",
 
+      "enum":[
 
+        "prefix",
 
+        "suffix"
 
+      ]
 
+    },
 
+    "FilterRuleValue":{"type":"string"},
 
+    "GetBucketAccelerateConfigurationOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Status":{
 
+          "shape":"BucketAccelerateStatus",
 
+          
+        }
 
+      }
 
+    },
 
+    "GetBucketAccelerateConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketAclOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Owner":{
 
+          "shape":"Owner",
 
+          
+        },
 
+        "Grants":{
 
+          "shape":"Grants",
 
+          
+          "locationName":"AccessControlList"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketAclRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketAnalyticsConfigurationOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "AnalyticsConfiguration":{
 
+          "shape":"AnalyticsConfiguration",
 
+          
+        }
 
+      },
 
+      "payload":"AnalyticsConfiguration"
 
+    },
 
+    "GetBucketAnalyticsConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"AnalyticsId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketCorsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "CORSRules":{
 
+          "shape":"CORSRules",
 
+          
+          "locationName":"CORSRule"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketCorsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketEncryptionOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ServerSideEncryptionConfiguration":{"shape":"ServerSideEncryptionConfiguration"}
 
+      },
 
+      "payload":"ServerSideEncryptionConfiguration"
 
+    },
 
+    "GetBucketEncryptionRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketIntelligentTieringConfigurationOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "IntelligentTieringConfiguration":{
 
+          "shape":"IntelligentTieringConfiguration",
 
+          
+        }
 
+      },
 
+      "payload":"IntelligentTieringConfiguration"
 
+    },
 
+    "GetBucketIntelligentTieringConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"IntelligentTieringId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketInventoryConfigurationOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "InventoryConfiguration":{
 
+          "shape":"InventoryConfiguration",
 
+          
+        }
 
+      },
 
+      "payload":"InventoryConfiguration"
 
+    },
 
+    "GetBucketInventoryConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"InventoryId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketLifecycleConfigurationOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Rules":{
 
+          "shape":"LifecycleRules",
 
+          
+          "locationName":"Rule"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketLifecycleConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketLifecycleOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Rules":{
 
+          "shape":"Rules",
 
+          
+          "locationName":"Rule"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketLifecycleRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketLocationOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "LocationConstraint":{
 
+          "shape":"BucketLocationConstraint",
 
+          
+        }
 
+      }
 
+    },
 
+    "GetBucketLocationRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketLoggingOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "LoggingEnabled":{"shape":"LoggingEnabled"}
 
+      }
 
+    },
 
+    "GetBucketLoggingRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketMetricsConfigurationOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "MetricsConfiguration":{
 
+          "shape":"MetricsConfiguration",
 
+          
+        }
 
+      },
 
+      "payload":"MetricsConfiguration"
 
+    },
 
+    "GetBucketMetricsConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"MetricsId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketNotificationConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketOwnershipControlsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "OwnershipControls":{
 
+          "shape":"OwnershipControls",
 
+          
+        }
 
+      },
 
+      "payload":"OwnershipControls"
 
+    },
 
+    "GetBucketOwnershipControlsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketPolicyOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Policy":{
 
+          "shape":"Policy",
 
+          
+        }
 
+      },
 
+      "payload":"Policy"
 
+    },
 
+    "GetBucketPolicyRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketPolicyStatusOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "PolicyStatus":{
 
+          "shape":"PolicyStatus",
 
+          
+        }
 
+      },
 
+      "payload":"PolicyStatus"
 
+    },
 
+    "GetBucketPolicyStatusRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketReplicationOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ReplicationConfiguration":{"shape":"ReplicationConfiguration"}
 
+      },
 
+      "payload":"ReplicationConfiguration"
 
+    },
 
+    "GetBucketReplicationRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketRequestPaymentOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Payer":{
 
+          "shape":"Payer",
 
+          
+        }
 
+      }
 
+    },
 
+    "GetBucketRequestPaymentRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketTaggingOutput":{
 
+      "type":"structure",
 
+      "required":["TagSet"],
 
+      "members":{
 
+        "TagSet":{
 
+          "shape":"TagSet",
 
+          
+        }
 
+      }
 
+    },
 
+    "GetBucketTaggingRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketVersioningOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Status":{
 
+          "shape":"BucketVersioningStatus",
 
+          
+        },
 
+        "MFADelete":{
 
+          "shape":"MFADeleteStatus",
 
+          
+          "locationName":"MfaDelete"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketVersioningRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetBucketWebsiteOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "RedirectAllRequestsTo":{
 
+          "shape":"RedirectAllRequestsTo",
 
+          
+        },
 
+        "IndexDocument":{
 
+          "shape":"IndexDocument",
 
+          
+        },
 
+        "ErrorDocument":{
 
+          "shape":"ErrorDocument",
 
+          
+        },
 
+        "RoutingRules":{
 
+          "shape":"RoutingRules",
 
+          
+        }
 
+      }
 
+    },
 
+    "GetBucketWebsiteRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetObjectAclOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Owner":{
 
+          "shape":"Owner",
 
+          
+        },
 
+        "Grants":{
 
+          "shape":"Grants",
 
+          
+          "locationName":"AccessControlList"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      }
 
+    },
 
+    "GetObjectAclRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetObjectAttributesOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "DeleteMarker":{
 
+          "shape":"DeleteMarker",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-delete-marker"
 
+        },
 
+        "LastModified":{
 
+          "shape":"LastModified",
 
+          
+          "location":"header",
 
+          "locationName":"Last-Modified"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-version-id"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        },
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+        },
 
+        "Checksum":{
 
+          "shape":"Checksum",
 
+          
+        },
 
+        "ObjectParts":{
 
+          "shape":"GetObjectAttributesParts",
 
+          
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+        },
 
+        "ObjectSize":{
 
+          "shape":"ObjectSize",
 
+          
+        }
 
+      }
 
+    },
 
+    "GetObjectAttributesParts":{
 
+      "type":"structure",
 
+      "members":{
 
+        "TotalPartsCount":{
 
+          "shape":"PartsCount",
 
+          
+          "locationName":"PartsCount"
 
+        },
 
+        "PartNumberMarker":{
 
+          "shape":"PartNumberMarker",
 
+          
+        },
 
+        "NextPartNumberMarker":{
 
+          "shape":"NextPartNumberMarker",
 
+          
+        },
 
+        "MaxParts":{
 
+          "shape":"MaxParts",
 
+          
+        },
 
+        "IsTruncated":{
 
+          "shape":"IsTruncated",
 
+          
+        },
 
+        "Parts":{
 
+          "shape":"PartsList",
 
+          
+          "locationName":"Part"
 
+        }
 
+      },
 
+      
+    },
 
+    "GetObjectAttributesRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key",
 
+        "ObjectAttributes"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "MaxParts":{
 
+          "shape":"MaxParts",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-max-parts"
 
+        },
 
+        "PartNumberMarker":{
 
+          "shape":"PartNumberMarker",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-part-number-marker"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "ObjectAttributes":{
 
+          "shape":"ObjectAttributesList",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-attributes"
 
+        }
 
+      }
 
+    },
 
+    "GetObjectLegalHoldOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "LegalHold":{
 
+          "shape":"ObjectLockLegalHold",
 
+          
+        }
 
+      },
 
+      "payload":"LegalHold"
 
+    },
 
+    "GetObjectLegalHoldRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetObjectLockConfigurationOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ObjectLockConfiguration":{
 
+          "shape":"ObjectLockConfiguration",
 
+          
+        }
 
+      },
 
+      "payload":"ObjectLockConfiguration"
 
+    },
 
+    "GetObjectLockConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetObjectOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Body":{
 
+          "shape":"Body",
 
+          
+          "streaming":true
 
+        },
 
+        "DeleteMarker":{
 
+          "shape":"DeleteMarker",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-delete-marker"
 
+        },
 
+        "AcceptRanges":{
 
+          "shape":"AcceptRanges",
 
+          
+          "location":"header",
 
+          "locationName":"accept-ranges"
 
+        },
 
+        "Expiration":{
 
+          "shape":"Expiration",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expiration"
 
+        },
 
+        "Restore":{
 
+          "shape":"Restore",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-restore"
 
+        },
 
+        "LastModified":{
 
+          "shape":"LastModified",
 
+          
+          "location":"header",
 
+          "locationName":"Last-Modified"
 
+        },
 
+        "ContentLength":{
 
+          "shape":"ContentLength",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Length"
 
+        },
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+          "location":"header",
 
+          "locationName":"ETag"
 
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32"
 
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32c"
 
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha1"
 
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha256"
 
+        },
 
+        "MissingMeta":{
 
+          "shape":"MissingMeta",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-missing-meta"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-version-id"
 
+        },
 
+        "CacheControl":{
 
+          "shape":"CacheControl",
 
+          
+          "location":"header",
 
+          "locationName":"Cache-Control"
 
+        },
 
+        "ContentDisposition":{
 
+          "shape":"ContentDisposition",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Disposition"
 
+        },
 
+        "ContentEncoding":{
 
+          "shape":"ContentEncoding",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Encoding"
 
+        },
 
+        "ContentLanguage":{
 
+          "shape":"ContentLanguage",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Language"
 
+        },
 
+        "ContentRange":{
 
+          "shape":"ContentRange",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Range"
 
+        },
 
+        "ContentType":{
 
+          "shape":"ContentType",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Type"
 
+        },
 
+        "Expires":{
 
+          "shape":"Expires",
 
+          
+          "location":"header",
 
+          "locationName":"Expires"
 
+        },
 
+        "WebsiteRedirectLocation":{
 
+          "shape":"WebsiteRedirectLocation",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-website-redirect-location"
 
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "Metadata":{
 
+          "shape":"Metadata",
 
+          
+          "location":"headers",
 
+          "locationName":"x-amz-meta-"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-storage-class"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        },
 
+        "ReplicationStatus":{
 
+          "shape":"ReplicationStatus",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-replication-status"
 
+        },
 
+        "PartsCount":{
 
+          "shape":"PartsCount",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-mp-parts-count"
 
+        },
 
+        "TagCount":{
 
+          "shape":"TagCount",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-tagging-count"
 
+        },
 
+        "ObjectLockMode":{
 
+          "shape":"ObjectLockMode",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-mode"
 
+        },
 
+        "ObjectLockRetainUntilDate":{
 
+          "shape":"ObjectLockRetainUntilDate",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-retain-until-date"
 
+        },
 
+        "ObjectLockLegalHoldStatus":{
 
+          "shape":"ObjectLockLegalHoldStatus",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-legal-hold"
 
+        }
 
+      },
 
+      "payload":"Body"
 
+    },
 
+    "GetObjectRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "IfMatch":{
 
+          "shape":"IfMatch",
 
+          
+          "location":"header",
 
+          "locationName":"If-Match"
 
+        },
 
+        "IfModifiedSince":{
 
+          "shape":"IfModifiedSince",
 
+          
+          "location":"header",
 
+          "locationName":"If-Modified-Since"
 
+        },
 
+        "IfNoneMatch":{
 
+          "shape":"IfNoneMatch",
 
+          
+          "location":"header",
 
+          "locationName":"If-None-Match"
 
+        },
 
+        "IfUnmodifiedSince":{
 
+          "shape":"IfUnmodifiedSince",
 
+          
+          "location":"header",
 
+          "locationName":"If-Unmodified-Since"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "Range":{
 
+          "shape":"Range",
 
+          
+          "location":"header",
 
+          "locationName":"Range"
 
+        },
 
+        "ResponseCacheControl":{
 
+          "shape":"ResponseCacheControl",
 
+          
+          "location":"querystring",
 
+          "locationName":"response-cache-control"
 
+        },
 
+        "ResponseContentDisposition":{
 
+          "shape":"ResponseContentDisposition",
 
+          
+          "location":"querystring",
 
+          "locationName":"response-content-disposition"
 
+        },
 
+        "ResponseContentEncoding":{
 
+          "shape":"ResponseContentEncoding",
 
+          
+          "location":"querystring",
 
+          "locationName":"response-content-encoding"
 
+        },
 
+        "ResponseContentLanguage":{
 
+          "shape":"ResponseContentLanguage",
 
+          
+          "location":"querystring",
 
+          "locationName":"response-content-language"
 
+        },
 
+        "ResponseContentType":{
 
+          "shape":"ResponseContentType",
 
+          
+          "location":"querystring",
 
+          "locationName":"response-content-type"
 
+        },
 
+        "ResponseExpires":{
 
+          "shape":"ResponseExpires",
 
+          
+          "location":"querystring",
 
+          "locationName":"response-expires"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "PartNumber":{
 
+          "shape":"PartNumber",
 
+          
+          "location":"querystring",
 
+          "locationName":"partNumber"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "ChecksumMode":{
 
+          "shape":"ChecksumMode",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-mode"
 
+        }
 
+      }
 
+    },
 
+    "GetObjectResponseStatusCode":{"type":"integer"},
 
+    "GetObjectRetentionOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Retention":{
 
+          "shape":"ObjectLockRetention",
 
+          
+        }
 
+      },
 
+      "payload":"Retention"
 
+    },
 
+    "GetObjectRetentionRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetObjectTaggingOutput":{
 
+      "type":"structure",
 
+      "required":["TagSet"],
 
+      "members":{
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-version-id"
 
+        },
 
+        "TagSet":{
 
+          "shape":"TagSet",
 
+          
+        }
 
+      }
 
+    },
 
+    "GetObjectTaggingRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        }
 
+      }
 
+    },
 
+    "GetObjectTorrentOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Body":{
 
+          "shape":"Body",
 
+          
+          "streaming":true
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      },
 
+      "payload":"Body"
 
+    },
 
+    "GetObjectTorrentRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GetPublicAccessBlockOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "PublicAccessBlockConfiguration":{
 
+          "shape":"PublicAccessBlockConfiguration",
 
+          
+        }
 
+      },
 
+      "payload":"PublicAccessBlockConfiguration"
 
+    },
 
+    "GetPublicAccessBlockRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "GlacierJobParameters":{
 
+      "type":"structure",
 
+      "required":["Tier"],
 
+      "members":{
 
+        "Tier":{
 
+          "shape":"Tier",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "Grant":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Grantee":{
 
+          "shape":"Grantee",
 
+          
+        },
 
+        "Permission":{
 
+          "shape":"Permission",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "GrantFullControl":{"type":"string"},
 
+    "GrantRead":{"type":"string"},
 
+    "GrantReadACP":{"type":"string"},
 
+    "GrantWrite":{"type":"string"},
 
+    "GrantWriteACP":{"type":"string"},
 
+    "Grantee":{
 
+      "type":"structure",
 
+      "required":["Type"],
 
+      "members":{
 
+        "DisplayName":{
 
+          "shape":"DisplayName",
 
+          
+        },
 
+        "EmailAddress":{
 
+          "shape":"EmailAddress",
 
+          
+        },
 
+        "ID":{
 
+          "shape":"ID",
 
+          
+        },
 
+        "Type":{
 
+          "shape":"Type",
 
+          
+          "locationName":"xsi:type",
 
+          "xmlAttribute":true
 
+        },
 
+        "URI":{
 
+          "shape":"URI",
 
+          
+        }
 
+      },
 
+      
+      "xmlNamespace":{
 
+        "prefix":"xsi",
 
+        "uri":"http://www.w3.org/2001/XMLSchema-instance"
 
+      }
 
+    },
 
+    "Grants":{
 
+      "type":"list",
 
+      "member":{
 
+        "shape":"Grant",
 
+        "locationName":"Grant"
 
+      }
 
+    },
 
+    "HeadBucketRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "HeadObjectOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "DeleteMarker":{
 
+          "shape":"DeleteMarker",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-delete-marker"
 
+        },
 
+        "AcceptRanges":{
 
+          "shape":"AcceptRanges",
 
+          
+          "location":"header",
 
+          "locationName":"accept-ranges"
 
+        },
 
+        "Expiration":{
 
+          "shape":"Expiration",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expiration"
 
+        },
 
+        "Restore":{
 
+          "shape":"Restore",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-restore"
 
+        },
 
+        "ArchiveStatus":{
 
+          "shape":"ArchiveStatus",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-archive-status"
 
+        },
 
+        "LastModified":{
 
+          "shape":"LastModified",
 
+          
+          "location":"header",
 
+          "locationName":"Last-Modified"
 
+        },
 
+        "ContentLength":{
 
+          "shape":"ContentLength",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Length"
 
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32"
 
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32c"
 
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha1"
 
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha256"
 
+        },
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+          "location":"header",
 
+          "locationName":"ETag"
 
+        },
 
+        "MissingMeta":{
 
+          "shape":"MissingMeta",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-missing-meta"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-version-id"
 
+        },
 
+        "CacheControl":{
 
+          "shape":"CacheControl",
 
+          
+          "location":"header",
 
+          "locationName":"Cache-Control"
 
+        },
 
+        "ContentDisposition":{
 
+          "shape":"ContentDisposition",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Disposition"
 
+        },
 
+        "ContentEncoding":{
 
+          "shape":"ContentEncoding",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Encoding"
 
+        },
 
+        "ContentLanguage":{
 
+          "shape":"ContentLanguage",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Language"
 
+        },
 
+        "ContentType":{
 
+          "shape":"ContentType",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Type"
 
+        },
 
+        "Expires":{
 
+          "shape":"Expires",
 
+          
+          "location":"header",
 
+          "locationName":"Expires"
 
+        },
 
+        "WebsiteRedirectLocation":{
 
+          "shape":"WebsiteRedirectLocation",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-website-redirect-location"
 
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "Metadata":{
 
+          "shape":"Metadata",
 
+          
+          "location":"headers",
 
+          "locationName":"x-amz-meta-"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-storage-class"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        },
 
+        "ReplicationStatus":{
 
+          "shape":"ReplicationStatus",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-replication-status"
 
+        },
 
+        "PartsCount":{
 
+          "shape":"PartsCount",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-mp-parts-count"
 
+        },
 
+        "ObjectLockMode":{
 
+          "shape":"ObjectLockMode",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-mode"
 
+        },
 
+        "ObjectLockRetainUntilDate":{
 
+          "shape":"ObjectLockRetainUntilDate",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-retain-until-date"
 
+        },
 
+        "ObjectLockLegalHoldStatus":{
 
+          "shape":"ObjectLockLegalHoldStatus",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-legal-hold"
 
+        }
 
+      }
 
+    },
 
+    "HeadObjectRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "IfMatch":{
 
+          "shape":"IfMatch",
 
+          
+          "location":"header",
 
+          "locationName":"If-Match"
 
+        },
 
+        "IfModifiedSince":{
 
+          "shape":"IfModifiedSince",
 
+          
+          "location":"header",
 
+          "locationName":"If-Modified-Since"
 
+        },
 
+        "IfNoneMatch":{
 
+          "shape":"IfNoneMatch",
 
+          
+          "location":"header",
 
+          "locationName":"If-None-Match"
 
+        },
 
+        "IfUnmodifiedSince":{
 
+          "shape":"IfUnmodifiedSince",
 
+          
+          "location":"header",
 
+          "locationName":"If-Unmodified-Since"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "Range":{
 
+          "shape":"Range",
 
+          
+          "location":"header",
 
+          "locationName":"Range"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "PartNumber":{
 
+          "shape":"PartNumber",
 
+          
+          "location":"querystring",
 
+          "locationName":"partNumber"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "ChecksumMode":{
 
+          "shape":"ChecksumMode",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-mode"
 
+        }
 
+      }
 
+    },
 
+    "HostName":{"type":"string"},
 
+    "HttpErrorCodeReturnedEquals":{"type":"string"},
 
+    "HttpRedirectCode":{"type":"string"},
 
+    "ID":{"type":"string"},
 
+    "IfMatch":{"type":"string"},
 
+    "IfModifiedSince":{"type":"timestamp"},
 
+    "IfNoneMatch":{"type":"string"},
 
+    "IfUnmodifiedSince":{"type":"timestamp"},
 
+    "IndexDocument":{
 
+      "type":"structure",
 
+      "required":["Suffix"],
 
+      "members":{
 
+        "Suffix":{
 
+          "shape":"Suffix",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "Initiated":{"type":"timestamp"},
 
+    "Initiator":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ID":{
 
+          "shape":"ID",
 
+          
+        },
 
+        "DisplayName":{
 
+          "shape":"DisplayName",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "InputSerialization":{
 
+      "type":"structure",
 
+      "members":{
 
+        "CSV":{
 
+          "shape":"CSVInput",
 
+          
+        },
 
+        "CompressionType":{
 
+          "shape":"CompressionType",
 
+          
+        },
 
+        "JSON":{
 
+          "shape":"JSONInput",
 
+          
+        },
 
+        "Parquet":{
 
+          "shape":"ParquetInput",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "IntelligentTieringAccessTier":{
 
+      "type":"string",
 
+      "enum":[
 
+        "ARCHIVE_ACCESS",
 
+        "DEEP_ARCHIVE_ACCESS"
 
+      ]
 
+    },
 
+    "IntelligentTieringAndOperator":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Tags":{
 
+          "shape":"TagSet",
 
+          
+          "flattened":true,
 
+          "locationName":"Tag"
 
+        }
 
+      },
 
+      
+    },
 
+    "IntelligentTieringConfiguration":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Id",
 
+        "Status",
 
+        "Tierings"
 
+      ],
 
+      "members":{
 
+        "Id":{
 
+          "shape":"IntelligentTieringId",
 
+          
+        },
 
+        "Filter":{
 
+          "shape":"IntelligentTieringFilter",
 
+          
+        },
 
+        "Status":{
 
+          "shape":"IntelligentTieringStatus",
 
+          
+        },
 
+        "Tierings":{
 
+          "shape":"TieringList",
 
+          
+          "locationName":"Tiering"
 
+        }
 
+      },
 
+      
+    },
 
+    "IntelligentTieringConfigurationList":{
 
+      "type":"list",
 
+      "member":{"shape":"IntelligentTieringConfiguration"},
 
+      "flattened":true
 
+    },
 
+    "IntelligentTieringDays":{"type":"integer"},
 
+    "IntelligentTieringFilter":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Tag":{"shape":"Tag"},
 
+        "And":{
 
+          "shape":"IntelligentTieringAndOperator",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "IntelligentTieringId":{"type":"string"},
 
+    "IntelligentTieringStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "InvalidObjectState":{
 
+      "type":"structure",
 
+      "members":{
 
+        "StorageClass":{"shape":"StorageClass"},
 
+        "AccessTier":{"shape":"IntelligentTieringAccessTier"}
 
+      },
 
+      
+      "exception":true
 
+    },
 
+    "InventoryConfiguration":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Destination",
 
+        "IsEnabled",
 
+        "Id",
 
+        "IncludedObjectVersions",
 
+        "Schedule"
 
+      ],
 
+      "members":{
 
+        "Destination":{
 
+          "shape":"InventoryDestination",
 
+          
+        },
 
+        "IsEnabled":{
 
+          "shape":"IsEnabled",
 
+          
+        },
 
+        "Filter":{
 
+          "shape":"InventoryFilter",
 
+          
+        },
 
+        "Id":{
 
+          "shape":"InventoryId",
 
+          
+        },
 
+        "IncludedObjectVersions":{
 
+          "shape":"InventoryIncludedObjectVersions",
 
+          
+        },
 
+        "OptionalFields":{
 
+          "shape":"InventoryOptionalFields",
 
+          
+        },
 
+        "Schedule":{
 
+          "shape":"InventorySchedule",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "InventoryConfigurationList":{
 
+      "type":"list",
 
+      "member":{"shape":"InventoryConfiguration"},
 
+      "flattened":true
 
+    },
 
+    "InventoryDestination":{
 
+      "type":"structure",
 
+      "required":["S3BucketDestination"],
 
+      "members":{
 
+        "S3BucketDestination":{
 
+          "shape":"InventoryS3BucketDestination",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "InventoryEncryption":{
 
+      "type":"structure",
 
+      "members":{
 
+        "SSES3":{
 
+          "shape":"SSES3",
 
+          
+          "locationName":"SSE-S3"
 
+        },
 
+        "SSEKMS":{
 
+          "shape":"SSEKMS",
 
+          
+          "locationName":"SSE-KMS"
 
+        }
 
+      },
 
+      
+    },
 
+    "InventoryFilter":{
 
+      "type":"structure",
 
+      "required":["Prefix"],
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "InventoryFormat":{
 
+      "type":"string",
 
+      "enum":[
 
+        "CSV",
 
+        "ORC",
 
+        "Parquet"
 
+      ]
 
+    },
 
+    "InventoryFrequency":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Daily",
 
+        "Weekly"
 
+      ]
 
+    },
 
+    "InventoryId":{"type":"string"},
 
+    "InventoryIncludedObjectVersions":{
 
+      "type":"string",
 
+      "enum":[
 
+        "All",
 
+        "Current"
 
+      ]
 
+    },
 
+    "InventoryOptionalField":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Size",
 
+        "LastModifiedDate",
 
+        "StorageClass",
 
+        "ETag",
 
+        "IsMultipartUploaded",
 
+        "ReplicationStatus",
 
+        "EncryptionStatus",
 
+        "ObjectLockRetainUntilDate",
 
+        "ObjectLockMode",
 
+        "ObjectLockLegalHoldStatus",
 
+        "IntelligentTieringAccessTier",
 
+        "BucketKeyStatus",
 
+        "ChecksumAlgorithm"
 
+      ]
 
+    },
 
+    "InventoryOptionalFields":{
 
+      "type":"list",
 
+      "member":{
 
+        "shape":"InventoryOptionalField",
 
+        "locationName":"Field"
 
+      }
 
+    },
 
+    "InventoryS3BucketDestination":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Format"
 
+      ],
 
+      "members":{
 
+        "AccountId":{
 
+          "shape":"AccountId",
 
+          
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "Format":{
 
+          "shape":"InventoryFormat",
 
+          
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Encryption":{
 
+          "shape":"InventoryEncryption",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "InventorySchedule":{
 
+      "type":"structure",
 
+      "required":["Frequency"],
 
+      "members":{
 
+        "Frequency":{
 
+          "shape":"InventoryFrequency",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "IsEnabled":{"type":"boolean"},
 
+    "IsLatest":{"type":"boolean"},
 
+    "IsPublic":{"type":"boolean"},
 
+    "IsTruncated":{"type":"boolean"},
 
+    "JSONInput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Type":{
 
+          "shape":"JSONType",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "JSONOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "RecordDelimiter":{
 
+          "shape":"RecordDelimiter",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "JSONType":{
 
+      "type":"string",
 
+      "enum":[
 
+        "DOCUMENT",
 
+        "LINES"
 
+      ]
 
+    },
 
+    "KMSContext":{"type":"string"},
 
+    "KeyCount":{"type":"integer"},
 
+    "KeyMarker":{"type":"string"},
 
+    "KeyPrefixEquals":{"type":"string"},
 
+    "LambdaFunctionArn":{"type":"string"},
 
+    "LambdaFunctionConfiguration":{
 
+      "type":"structure",
 
+      "required":[
 
+        "LambdaFunctionArn",
 
+        "Events"
 
+      ],
 
+      "members":{
 
+        "Id":{"shape":"NotificationId"},
 
+        "LambdaFunctionArn":{
 
+          "shape":"LambdaFunctionArn",
 
+          
+          "locationName":"CloudFunction"
 
+        },
 
+        "Events":{
 
+          "shape":"EventList",
 
+          
+          "locationName":"Event"
 
+        },
 
+        "Filter":{"shape":"NotificationConfigurationFilter"}
 
+      },
 
+      
+    },
 
+    "LambdaFunctionConfigurationList":{
 
+      "type":"list",
 
+      "member":{"shape":"LambdaFunctionConfiguration"},
 
+      "flattened":true
 
+    },
 
+    "LastModified":{"type":"timestamp"},
 
+    "LifecycleConfiguration":{
 
+      "type":"structure",
 
+      "required":["Rules"],
 
+      "members":{
 
+        "Rules":{
 
+          "shape":"Rules",
 
+          
+          "locationName":"Rule"
 
+        }
 
+      },
 
+      
+    },
 
+    "LifecycleExpiration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Date":{
 
+          "shape":"Date",
 
+          
+        },
 
+        "Days":{
 
+          "shape":"Days",
 
+          
+        },
 
+        "ExpiredObjectDeleteMarker":{
 
+          "shape":"ExpiredObjectDeleteMarker",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "LifecycleRule":{
 
+      "type":"structure",
 
+      "required":["Status"],
 
+      "members":{
 
+        "Expiration":{
 
+          "shape":"LifecycleExpiration",
 
+          
+        },
 
+        "ID":{
 
+          "shape":"ID",
 
+          
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+          "deprecated":true
 
+        },
 
+        "Filter":{
 
+          "shape":"LifecycleRuleFilter",
 
+          
+        },
 
+        "Status":{
 
+          "shape":"ExpirationStatus",
 
+          
+        },
 
+        "Transitions":{
 
+          "shape":"TransitionList",
 
+          
+          "locationName":"Transition"
 
+        },
 
+        "NoncurrentVersionTransitions":{
 
+          "shape":"NoncurrentVersionTransitionList",
 
+          
+          "locationName":"NoncurrentVersionTransition"
 
+        },
 
+        "NoncurrentVersionExpiration":{"shape":"NoncurrentVersionExpiration"},
 
+        "AbortIncompleteMultipartUpload":{"shape":"AbortIncompleteMultipartUpload"}
 
+      },
 
+      
+    },
 
+    "LifecycleRuleAndOperator":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Tags":{
 
+          "shape":"TagSet",
 
+          
+          "flattened":true,
 
+          "locationName":"Tag"
 
+        },
 
+        "ObjectSizeGreaterThan":{
 
+          "shape":"ObjectSizeGreaterThanBytes",
 
+          
+        },
 
+        "ObjectSizeLessThan":{
 
+          "shape":"ObjectSizeLessThanBytes",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "LifecycleRuleFilter":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Tag":{
 
+          "shape":"Tag",
 
+          
+        },
 
+        "ObjectSizeGreaterThan":{
 
+          "shape":"ObjectSizeGreaterThanBytes",
 
+          
+        },
 
+        "ObjectSizeLessThan":{
 
+          "shape":"ObjectSizeLessThanBytes",
 
+          
+        },
 
+        "And":{"shape":"LifecycleRuleAndOperator"}
 
+      },
 
+      
+    },
 
+    "LifecycleRules":{
 
+      "type":"list",
 
+      "member":{"shape":"LifecycleRule"},
 
+      "flattened":true
 
+    },
 
+    "ListBucketAnalyticsConfigurationsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "IsTruncated":{
 
+          "shape":"IsTruncated",
 
+          
+        },
 
+        "ContinuationToken":{
 
+          "shape":"Token",
 
+          
+        },
 
+        "NextContinuationToken":{
 
+          "shape":"NextToken",
 
+          
+        },
 
+        "AnalyticsConfigurationList":{
 
+          "shape":"AnalyticsConfigurationList",
 
+          
+          "locationName":"AnalyticsConfiguration"
 
+        }
 
+      }
 
+    },
 
+    "ListBucketAnalyticsConfigurationsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContinuationToken":{
 
+          "shape":"Token",
 
+          
+          "location":"querystring",
 
+          "locationName":"continuation-token"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "ListBucketIntelligentTieringConfigurationsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "IsTruncated":{
 
+          "shape":"IsTruncated",
 
+          
+        },
 
+        "ContinuationToken":{
 
+          "shape":"Token",
 
+          
+        },
 
+        "NextContinuationToken":{
 
+          "shape":"NextToken",
 
+          
+        },
 
+        "IntelligentTieringConfigurationList":{
 
+          "shape":"IntelligentTieringConfigurationList",
 
+          
+          "locationName":"IntelligentTieringConfiguration"
 
+        }
 
+      }
 
+    },
 
+    "ListBucketIntelligentTieringConfigurationsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContinuationToken":{
 
+          "shape":"Token",
 
+          
+          "location":"querystring",
 
+          "locationName":"continuation-token"
 
+        }
 
+      }
 
+    },
 
+    "ListBucketInventoryConfigurationsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ContinuationToken":{
 
+          "shape":"Token",
 
+          
+        },
 
+        "InventoryConfigurationList":{
 
+          "shape":"InventoryConfigurationList",
 
+          
+          "locationName":"InventoryConfiguration"
 
+        },
 
+        "IsTruncated":{
 
+          "shape":"IsTruncated",
 
+          
+        },
 
+        "NextContinuationToken":{
 
+          "shape":"NextToken",
 
+          
+        }
 
+      }
 
+    },
 
+    "ListBucketInventoryConfigurationsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContinuationToken":{
 
+          "shape":"Token",
 
+          
+          "location":"querystring",
 
+          "locationName":"continuation-token"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "ListBucketMetricsConfigurationsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "IsTruncated":{
 
+          "shape":"IsTruncated",
 
+          
+        },
 
+        "ContinuationToken":{
 
+          "shape":"Token",
 
+          
+        },
 
+        "NextContinuationToken":{
 
+          "shape":"NextToken",
 
+          
+        },
 
+        "MetricsConfigurationList":{
 
+          "shape":"MetricsConfigurationList",
 
+          
+          "locationName":"MetricsConfiguration"
 
+        }
 
+      }
 
+    },
 
+    "ListBucketMetricsConfigurationsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContinuationToken":{
 
+          "shape":"Token",
 
+          
+          "location":"querystring",
 
+          "locationName":"continuation-token"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "ListBucketsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Buckets":{
 
+          "shape":"Buckets",
 
+          
+        },
 
+        "Owner":{
 
+          "shape":"Owner",
 
+          
+        }
 
+      }
 
+    },
 
+    "ListMultipartUploadsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "KeyMarker":{
 
+          "shape":"KeyMarker",
 
+          
+        },
 
+        "UploadIdMarker":{
 
+          "shape":"UploadIdMarker",
 
+          
+        },
 
+        "NextKeyMarker":{
 
+          "shape":"NextKeyMarker",
 
+          
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Delimiter":{
 
+          "shape":"Delimiter",
 
+          
+        },
 
+        "NextUploadIdMarker":{
 
+          "shape":"NextUploadIdMarker",
 
+          
+        },
 
+        "MaxUploads":{
 
+          "shape":"MaxUploads",
 
+          
+        },
 
+        "IsTruncated":{
 
+          "shape":"IsTruncated",
 
+          
+        },
 
+        "Uploads":{
 
+          "shape":"MultipartUploadList",
 
+          
+          "locationName":"Upload"
 
+        },
 
+        "CommonPrefixes":{
 
+          "shape":"CommonPrefixList",
 
+          
+        },
 
+        "EncodingType":{
 
+          "shape":"EncodingType",
 
+          
+        }
 
+      }
 
+    },
 
+    "ListMultipartUploadsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Delimiter":{
 
+          "shape":"Delimiter",
 
+          
+          "location":"querystring",
 
+          "locationName":"delimiter"
 
+        },
 
+        "EncodingType":{
 
+          "shape":"EncodingType",
 
+          "location":"querystring",
 
+          "locationName":"encoding-type"
 
+        },
 
+        "KeyMarker":{
 
+          "shape":"KeyMarker",
 
+          
+          "location":"querystring",
 
+          "locationName":"key-marker"
 
+        },
 
+        "MaxUploads":{
 
+          "shape":"MaxUploads",
 
+          
+          "location":"querystring",
 
+          "locationName":"max-uploads"
 
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+          "location":"querystring",
 
+          "locationName":"prefix"
 
+        },
 
+        "UploadIdMarker":{
 
+          "shape":"UploadIdMarker",
 
+          
+          "location":"querystring",
 
+          "locationName":"upload-id-marker"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "ListObjectVersionsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "IsTruncated":{
 
+          "shape":"IsTruncated",
 
+          
+        },
 
+        "KeyMarker":{
 
+          "shape":"KeyMarker",
 
+          
+        },
 
+        "VersionIdMarker":{
 
+          "shape":"VersionIdMarker",
 
+          
+        },
 
+        "NextKeyMarker":{
 
+          "shape":"NextKeyMarker",
 
+          
+        },
 
+        "NextVersionIdMarker":{
 
+          "shape":"NextVersionIdMarker",
 
+          
+        },
 
+        "Versions":{
 
+          "shape":"ObjectVersionList",
 
+          
+          "locationName":"Version"
 
+        },
 
+        "DeleteMarkers":{
 
+          "shape":"DeleteMarkers",
 
+          
+          "locationName":"DeleteMarker"
 
+        },
 
+        "Name":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Delimiter":{
 
+          "shape":"Delimiter",
 
+          
+        },
 
+        "MaxKeys":{
 
+          "shape":"MaxKeys",
 
+          
+        },
 
+        "CommonPrefixes":{
 
+          "shape":"CommonPrefixList",
 
+          
+        },
 
+        "EncodingType":{
 
+          "shape":"EncodingType",
 
+          
+        }
 
+      }
 
+    },
 
+    "ListObjectVersionsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Delimiter":{
 
+          "shape":"Delimiter",
 
+          
+          "location":"querystring",
 
+          "locationName":"delimiter"
 
+        },
 
+        "EncodingType":{
 
+          "shape":"EncodingType",
 
+          "location":"querystring",
 
+          "locationName":"encoding-type"
 
+        },
 
+        "KeyMarker":{
 
+          "shape":"KeyMarker",
 
+          
+          "location":"querystring",
 
+          "locationName":"key-marker"
 
+        },
 
+        "MaxKeys":{
 
+          "shape":"MaxKeys",
 
+          
+          "location":"querystring",
 
+          "locationName":"max-keys"
 
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+          "location":"querystring",
 
+          "locationName":"prefix"
 
+        },
 
+        "VersionIdMarker":{
 
+          "shape":"VersionIdMarker",
 
+          
+          "location":"querystring",
 
+          "locationName":"version-id-marker"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "ListObjectsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "IsTruncated":{
 
+          "shape":"IsTruncated",
 
+          
+        },
 
+        "Marker":{
 
+          "shape":"Marker",
 
+          
+        },
 
+        "NextMarker":{
 
+          "shape":"NextMarker",
 
+          
+        },
 
+        "Contents":{
 
+          "shape":"ObjectList",
 
+          
+        },
 
+        "Name":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Delimiter":{
 
+          "shape":"Delimiter",
 
+          
+        },
 
+        "MaxKeys":{
 
+          "shape":"MaxKeys",
 
+          
+        },
 
+        "CommonPrefixes":{
 
+          "shape":"CommonPrefixList",
 
+          
+        },
 
+        "EncodingType":{
 
+          "shape":"EncodingType",
 
+          
+        }
 
+      }
 
+    },
 
+    "ListObjectsRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Delimiter":{
 
+          "shape":"Delimiter",
 
+          
+          "location":"querystring",
 
+          "locationName":"delimiter"
 
+        },
 
+        "EncodingType":{
 
+          "shape":"EncodingType",
 
+          "location":"querystring",
 
+          "locationName":"encoding-type"
 
+        },
 
+        "Marker":{
 
+          "shape":"Marker",
 
+          
+          "location":"querystring",
 
+          "locationName":"marker"
 
+        },
 
+        "MaxKeys":{
 
+          "shape":"MaxKeys",
 
+          
+          "location":"querystring",
 
+          "locationName":"max-keys"
 
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+          "location":"querystring",
 
+          "locationName":"prefix"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "ListObjectsV2Output":{
 
+      "type":"structure",
 
+      "members":{
 
+        "IsTruncated":{
 
+          "shape":"IsTruncated",
 
+          
+        },
 
+        "Contents":{
 
+          "shape":"ObjectList",
 
+          
+        },
 
+        "Name":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Delimiter":{
 
+          "shape":"Delimiter",
 
+          
+        },
 
+        "MaxKeys":{
 
+          "shape":"MaxKeys",
 
+          
+        },
 
+        "CommonPrefixes":{
 
+          "shape":"CommonPrefixList",
 
+          
+        },
 
+        "EncodingType":{
 
+          "shape":"EncodingType",
 
+          
+        },
 
+        "KeyCount":{
 
+          "shape":"KeyCount",
 
+          
+        },
 
+        "ContinuationToken":{
 
+          "shape":"Token",
 
+          
+        },
 
+        "NextContinuationToken":{
 
+          "shape":"NextToken",
 
+          
+        },
 
+        "StartAfter":{
 
+          "shape":"StartAfter",
 
+          
+        }
 
+      }
 
+    },
 
+    "ListObjectsV2Request":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Delimiter":{
 
+          "shape":"Delimiter",
 
+          
+          "location":"querystring",
 
+          "locationName":"delimiter"
 
+        },
 
+        "EncodingType":{
 
+          "shape":"EncodingType",
 
+          
+          "location":"querystring",
 
+          "locationName":"encoding-type"
 
+        },
 
+        "MaxKeys":{
 
+          "shape":"MaxKeys",
 
+          
+          "location":"querystring",
 
+          "locationName":"max-keys"
 
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+          "location":"querystring",
 
+          "locationName":"prefix"
 
+        },
 
+        "ContinuationToken":{
 
+          "shape":"Token",
 
+          
+          "location":"querystring",
 
+          "locationName":"continuation-token"
 
+        },
 
+        "FetchOwner":{
 
+          "shape":"FetchOwner",
 
+          
+          "location":"querystring",
 
+          "locationName":"fetch-owner"
 
+        },
 
+        "StartAfter":{
 
+          "shape":"StartAfter",
 
+          
+          "location":"querystring",
 
+          "locationName":"start-after"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "ListPartsOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "AbortDate":{
 
+          "shape":"AbortDate",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-abort-date"
 
+        },
 
+        "AbortRuleId":{
 
+          "shape":"AbortRuleId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-abort-rule-id"
 
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "UploadId":{
 
+          "shape":"MultipartUploadId",
 
+          
+        },
 
+        "PartNumberMarker":{
 
+          "shape":"PartNumberMarker",
 
+          
+        },
 
+        "NextPartNumberMarker":{
 
+          "shape":"NextPartNumberMarker",
 
+          
+        },
 
+        "MaxParts":{
 
+          "shape":"MaxParts",
 
+          
+        },
 
+        "IsTruncated":{
 
+          "shape":"IsTruncated",
 
+          
+        },
 
+        "Parts":{
 
+          "shape":"Parts",
 
+          
+          "locationName":"Part"
 
+        },
 
+        "Initiator":{
 
+          "shape":"Initiator",
 
+          
+        },
 
+        "Owner":{
 
+          "shape":"Owner",
 
+          
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+        }
 
+      }
 
+    },
 
+    "ListPartsRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key",
 
+        "UploadId"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "MaxParts":{
 
+          "shape":"MaxParts",
 
+          
+          "location":"querystring",
 
+          "locationName":"max-parts"
 
+        },
 
+        "PartNumberMarker":{
 
+          "shape":"PartNumberMarker",
 
+          
+          "location":"querystring",
 
+          "locationName":"part-number-marker"
 
+        },
 
+        "UploadId":{
 
+          "shape":"MultipartUploadId",
 
+          
+          "location":"querystring",
 
+          "locationName":"uploadId"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        }
 
+      }
 
+    },
 
+    "Location":{"type":"string"},
 
+    "LocationPrefix":{"type":"string"},
 
+    "LoggingEnabled":{
 
+      "type":"structure",
 
+      "required":[
 
+        "TargetBucket",
 
+        "TargetPrefix"
 
+      ],
 
+      "members":{
 
+        "TargetBucket":{
 
+          "shape":"TargetBucket",
 
+          
+        },
 
+        "TargetGrants":{
 
+          "shape":"TargetGrants",
 
+          
+        },
 
+        "TargetPrefix":{
 
+          "shape":"TargetPrefix",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "MFA":{"type":"string"},
 
+    "MFADelete":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "MFADeleteStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "Marker":{"type":"string"},
 
+    "MaxAgeSeconds":{"type":"integer"},
 
+    "MaxKeys":{"type":"integer"},
 
+    "MaxParts":{"type":"integer"},
 
+    "MaxUploads":{"type":"integer"},
 
+    "Message":{"type":"string"},
 
+    "Metadata":{
 
+      "type":"map",
 
+      "key":{"shape":"MetadataKey"},
 
+      "value":{"shape":"MetadataValue"}
 
+    },
 
+    "MetadataDirective":{
 
+      "type":"string",
 
+      "enum":[
 
+        "COPY",
 
+        "REPLACE"
 
+      ]
 
+    },
 
+    "MetadataEntry":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Name":{
 
+          "shape":"MetadataKey",
 
+          
+        },
 
+        "Value":{
 
+          "shape":"MetadataValue",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "MetadataKey":{"type":"string"},
 
+    "MetadataValue":{"type":"string"},
 
+    "Metrics":{
 
+      "type":"structure",
 
+      "required":["Status"],
 
+      "members":{
 
+        "Status":{
 
+          "shape":"MetricsStatus",
 
+          
+        },
 
+        "EventThreshold":{
 
+          "shape":"ReplicationTimeValue",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "MetricsAndOperator":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Tags":{
 
+          "shape":"TagSet",
 
+          
+          "flattened":true,
 
+          "locationName":"Tag"
 
+        },
 
+        "AccessPointArn":{
 
+          "shape":"AccessPointArn",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "MetricsConfiguration":{
 
+      "type":"structure",
 
+      "required":["Id"],
 
+      "members":{
 
+        "Id":{
 
+          "shape":"MetricsId",
 
+          
+        },
 
+        "Filter":{
 
+          "shape":"MetricsFilter",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "MetricsConfigurationList":{
 
+      "type":"list",
 
+      "member":{"shape":"MetricsConfiguration"},
 
+      "flattened":true
 
+    },
 
+    "MetricsFilter":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Tag":{
 
+          "shape":"Tag",
 
+          
+        },
 
+        "AccessPointArn":{
 
+          "shape":"AccessPointArn",
 
+          
+        },
 
+        "And":{
 
+          "shape":"MetricsAndOperator",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "MetricsId":{"type":"string"},
 
+    "MetricsStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "Minutes":{"type":"integer"},
 
+    "MissingMeta":{"type":"integer"},
 
+    "MultipartUpload":{
 
+      "type":"structure",
 
+      "members":{
 
+        "UploadId":{
 
+          "shape":"MultipartUploadId",
 
+          
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "Initiated":{
 
+          "shape":"Initiated",
 
+          
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+        },
 
+        "Owner":{
 
+          "shape":"Owner",
 
+          
+        },
 
+        "Initiator":{
 
+          "shape":"Initiator",
 
+          
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "MultipartUploadId":{"type":"string"},
 
+    "MultipartUploadList":{
 
+      "type":"list",
 
+      "member":{"shape":"MultipartUpload"},
 
+      "flattened":true
 
+    },
 
+    "NextKeyMarker":{"type":"string"},
 
+    "NextMarker":{"type":"string"},
 
+    "NextPartNumberMarker":{"type":"integer"},
 
+    "NextToken":{"type":"string"},
 
+    "NextUploadIdMarker":{"type":"string"},
 
+    "NextVersionIdMarker":{"type":"string"},
 
+    "NoSuchBucket":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+      "exception":true
 
+    },
 
+    "NoSuchKey":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+      "exception":true
 
+    },
 
+    "NoSuchUpload":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+      "exception":true
 
+    },
 
+    "NoncurrentVersionExpiration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "NoncurrentDays":{
 
+          "shape":"Days",
 
+          
+        },
 
+        "NewerNoncurrentVersions":{
 
+          "shape":"VersionCount",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "NoncurrentVersionTransition":{
 
+      "type":"structure",
 
+      "members":{
 
+        "NoncurrentDays":{
 
+          "shape":"Days",
 
+          
+        },
 
+        "StorageClass":{
 
+          "shape":"TransitionStorageClass",
 
+          
+        },
 
+        "NewerNoncurrentVersions":{
 
+          "shape":"VersionCount",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "NoncurrentVersionTransitionList":{
 
+      "type":"list",
 
+      "member":{"shape":"NoncurrentVersionTransition"},
 
+      "flattened":true
 
+    },
 
+    "NotificationConfiguration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "TopicConfigurations":{
 
+          "shape":"TopicConfigurationList",
 
+          
+          "locationName":"TopicConfiguration"
 
+        },
 
+        "QueueConfigurations":{
 
+          "shape":"QueueConfigurationList",
 
+          
+          "locationName":"QueueConfiguration"
 
+        },
 
+        "LambdaFunctionConfigurations":{
 
+          "shape":"LambdaFunctionConfigurationList",
 
+          
+          "locationName":"CloudFunctionConfiguration"
 
+        },
 
+        "EventBridgeConfiguration":{
 
+          "shape":"EventBridgeConfiguration",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "NotificationConfigurationDeprecated":{
 
+      "type":"structure",
 
+      "members":{
 
+        "TopicConfiguration":{
 
+          "shape":"TopicConfigurationDeprecated",
 
+          
+        },
 
+        "QueueConfiguration":{
 
+          "shape":"QueueConfigurationDeprecated",
 
+          
+        },
 
+        "CloudFunctionConfiguration":{
 
+          "shape":"CloudFunctionConfiguration",
 
+          
+        }
 
+      }
 
+    },
 
+    "NotificationConfigurationFilter":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Key":{
 
+          "shape":"S3KeyFilter",
 
+          "locationName":"S3Key"
 
+        }
 
+      },
 
+      
+    },
 
+    "NotificationId":{
 
+      "type":"string",
 
+      
+    },
 
+    "Object":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "LastModified":{
 
+          "shape":"LastModified",
 
+          
+        },
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithmList",
 
+          
+        },
 
+        "Size":{
 
+          "shape":"Size",
 
+          
+        },
 
+        "StorageClass":{
 
+          "shape":"ObjectStorageClass",
 
+          
+        },
 
+        "Owner":{
 
+          "shape":"Owner",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ObjectAlreadyInActiveTierError":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+      "exception":true
 
+    },
 
+    "ObjectAttributes":{
 
+      "type":"string",
 
+      "enum":[
 
+        "ETag",
 
+        "Checksum",
 
+        "ObjectParts",
 
+        "StorageClass",
 
+        "ObjectSize"
 
+      ]
 
+    },
 
+    "ObjectAttributesList":{
 
+      "type":"list",
 
+      "member":{"shape":"ObjectAttributes"}
 
+    },
 
+    "ObjectCannedACL":{
 
+      "type":"string",
 
+      "enum":[
 
+        "private",
 
+        "public-read",
 
+        "public-read-write",
 
+        "authenticated-read",
 
+        "aws-exec-read",
 
+        "bucket-owner-read",
 
+        "bucket-owner-full-control"
 
+      ]
 
+    },
 
+    "ObjectIdentifier":{
 
+      "type":"structure",
 
+      "required":["Key"],
 
+      "members":{
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ObjectIdentifierList":{
 
+      "type":"list",
 
+      "member":{"shape":"ObjectIdentifier"},
 
+      "flattened":true
 
+    },
 
+    "ObjectKey":{
 
+      "type":"string",
 
+      "min":1
 
+    },
 
+    "ObjectList":{
 
+      "type":"list",
 
+      "member":{"shape":"Object"},
 
+      "flattened":true
 
+    },
 
+    "ObjectLockConfiguration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ObjectLockEnabled":{
 
+          "shape":"ObjectLockEnabled",
 
+          
+        },
 
+        "Rule":{
 
+          "shape":"ObjectLockRule",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ObjectLockEnabled":{
 
+      "type":"string",
 
+      "enum":["Enabled"]
 
+    },
 
+    "ObjectLockEnabledForBucket":{"type":"boolean"},
 
+    "ObjectLockLegalHold":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Status":{
 
+          "shape":"ObjectLockLegalHoldStatus",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ObjectLockLegalHoldStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "ON",
 
+        "OFF"
 
+      ]
 
+    },
 
+    "ObjectLockMode":{
 
+      "type":"string",
 
+      "enum":[
 
+        "GOVERNANCE",
 
+        "COMPLIANCE"
 
+      ]
 
+    },
 
+    "ObjectLockRetainUntilDate":{
 
+      "type":"timestamp",
 
+      "timestampFormat":"iso8601"
 
+    },
 
+    "ObjectLockRetention":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Mode":{
 
+          "shape":"ObjectLockRetentionMode",
 
+          
+        },
 
+        "RetainUntilDate":{
 
+          "shape":"Date",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ObjectLockRetentionMode":{
 
+      "type":"string",
 
+      "enum":[
 
+        "GOVERNANCE",
 
+        "COMPLIANCE"
 
+      ]
 
+    },
 
+    "ObjectLockRule":{
 
+      "type":"structure",
 
+      "members":{
 
+        "DefaultRetention":{
 
+          "shape":"DefaultRetention",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ObjectLockToken":{"type":"string"},
 
+    "ObjectNotInActiveTierError":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+      "exception":true
 
+    },
 
+    "ObjectOwnership":{
 
+      "type":"string",
 
+      
+      "enum":[
 
+        "BucketOwnerPreferred",
 
+        "ObjectWriter",
 
+        "BucketOwnerEnforced"
 
+      ]
 
+    },
 
+    "ObjectPart":{
 
+      "type":"structure",
 
+      "members":{
 
+        "PartNumber":{
 
+          "shape":"PartNumber",
 
+          
+        },
 
+        "Size":{
 
+          "shape":"Size",
 
+          
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ObjectSize":{"type":"long"},
 
+    "ObjectSizeGreaterThanBytes":{"type":"long"},
 
+    "ObjectSizeLessThanBytes":{"type":"long"},
 
+    "ObjectStorageClass":{
 
+      "type":"string",
 
+      "enum":[
 
+        "STANDARD",
 
+        "REDUCED_REDUNDANCY",
 
+        "GLACIER",
 
+        "STANDARD_IA",
 
+        "ONEZONE_IA",
 
+        "INTELLIGENT_TIERING",
 
+        "DEEP_ARCHIVE",
 
+        "OUTPOSTS",
 
+        "GLACIER_IR",
 
+        "SNOW"
 
+      ]
 
+    },
 
+    "ObjectVersion":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithmList",
 
+          
+        },
 
+        "Size":{
 
+          "shape":"Size",
 
+          
+        },
 
+        "StorageClass":{
 
+          "shape":"ObjectVersionStorageClass",
 
+          
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+        },
 
+        "IsLatest":{
 
+          "shape":"IsLatest",
 
+          
+        },
 
+        "LastModified":{
 
+          "shape":"LastModified",
 
+          
+        },
 
+        "Owner":{
 
+          "shape":"Owner",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ObjectVersionId":{"type":"string"},
 
+    "ObjectVersionList":{
 
+      "type":"list",
 
+      "member":{"shape":"ObjectVersion"},
 
+      "flattened":true
 
+    },
 
+    "ObjectVersionStorageClass":{
 
+      "type":"string",
 
+      "enum":["STANDARD"]
 
+    },
 
+    "OutputLocation":{
 
+      "type":"structure",
 
+      "members":{
 
+        "S3":{
 
+          "shape":"S3Location",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "OutputSerialization":{
 
+      "type":"structure",
 
+      "members":{
 
+        "CSV":{
 
+          "shape":"CSVOutput",
 
+          
+        },
 
+        "JSON":{
 
+          "shape":"JSONOutput",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "Owner":{
 
+      "type":"structure",
 
+      "members":{
 
+        "DisplayName":{
 
+          "shape":"DisplayName",
 
+          
+        },
 
+        "ID":{
 
+          "shape":"ID",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "OwnerOverride":{
 
+      "type":"string",
 
+      "enum":["Destination"]
 
+    },
 
+    "OwnershipControls":{
 
+      "type":"structure",
 
+      "required":["Rules"],
 
+      "members":{
 
+        "Rules":{
 
+          "shape":"OwnershipControlsRules",
 
+          
+          "locationName":"Rule"
 
+        }
 
+      },
 
+      
+    },
 
+    "OwnershipControlsRule":{
 
+      "type":"structure",
 
+      "required":["ObjectOwnership"],
 
+      "members":{
 
+        "ObjectOwnership":{"shape":"ObjectOwnership"}
 
+      },
 
+      
+    },
 
+    "OwnershipControlsRules":{
 
+      "type":"list",
 
+      "member":{"shape":"OwnershipControlsRule"},
 
+      "flattened":true
 
+    },
 
+    "ParquetInput":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+    },
 
+    "Part":{
 
+      "type":"structure",
 
+      "members":{
 
+        "PartNumber":{
 
+          "shape":"PartNumber",
 
+          
+        },
 
+        "LastModified":{
 
+          "shape":"LastModified",
 
+          
+        },
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+        },
 
+        "Size":{
 
+          "shape":"Size",
 
+          
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "PartNumber":{"type":"integer"},
 
+    "PartNumberMarker":{"type":"integer"},
 
+    "Parts":{
 
+      "type":"list",
 
+      "member":{"shape":"Part"},
 
+      "flattened":true
 
+    },
 
+    "PartsCount":{"type":"integer"},
 
+    "PartsList":{
 
+      "type":"list",
 
+      "member":{"shape":"ObjectPart"},
 
+      "flattened":true
 
+    },
 
+    "Payer":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Requester",
 
+        "BucketOwner"
 
+      ]
 
+    },
 
+    "Permission":{
 
+      "type":"string",
 
+      "enum":[
 
+        "FULL_CONTROL",
 
+        "WRITE",
 
+        "WRITE_ACP",
 
+        "READ",
 
+        "READ_ACP"
 
+      ]
 
+    },
 
+    "Policy":{"type":"string"},
 
+    "PolicyStatus":{
 
+      "type":"structure",
 
+      "members":{
 
+        "IsPublic":{
 
+          "shape":"IsPublic",
 
+          
+          "locationName":"IsPublic"
 
+        }
 
+      },
 
+      
+    },
 
+    "Prefix":{"type":"string"},
 
+    "Priority":{"type":"integer"},
 
+    "Progress":{
 
+      "type":"structure",
 
+      "members":{
 
+        "BytesScanned":{
 
+          "shape":"BytesScanned",
 
+          
+        },
 
+        "BytesProcessed":{
 
+          "shape":"BytesProcessed",
 
+          
+        },
 
+        "BytesReturned":{
 
+          "shape":"BytesReturned",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ProgressEvent":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Details":{
 
+          "shape":"Progress",
 
+          
+          "eventpayload":true
 
+        }
 
+      },
 
+      
+      "event":true
 
+    },
 
+    "Protocol":{
 
+      "type":"string",
 
+      "enum":[
 
+        "http",
 
+        "https"
 
+      ]
 
+    },
 
+    "PublicAccessBlockConfiguration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "BlockPublicAcls":{
 
+          "shape":"Setting",
 
+          
+          "locationName":"BlockPublicAcls"
 
+        },
 
+        "IgnorePublicAcls":{
 
+          "shape":"Setting",
 
+          
+          "locationName":"IgnorePublicAcls"
 
+        },
 
+        "BlockPublicPolicy":{
 
+          "shape":"Setting",
 
+          
+          "locationName":"BlockPublicPolicy"
 
+        },
 
+        "RestrictPublicBuckets":{
 
+          "shape":"Setting",
 
+          
+          "locationName":"RestrictPublicBuckets"
 
+        }
 
+      },
 
+      
+    },
 
+    "PutBucketAccelerateConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "AccelerateConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "AccelerateConfiguration":{
 
+          "shape":"AccelerateConfiguration",
 
+          
+          "locationName":"AccelerateConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        }
 
+      },
 
+      "payload":"AccelerateConfiguration"
 
+    },
 
+    "PutBucketAclRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "ACL":{
 
+          "shape":"BucketCannedACL",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-acl"
 
+        },
 
+        "AccessControlPolicy":{
 
+          "shape":"AccessControlPolicy",
 
+          
+          "locationName":"AccessControlPolicy",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "GrantFullControl":{
 
+          "shape":"GrantFullControl",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-full-control"
 
+        },
 
+        "GrantRead":{
 
+          "shape":"GrantRead",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read"
 
+        },
 
+        "GrantReadACP":{
 
+          "shape":"GrantReadACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read-acp"
 
+        },
 
+        "GrantWrite":{
 
+          "shape":"GrantWrite",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-write"
 
+        },
 
+        "GrantWriteACP":{
 
+          "shape":"GrantWriteACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-write-acp"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"AccessControlPolicy"
 
+    },
 
+    "PutBucketAnalyticsConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id",
 
+        "AnalyticsConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"AnalyticsId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        },
 
+        "AnalyticsConfiguration":{
 
+          "shape":"AnalyticsConfiguration",
 
+          
+          "locationName":"AnalyticsConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"AnalyticsConfiguration"
 
+    },
 
+    "PutBucketCorsRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "CORSConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "CORSConfiguration":{
 
+          "shape":"CORSConfiguration",
 
+          
+          "locationName":"CORSConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"CORSConfiguration"
 
+    },
 
+    "PutBucketEncryptionRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "ServerSideEncryptionConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ServerSideEncryptionConfiguration":{
 
+          "shape":"ServerSideEncryptionConfiguration",
 
+          "locationName":"ServerSideEncryptionConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"ServerSideEncryptionConfiguration"
 
+    },
 
+    "PutBucketIntelligentTieringConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id",
 
+        "IntelligentTieringConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"IntelligentTieringId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        },
 
+        "IntelligentTieringConfiguration":{
 
+          "shape":"IntelligentTieringConfiguration",
 
+          
+          "locationName":"IntelligentTieringConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        }
 
+      },
 
+      "payload":"IntelligentTieringConfiguration"
 
+    },
 
+    "PutBucketInventoryConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id",
 
+        "InventoryConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"InventoryId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        },
 
+        "InventoryConfiguration":{
 
+          "shape":"InventoryConfiguration",
 
+          
+          "locationName":"InventoryConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"InventoryConfiguration"
 
+    },
 
+    "PutBucketLifecycleConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "LifecycleConfiguration":{
 
+          "shape":"BucketLifecycleConfiguration",
 
+          
+          "locationName":"LifecycleConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"LifecycleConfiguration"
 
+    },
 
+    "PutBucketLifecycleRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "LifecycleConfiguration":{
 
+          "shape":"LifecycleConfiguration",
 
+          
+          "locationName":"LifecycleConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"LifecycleConfiguration"
 
+    },
 
+    "PutBucketLoggingRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "BucketLoggingStatus"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "BucketLoggingStatus":{
 
+          "shape":"BucketLoggingStatus",
 
+          
+          "locationName":"BucketLoggingStatus",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"BucketLoggingStatus"
 
+    },
 
+    "PutBucketMetricsConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Id",
 
+        "MetricsConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Id":{
 
+          "shape":"MetricsId",
 
+          
+          "location":"querystring",
 
+          "locationName":"id"
 
+        },
 
+        "MetricsConfiguration":{
 
+          "shape":"MetricsConfiguration",
 
+          
+          "locationName":"MetricsConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"MetricsConfiguration"
 
+    },
 
+    "PutBucketNotificationConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "NotificationConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "NotificationConfiguration":{
 
+          "shape":"NotificationConfiguration",
 
+          "locationName":"NotificationConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "SkipDestinationValidation":{
 
+          "shape":"SkipValidation",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-skip-destination-validation"
 
+        }
 
+      },
 
+      "payload":"NotificationConfiguration"
 
+    },
 
+    "PutBucketNotificationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "NotificationConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "NotificationConfiguration":{
 
+          "shape":"NotificationConfigurationDeprecated",
 
+          
+          "locationName":"NotificationConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"NotificationConfiguration"
 
+    },
 
+    "PutBucketOwnershipControlsRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "OwnershipControls"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "OwnershipControls":{
 
+          "shape":"OwnershipControls",
 
+          
+          "locationName":"OwnershipControls",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        }
 
+      },
 
+      "payload":"OwnershipControls"
 
+    },
 
+    "PutBucketPolicyRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Policy"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ConfirmRemoveSelfBucketAccess":{
 
+          "shape":"ConfirmRemoveSelfBucketAccess",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-confirm-remove-self-bucket-access"
 
+        },
 
+        "Policy":{
 
+          "shape":"Policy",
 
+          
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"Policy"
 
+    },
 
+    "PutBucketReplicationRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "ReplicationConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ReplicationConfiguration":{
 
+          "shape":"ReplicationConfiguration",
 
+          "locationName":"ReplicationConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "Token":{
 
+          "shape":"ObjectLockToken",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-bucket-object-lock-token"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"ReplicationConfiguration"
 
+    },
 
+    "PutBucketRequestPaymentRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "RequestPaymentConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "RequestPaymentConfiguration":{
 
+          "shape":"RequestPaymentConfiguration",
 
+          
+          "locationName":"RequestPaymentConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"RequestPaymentConfiguration"
 
+    },
 
+    "PutBucketTaggingRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Tagging"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "Tagging":{
 
+          "shape":"Tagging",
 
+          
+          "locationName":"Tagging",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"Tagging"
 
+    },
 
+    "PutBucketVersioningRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "VersioningConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "MFA":{
 
+          "shape":"MFA",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-mfa"
 
+        },
 
+        "VersioningConfiguration":{
 
+          "shape":"VersioningConfiguration",
 
+          
+          "locationName":"VersioningConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"VersioningConfiguration"
 
+    },
 
+    "PutBucketWebsiteRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "WebsiteConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "WebsiteConfiguration":{
 
+          "shape":"WebsiteConfiguration",
 
+          
+          "locationName":"WebsiteConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"WebsiteConfiguration"
 
+    },
 
+    "PutObjectAclOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      }
 
+    },
 
+    "PutObjectAclRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "ACL":{
 
+          "shape":"ObjectCannedACL",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-acl"
 
+        },
 
+        "AccessControlPolicy":{
 
+          "shape":"AccessControlPolicy",
 
+          
+          "locationName":"AccessControlPolicy",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "GrantFullControl":{
 
+          "shape":"GrantFullControl",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-full-control"
 
+        },
 
+        "GrantRead":{
 
+          "shape":"GrantRead",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read"
 
+        },
 
+        "GrantReadACP":{
 
+          "shape":"GrantReadACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read-acp"
 
+        },
 
+        "GrantWrite":{
 
+          "shape":"GrantWrite",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-write"
 
+        },
 
+        "GrantWriteACP":{
 
+          "shape":"GrantWriteACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-write-acp"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"AccessControlPolicy"
 
+    },
 
+    "PutObjectLegalHoldOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      }
 
+    },
 
+    "PutObjectLegalHoldRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "LegalHold":{
 
+          "shape":"ObjectLockLegalHold",
 
+          
+          "locationName":"LegalHold",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"LegalHold"
 
+    },
 
+    "PutObjectLockConfigurationOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      }
 
+    },
 
+    "PutObjectLockConfigurationRequest":{
 
+      "type":"structure",
 
+      "required":["Bucket"],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ObjectLockConfiguration":{
 
+          "shape":"ObjectLockConfiguration",
 
+          
+          "locationName":"ObjectLockConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "Token":{
 
+          "shape":"ObjectLockToken",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-bucket-object-lock-token"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"ObjectLockConfiguration"
 
+    },
 
+    "PutObjectOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Expiration":{
 
+          "shape":"Expiration",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expiration"
 
+        },
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+          "location":"header",
 
+          "locationName":"ETag"
 
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32"
 
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32c"
 
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha1"
 
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha256"
 
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-version-id"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "SSEKMSEncryptionContext":{
 
+          "shape":"SSEKMSEncryptionContext",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-context"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      }
 
+    },
 
+    "PutObjectRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "ACL":{
 
+          "shape":"ObjectCannedACL",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-acl"
 
+        },
 
+        "Body":{
 
+          "shape":"Body",
 
+          
+          "streaming":true
 
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "CacheControl":{
 
+          "shape":"CacheControl",
 
+          
+          "location":"header",
 
+          "locationName":"Cache-Control"
 
+        },
 
+        "ContentDisposition":{
 
+          "shape":"ContentDisposition",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Disposition"
 
+        },
 
+        "ContentEncoding":{
 
+          "shape":"ContentEncoding",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Encoding"
 
+        },
 
+        "ContentLanguage":{
 
+          "shape":"ContentLanguage",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Language"
 
+        },
 
+        "ContentLength":{
 
+          "shape":"ContentLength",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Length"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ContentType":{
 
+          "shape":"ContentType",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Type"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32"
 
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32c"
 
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha1"
 
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha256"
 
+        },
 
+        "Expires":{
 
+          "shape":"Expires",
 
+          
+          "location":"header",
 
+          "locationName":"Expires"
 
+        },
 
+        "GrantFullControl":{
 
+          "shape":"GrantFullControl",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-full-control"
 
+        },
 
+        "GrantRead":{
 
+          "shape":"GrantRead",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read"
 
+        },
 
+        "GrantReadACP":{
 
+          "shape":"GrantReadACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-read-acp"
 
+        },
 
+        "GrantWriteACP":{
 
+          "shape":"GrantWriteACP",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-grant-write-acp"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "Metadata":{
 
+          "shape":"Metadata",
 
+          
+          "location":"headers",
 
+          "locationName":"x-amz-meta-"
 
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-storage-class"
 
+        },
 
+        "WebsiteRedirectLocation":{
 
+          "shape":"WebsiteRedirectLocation",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-website-redirect-location"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "SSEKMSEncryptionContext":{
 
+          "shape":"SSEKMSEncryptionContext",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-context"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "Tagging":{
 
+          "shape":"TaggingHeader",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-tagging"
 
+        },
 
+        "ObjectLockMode":{
 
+          "shape":"ObjectLockMode",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-mode"
 
+        },
 
+        "ObjectLockRetainUntilDate":{
 
+          "shape":"ObjectLockRetainUntilDate",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-retain-until-date"
 
+        },
 
+        "ObjectLockLegalHoldStatus":{
 
+          "shape":"ObjectLockLegalHoldStatus",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-object-lock-legal-hold"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"Body"
 
+    },
 
+    "PutObjectRetentionOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      }
 
+    },
 
+    "PutObjectRetentionRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "Retention":{
 
+          "shape":"ObjectLockRetention",
 
+          
+          "locationName":"Retention",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "BypassGovernanceRetention":{
 
+          "shape":"BypassGovernanceRetention",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-bypass-governance-retention"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"Retention"
 
+    },
 
+    "PutObjectTaggingOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-version-id"
 
+        }
 
+      }
 
+    },
 
+    "PutObjectTaggingRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key",
 
+        "Tagging"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "Tagging":{
 
+          "shape":"Tagging",
 
+          
+          "locationName":"Tagging",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        }
 
+      },
 
+      "payload":"Tagging"
 
+    },
 
+    "PutPublicAccessBlockRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "PublicAccessBlockConfiguration"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "PublicAccessBlockConfiguration":{
 
+          "shape":"PublicAccessBlockConfiguration",
 
+          
+          "locationName":"PublicAccessBlockConfiguration",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"PublicAccessBlockConfiguration"
 
+    },
 
+    "QueueArn":{"type":"string"},
 
+    "QueueConfiguration":{
 
+      "type":"structure",
 
+      "required":[
 
+        "QueueArn",
 
+        "Events"
 
+      ],
 
+      "members":{
 
+        "Id":{"shape":"NotificationId"},
 
+        "QueueArn":{
 
+          "shape":"QueueArn",
 
+          
+          "locationName":"Queue"
 
+        },
 
+        "Events":{
 
+          "shape":"EventList",
 
+          
+          "locationName":"Event"
 
+        },
 
+        "Filter":{"shape":"NotificationConfigurationFilter"}
 
+      },
 
+      
+    },
 
+    "QueueConfigurationDeprecated":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Id":{"shape":"NotificationId"},
 
+        "Event":{
 
+          "shape":"Event",
 
+          "deprecated":true
 
+        },
 
+        "Events":{
 
+          "shape":"EventList",
 
+          
+          "locationName":"Event"
 
+        },
 
+        "Queue":{
 
+          "shape":"QueueArn",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "QueueConfigurationList":{
 
+      "type":"list",
 
+      "member":{"shape":"QueueConfiguration"},
 
+      "flattened":true
 
+    },
 
+    "Quiet":{"type":"boolean"},
 
+    "QuoteCharacter":{"type":"string"},
 
+    "QuoteEscapeCharacter":{"type":"string"},
 
+    "QuoteFields":{
 
+      "type":"string",
 
+      "enum":[
 
+        "ALWAYS",
 
+        "ASNEEDED"
 
+      ]
 
+    },
 
+    "Range":{"type":"string"},
 
+    "RecordDelimiter":{"type":"string"},
 
+    "RecordsEvent":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Payload":{
 
+          "shape":"Body",
 
+          
+          "eventpayload":true
 
+        }
 
+      },
 
+      
+      "event":true
 
+    },
 
+    "Redirect":{
 
+      "type":"structure",
 
+      "members":{
 
+        "HostName":{
 
+          "shape":"HostName",
 
+          
+        },
 
+        "HttpRedirectCode":{
 
+          "shape":"HttpRedirectCode",
 
+          
+        },
 
+        "Protocol":{
 
+          "shape":"Protocol",
 
+          
+        },
 
+        "ReplaceKeyPrefixWith":{
 
+          "shape":"ReplaceKeyPrefixWith",
 
+          
+        },
 
+        "ReplaceKeyWith":{
 
+          "shape":"ReplaceKeyWith",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "RedirectAllRequestsTo":{
 
+      "type":"structure",
 
+      "required":["HostName"],
 
+      "members":{
 
+        "HostName":{
 
+          "shape":"HostName",
 
+          
+        },
 
+        "Protocol":{
 
+          "shape":"Protocol",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ReplaceKeyPrefixWith":{"type":"string"},
 
+    "ReplaceKeyWith":{"type":"string"},
 
+    "ReplicaKmsKeyID":{"type":"string"},
 
+    "ReplicaModifications":{
 
+      "type":"structure",
 
+      "required":["Status"],
 
+      "members":{
 
+        "Status":{
 
+          "shape":"ReplicaModificationsStatus",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ReplicaModificationsStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "ReplicationConfiguration":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Role",
 
+        "Rules"
 
+      ],
 
+      "members":{
 
+        "Role":{
 
+          "shape":"Role",
 
+          
+        },
 
+        "Rules":{
 
+          "shape":"ReplicationRules",
 
+          
+          "locationName":"Rule"
 
+        }
 
+      },
 
+      
+    },
 
+    "ReplicationRule":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Status",
 
+        "Destination"
 
+      ],
 
+      "members":{
 
+        "ID":{
 
+          "shape":"ID",
 
+          
+        },
 
+        "Priority":{
 
+          "shape":"Priority",
 
+          
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+          "deprecated":true
 
+        },
 
+        "Filter":{"shape":"ReplicationRuleFilter"},
 
+        "Status":{
 
+          "shape":"ReplicationRuleStatus",
 
+          
+        },
 
+        "SourceSelectionCriteria":{
 
+          "shape":"SourceSelectionCriteria",
 
+          
+        },
 
+        "ExistingObjectReplication":{
 
+          "shape":"ExistingObjectReplication",
 
+          
+        },
 
+        "Destination":{
 
+          "shape":"Destination",
 
+          
+        },
 
+        "DeleteMarkerReplication":{"shape":"DeleteMarkerReplication"}
 
+      },
 
+      
+    },
 
+    "ReplicationRuleAndOperator":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Tags":{
 
+          "shape":"TagSet",
 
+          
+          "flattened":true,
 
+          "locationName":"Tag"
 
+        }
 
+      },
 
+      
+    },
 
+    "ReplicationRuleFilter":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Tag":{
 
+          "shape":"Tag",
 
+          
+        },
 
+        "And":{
 
+          "shape":"ReplicationRuleAndOperator",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ReplicationRuleStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "ReplicationRules":{
 
+      "type":"list",
 
+      "member":{"shape":"ReplicationRule"},
 
+      "flattened":true
 
+    },
 
+    "ReplicationStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "COMPLETE",
 
+        "PENDING",
 
+        "FAILED",
 
+        "REPLICA"
 
+      ]
 
+    },
 
+    "ReplicationTime":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Status",
 
+        "Time"
 
+      ],
 
+      "members":{
 
+        "Status":{
 
+          "shape":"ReplicationTimeStatus",
 
+          
+        },
 
+        "Time":{
 
+          "shape":"ReplicationTimeValue",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ReplicationTimeStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "ReplicationTimeValue":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Minutes":{
 
+          "shape":"Minutes",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "RequestCharged":{
 
+      "type":"string",
 
+      
+      "enum":["requester"]
 
+    },
 
+    "RequestPayer":{
 
+      "type":"string",
 
+      
+      "enum":["requester"]
 
+    },
 
+    "RequestPaymentConfiguration":{
 
+      "type":"structure",
 
+      "required":["Payer"],
 
+      "members":{
 
+        "Payer":{
 
+          "shape":"Payer",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "RequestProgress":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Enabled":{
 
+          "shape":"EnableRequestProgress",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "RequestRoute":{"type":"string"},
 
+    "RequestToken":{"type":"string"},
 
+    "ResponseCacheControl":{"type":"string"},
 
+    "ResponseContentDisposition":{"type":"string"},
 
+    "ResponseContentEncoding":{"type":"string"},
 
+    "ResponseContentLanguage":{"type":"string"},
 
+    "ResponseContentType":{"type":"string"},
 
+    "ResponseExpires":{
 
+      "type":"timestamp",
 
+      "timestampFormat":"rfc822"
 
+    },
 
+    "Restore":{"type":"string"},
 
+    "RestoreObjectOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        },
 
+        "RestoreOutputPath":{
 
+          "shape":"RestoreOutputPath",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-restore-output-path"
 
+        }
 
+      }
 
+    },
 
+    "RestoreObjectRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"querystring",
 
+          "locationName":"versionId"
 
+        },
 
+        "RestoreRequest":{
 
+          "shape":"RestoreRequest",
 
+          "locationName":"RestoreRequest",
 
+          "xmlNamespace":{"uri":"http://s3.amazonaws.com/doc/2006-03-01/"}
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"RestoreRequest"
 
+    },
 
+    "RestoreOutputPath":{"type":"string"},
 
+    "RestoreRequest":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Days":{
 
+          "shape":"Days",
 
+          
+        },
 
+        "GlacierJobParameters":{
 
+          "shape":"GlacierJobParameters",
 
+          
+        },
 
+        "Type":{
 
+          "shape":"RestoreRequestType",
 
+          
+        },
 
+        "Tier":{
 
+          "shape":"Tier",
 
+          
+        },
 
+        "Description":{
 
+          "shape":"Description",
 
+          
+        },
 
+        "SelectParameters":{
 
+          "shape":"SelectParameters",
 
+          
+        },
 
+        "OutputLocation":{
 
+          "shape":"OutputLocation",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "RestoreRequestType":{
 
+      "type":"string",
 
+      "enum":["SELECT"]
 
+    },
 
+    "Role":{"type":"string"},
 
+    "RoutingRule":{
 
+      "type":"structure",
 
+      "required":["Redirect"],
 
+      "members":{
 
+        "Condition":{
 
+          "shape":"Condition",
 
+          
+        },
 
+        "Redirect":{
 
+          "shape":"Redirect",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "RoutingRules":{
 
+      "type":"list",
 
+      "member":{
 
+        "shape":"RoutingRule",
 
+        "locationName":"RoutingRule"
 
+      }
 
+    },
 
+    "Rule":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Prefix",
 
+        "Status"
 
+      ],
 
+      "members":{
 
+        "Expiration":{
 
+          "shape":"LifecycleExpiration",
 
+          
+        },
 
+        "ID":{
 
+          "shape":"ID",
 
+          
+        },
 
+        "Prefix":{
 
+          "shape":"Prefix",
 
+          
+        },
 
+        "Status":{
 
+          "shape":"ExpirationStatus",
 
+          
+        },
 
+        "Transition":{
 
+          "shape":"Transition",
 
+          
+        },
 
+        "NoncurrentVersionTransition":{"shape":"NoncurrentVersionTransition"},
 
+        "NoncurrentVersionExpiration":{"shape":"NoncurrentVersionExpiration"},
 
+        "AbortIncompleteMultipartUpload":{"shape":"AbortIncompleteMultipartUpload"}
 
+      },
 
+      
+    },
 
+    "Rules":{
 
+      "type":"list",
 
+      "member":{"shape":"Rule"},
 
+      "flattened":true
 
+    },
 
+    "S3KeyFilter":{
 
+      "type":"structure",
 
+      "members":{
 
+        "FilterRules":{
 
+          "shape":"FilterRuleList",
 
+          "locationName":"FilterRule"
 
+        }
 
+      },
 
+      
+    },
 
+    "S3Location":{
 
+      "type":"structure",
 
+      "required":[
 
+        "BucketName",
 
+        "Prefix"
 
+      ],
 
+      "members":{
 
+        "BucketName":{
 
+          "shape":"BucketName",
 
+          
+        },
 
+        "Prefix":{
 
+          "shape":"LocationPrefix",
 
+          
+        },
 
+        "Encryption":{"shape":"Encryption"},
 
+        "CannedACL":{
 
+          "shape":"ObjectCannedACL",
 
+          
+        },
 
+        "AccessControlList":{
 
+          "shape":"Grants",
 
+          
+        },
 
+        "Tagging":{
 
+          "shape":"Tagging",
 
+          
+        },
 
+        "UserMetadata":{
 
+          "shape":"UserMetadata",
 
+          
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "SSECustomerAlgorithm":{"type":"string"},
 
+    "SSECustomerKey":{
 
+      "type":"string",
 
+      "sensitive":true
 
+    },
 
+    "SSECustomerKeyMD5":{"type":"string"},
 
+    "SSEKMS":{
 
+      "type":"structure",
 
+      "required":["KeyId"],
 
+      "members":{
 
+        "KeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+        }
 
+      },
 
+      
+      "locationName":"SSE-KMS"
 
+    },
 
+    "SSEKMSEncryptionContext":{
 
+      "type":"string",
 
+      "sensitive":true
 
+    },
 
+    "SSEKMSKeyId":{
 
+      "type":"string",
 
+      "sensitive":true
 
+    },
 
+    "SSES3":{
 
+      "type":"structure",
 
+      "members":{
 
+      },
 
+      
+      "locationName":"SSE-S3"
 
+    },
 
+    "ScanRange":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Start":{
 
+          "shape":"Start",
 
+          
+        },
 
+        "End":{
 
+          "shape":"End",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "SelectObjectContentEventStream":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Records":{
 
+          "shape":"RecordsEvent",
 
+          
+        },
 
+        "Stats":{
 
+          "shape":"StatsEvent",
 
+          
+        },
 
+        "Progress":{
 
+          "shape":"ProgressEvent",
 
+          
+        },
 
+        "Cont":{
 
+          "shape":"ContinuationEvent",
 
+          
+        },
 
+        "End":{
 
+          "shape":"EndEvent",
 
+          
+        }
 
+      },
 
+      
+      "eventstream":true
 
+    },
 
+    "SelectObjectContentOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Payload":{
 
+          "shape":"SelectObjectContentEventStream",
 
+          
+        }
 
+      },
 
+      "payload":"Payload"
 
+    },
 
+    "SelectObjectContentRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key",
 
+        "Expression",
 
+        "ExpressionType",
 
+        "InputSerialization",
 
+        "OutputSerialization"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "Expression":{
 
+          "shape":"Expression",
 
+          
+        },
 
+        "ExpressionType":{
 
+          "shape":"ExpressionType",
 
+          
+        },
 
+        "RequestProgress":{
 
+          "shape":"RequestProgress",
 
+          
+        },
 
+        "InputSerialization":{
 
+          "shape":"InputSerialization",
 
+          
+        },
 
+        "OutputSerialization":{
 
+          "shape":"OutputSerialization",
 
+          
+        },
 
+        "ScanRange":{
 
+          "shape":"ScanRange",
 
+          
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      
+    },
 
+    "SelectParameters":{
 
+      "type":"structure",
 
+      "required":[
 
+        "InputSerialization",
 
+        "ExpressionType",
 
+        "Expression",
 
+        "OutputSerialization"
 
+      ],
 
+      "members":{
 
+        "InputSerialization":{
 
+          "shape":"InputSerialization",
 
+          
+        },
 
+        "ExpressionType":{
 
+          "shape":"ExpressionType",
 
+          
+        },
 
+        "Expression":{
 
+          "shape":"Expression",
 
+          
+        },
 
+        "OutputSerialization":{
 
+          "shape":"OutputSerialization",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ServerSideEncryption":{
 
+      "type":"string",
 
+      "enum":[
 
+        "AES256",
 
+        "aws:kms"
 
+      ]
 
+    },
 
+    "ServerSideEncryptionByDefault":{
 
+      "type":"structure",
 
+      "required":["SSEAlgorithm"],
 
+      "members":{
 
+        "SSEAlgorithm":{
 
+          "shape":"ServerSideEncryption",
 
+          
+        },
 
+        "KMSMasterKeyID":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ServerSideEncryptionConfiguration":{
 
+      "type":"structure",
 
+      "required":["Rules"],
 
+      "members":{
 
+        "Rules":{
 
+          "shape":"ServerSideEncryptionRules",
 
+          
+          "locationName":"Rule"
 
+        }
 
+      },
 
+      
+    },
 
+    "ServerSideEncryptionRule":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ApplyServerSideEncryptionByDefault":{
 
+          "shape":"ServerSideEncryptionByDefault",
 
+          
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "ServerSideEncryptionRules":{
 
+      "type":"list",
 
+      "member":{"shape":"ServerSideEncryptionRule"},
 
+      "flattened":true
 
+    },
 
+    "Setting":{"type":"boolean"},
 
+    "Size":{"type":"integer"},
 
+    "SkipValidation":{"type":"boolean"},
 
+    "SourceSelectionCriteria":{
 
+      "type":"structure",
 
+      "members":{
 
+        "SseKmsEncryptedObjects":{
 
+          "shape":"SseKmsEncryptedObjects",
 
+          
+        },
 
+        "ReplicaModifications":{
 
+          "shape":"ReplicaModifications",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "SseKmsEncryptedObjects":{
 
+      "type":"structure",
 
+      "required":["Status"],
 
+      "members":{
 
+        "Status":{
 
+          "shape":"SseKmsEncryptedObjectsStatus",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "SseKmsEncryptedObjectsStatus":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Enabled",
 
+        "Disabled"
 
+      ]
 
+    },
 
+    "Start":{"type":"long"},
 
+    "StartAfter":{"type":"string"},
 
+    "Stats":{
 
+      "type":"structure",
 
+      "members":{
 
+        "BytesScanned":{
 
+          "shape":"BytesScanned",
 
+          
+        },
 
+        "BytesProcessed":{
 
+          "shape":"BytesProcessed",
 
+          
+        },
 
+        "BytesReturned":{
 
+          "shape":"BytesReturned",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "StatsEvent":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Details":{
 
+          "shape":"Stats",
 
+          
+          "eventpayload":true
 
+        }
 
+      },
 
+      
+      "event":true
 
+    },
 
+    "StorageClass":{
 
+      "type":"string",
 
+      "enum":[
 
+        "STANDARD",
 
+        "REDUCED_REDUNDANCY",
 
+        "STANDARD_IA",
 
+        "ONEZONE_IA",
 
+        "INTELLIGENT_TIERING",
 
+        "GLACIER",
 
+        "DEEP_ARCHIVE",
 
+        "OUTPOSTS",
 
+        "GLACIER_IR",
 
+        "SNOW"
 
+      ]
 
+    },
 
+    "StorageClassAnalysis":{
 
+      "type":"structure",
 
+      "members":{
 
+        "DataExport":{
 
+          "shape":"StorageClassAnalysisDataExport",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "StorageClassAnalysisDataExport":{
 
+      "type":"structure",
 
+      "required":[
 
+        "OutputSchemaVersion",
 
+        "Destination"
 
+      ],
 
+      "members":{
 
+        "OutputSchemaVersion":{
 
+          "shape":"StorageClassAnalysisSchemaVersion",
 
+          
+        },
 
+        "Destination":{
 
+          "shape":"AnalyticsExportDestination",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "StorageClassAnalysisSchemaVersion":{
 
+      "type":"string",
 
+      "enum":["V_1"]
 
+    },
 
+    "Suffix":{"type":"string"},
 
+    "Tag":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Key",
 
+        "Value"
 
+      ],
 
+      "members":{
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+        },
 
+        "Value":{
 
+          "shape":"Value",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "TagCount":{"type":"integer"},
 
+    "TagSet":{
 
+      "type":"list",
 
+      "member":{
 
+        "shape":"Tag",
 
+        "locationName":"Tag"
 
+      }
 
+    },
 
+    "Tagging":{
 
+      "type":"structure",
 
+      "required":["TagSet"],
 
+      "members":{
 
+        "TagSet":{
 
+          "shape":"TagSet",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "TaggingDirective":{
 
+      "type":"string",
 
+      "enum":[
 
+        "COPY",
 
+        "REPLACE"
 
+      ]
 
+    },
 
+    "TaggingHeader":{"type":"string"},
 
+    "TargetBucket":{"type":"string"},
 
+    "TargetGrant":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Grantee":{
 
+          "shape":"Grantee",
 
+          
+        },
 
+        "Permission":{
 
+          "shape":"BucketLogsPermission",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "TargetGrants":{
 
+      "type":"list",
 
+      "member":{
 
+        "shape":"TargetGrant",
 
+        "locationName":"Grant"
 
+      }
 
+    },
 
+    "TargetPrefix":{"type":"string"},
 
+    "Tier":{
 
+      "type":"string",
 
+      "enum":[
 
+        "Standard",
 
+        "Bulk",
 
+        "Expedited"
 
+      ]
 
+    },
 
+    "Tiering":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Days",
 
+        "AccessTier"
 
+      ],
 
+      "members":{
 
+        "Days":{
 
+          "shape":"IntelligentTieringDays",
 
+          
+        },
 
+        "AccessTier":{
 
+          "shape":"IntelligentTieringAccessTier",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "TieringList":{
 
+      "type":"list",
 
+      "member":{"shape":"Tiering"},
 
+      "flattened":true
 
+    },
 
+    "Token":{"type":"string"},
 
+    "TopicArn":{"type":"string"},
 
+    "TopicConfiguration":{
 
+      "type":"structure",
 
+      "required":[
 
+        "TopicArn",
 
+        "Events"
 
+      ],
 
+      "members":{
 
+        "Id":{"shape":"NotificationId"},
 
+        "TopicArn":{
 
+          "shape":"TopicArn",
 
+          
+          "locationName":"Topic"
 
+        },
 
+        "Events":{
 
+          "shape":"EventList",
 
+          
+          "locationName":"Event"
 
+        },
 
+        "Filter":{"shape":"NotificationConfigurationFilter"}
 
+      },
 
+      
+    },
 
+    "TopicConfigurationDeprecated":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Id":{"shape":"NotificationId"},
 
+        "Events":{
 
+          "shape":"EventList",
 
+          
+          "locationName":"Event"
 
+        },
 
+        "Event":{
 
+          "shape":"Event",
 
+          
+          "deprecated":true
 
+        },
 
+        "Topic":{
 
+          "shape":"TopicArn",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "TopicConfigurationList":{
 
+      "type":"list",
 
+      "member":{"shape":"TopicConfiguration"},
 
+      "flattened":true
 
+    },
 
+    "Transition":{
 
+      "type":"structure",
 
+      "members":{
 
+        "Date":{
 
+          "shape":"Date",
 
+          
+        },
 
+        "Days":{
 
+          "shape":"Days",
 
+          
+        },
 
+        "StorageClass":{
 
+          "shape":"TransitionStorageClass",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "TransitionList":{
 
+      "type":"list",
 
+      "member":{"shape":"Transition"},
 
+      "flattened":true
 
+    },
 
+    "TransitionStorageClass":{
 
+      "type":"string",
 
+      "enum":[
 
+        "GLACIER",
 
+        "STANDARD_IA",
 
+        "ONEZONE_IA",
 
+        "INTELLIGENT_TIERING",
 
+        "DEEP_ARCHIVE",
 
+        "GLACIER_IR"
 
+      ]
 
+    },
 
+    "Type":{
 
+      "type":"string",
 
+      "enum":[
 
+        "CanonicalUser",
 
+        "AmazonCustomerByEmail",
 
+        "Group"
 
+      ]
 
+    },
 
+    "URI":{"type":"string"},
 
+    "UploadIdMarker":{"type":"string"},
 
+    "UploadPartCopyOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "CopySourceVersionId":{
 
+          "shape":"CopySourceVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-version-id"
 
+        },
 
+        "CopyPartResult":{
 
+          "shape":"CopyPartResult",
 
+          
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      },
 
+      "payload":"CopyPartResult"
 
+    },
 
+    "UploadPartCopyRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "CopySource",
 
+        "Key",
 
+        "PartNumber",
 
+        "UploadId"
 
+      ],
 
+      "members":{
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "CopySource":{
 
+          "shape":"CopySource",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source"
 
+        },
 
+        "CopySourceIfMatch":{
 
+          "shape":"CopySourceIfMatch",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-if-match"
 
+        },
 
+        "CopySourceIfModifiedSince":{
 
+          "shape":"CopySourceIfModifiedSince",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-if-modified-since"
 
+        },
 
+        "CopySourceIfNoneMatch":{
 
+          "shape":"CopySourceIfNoneMatch",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-if-none-match"
 
+        },
 
+        "CopySourceIfUnmodifiedSince":{
 
+          "shape":"CopySourceIfUnmodifiedSince",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-if-unmodified-since"
 
+        },
 
+        "CopySourceRange":{
 
+          "shape":"CopySourceRange",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-range"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "PartNumber":{
 
+          "shape":"PartNumber",
 
+          
+          "location":"querystring",
 
+          "locationName":"partNumber"
 
+        },
 
+        "UploadId":{
 
+          "shape":"MultipartUploadId",
 
+          
+          "location":"querystring",
 
+          "locationName":"uploadId"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "CopySourceSSECustomerAlgorithm":{
 
+          "shape":"CopySourceSSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-server-side-encryption-customer-algorithm"
 
+        },
 
+        "CopySourceSSECustomerKey":{
 
+          "shape":"CopySourceSSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-server-side-encryption-customer-key"
 
+        },
 
+        "CopySourceSSECustomerKeyMD5":{
 
+          "shape":"CopySourceSSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-copy-source-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        },
 
+        "ExpectedSourceBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-source-expected-bucket-owner"
 
+        }
 
+      }
 
+    },
 
+    "UploadPartOutput":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption"
 
+        },
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+          "location":"header",
 
+          "locationName":"ETag"
 
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32"
 
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32c"
 
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha1"
 
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha256"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-bucket-key-enabled"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-charged"
 
+        }
 
+      }
 
+    },
 
+    "UploadPartRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "Bucket",
 
+        "Key",
 
+        "PartNumber",
 
+        "UploadId"
 
+      ],
 
+      "members":{
 
+        "Body":{
 
+          "shape":"Body",
 
+          
+          "streaming":true
 
+        },
 
+        "Bucket":{
 
+          "shape":"BucketName",
 
+          
+          "contextParam":{"name":"Bucket"},
 
+          "location":"uri",
 
+          "locationName":"Bucket"
 
+        },
 
+        "ContentLength":{
 
+          "shape":"ContentLength",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Length"
 
+        },
 
+        "ContentMD5":{
 
+          "shape":"ContentMD5",
 
+          
+          "location":"header",
 
+          "locationName":"Content-MD5"
 
+        },
 
+        "ChecksumAlgorithm":{
 
+          "shape":"ChecksumAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-sdk-checksum-algorithm"
 
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32"
 
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-crc32c"
 
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha1"
 
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-checksum-sha256"
 
+        },
 
+        "Key":{
 
+          "shape":"ObjectKey",
 
+          
+          "location":"uri",
 
+          "locationName":"Key"
 
+        },
 
+        "PartNumber":{
 
+          "shape":"PartNumber",
 
+          
+          "location":"querystring",
 
+          "locationName":"partNumber"
 
+        },
 
+        "UploadId":{
 
+          "shape":"MultipartUploadId",
 
+          
+          "location":"querystring",
 
+          "locationName":"uploadId"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSECustomerKey":{
 
+          "shape":"SSECustomerKey",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "RequestPayer":{
 
+          "shape":"RequestPayer",
 
+          "location":"header",
 
+          "locationName":"x-amz-request-payer"
 
+        },
 
+        "ExpectedBucketOwner":{
 
+          "shape":"AccountId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-expected-bucket-owner"
 
+        }
 
+      },
 
+      "payload":"Body"
 
+    },
 
+    "UserMetadata":{
 
+      "type":"list",
 
+      "member":{
 
+        "shape":"MetadataEntry",
 
+        "locationName":"MetadataEntry"
 
+      }
 
+    },
 
+    "Value":{"type":"string"},
 
+    "VersionCount":{"type":"integer"},
 
+    "VersionIdMarker":{"type":"string"},
 
+    "VersioningConfiguration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "MFADelete":{
 
+          "shape":"MFADelete",
 
+          
+          "locationName":"MfaDelete"
 
+        },
 
+        "Status":{
 
+          "shape":"BucketVersioningStatus",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "WebsiteConfiguration":{
 
+      "type":"structure",
 
+      "members":{
 
+        "ErrorDocument":{
 
+          "shape":"ErrorDocument",
 
+          
+        },
 
+        "IndexDocument":{
 
+          "shape":"IndexDocument",
 
+          
+        },
 
+        "RedirectAllRequestsTo":{
 
+          "shape":"RedirectAllRequestsTo",
 
+          
+        },
 
+        "RoutingRules":{
 
+          "shape":"RoutingRules",
 
+          
+        }
 
+      },
 
+      
+    },
 
+    "WebsiteRedirectLocation":{"type":"string"},
 
+    "WriteGetObjectResponseRequest":{
 
+      "type":"structure",
 
+      "required":[
 
+        "RequestRoute",
 
+        "RequestToken"
 
+      ],
 
+      "members":{
 
+        "RequestRoute":{
 
+          "shape":"RequestRoute",
 
+          
+          "hostLabel":true,
 
+          "location":"header",
 
+          "locationName":"x-amz-request-route"
 
+        },
 
+        "RequestToken":{
 
+          "shape":"RequestToken",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-request-token"
 
+        },
 
+        "Body":{
 
+          "shape":"Body",
 
+          
+          "streaming":true
 
+        },
 
+        "StatusCode":{
 
+          "shape":"GetObjectResponseStatusCode",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-status"
 
+        },
 
+        "ErrorCode":{
 
+          "shape":"ErrorCode",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-error-code"
 
+        },
 
+        "ErrorMessage":{
 
+          "shape":"ErrorMessage",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-error-message"
 
+        },
 
+        "AcceptRanges":{
 
+          "shape":"AcceptRanges",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-accept-ranges"
 
+        },
 
+        "CacheControl":{
 
+          "shape":"CacheControl",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-Cache-Control"
 
+        },
 
+        "ContentDisposition":{
 
+          "shape":"ContentDisposition",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-Content-Disposition"
 
+        },
 
+        "ContentEncoding":{
 
+          "shape":"ContentEncoding",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-Content-Encoding"
 
+        },
 
+        "ContentLanguage":{
 
+          "shape":"ContentLanguage",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-Content-Language"
 
+        },
 
+        "ContentLength":{
 
+          "shape":"ContentLength",
 
+          
+          "location":"header",
 
+          "locationName":"Content-Length"
 
+        },
 
+        "ContentRange":{
 
+          "shape":"ContentRange",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-Content-Range"
 
+        },
 
+        "ContentType":{
 
+          "shape":"ContentType",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-Content-Type"
 
+        },
 
+        "ChecksumCRC32":{
 
+          "shape":"ChecksumCRC32",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-checksum-crc32"
 
+        },
 
+        "ChecksumCRC32C":{
 
+          "shape":"ChecksumCRC32C",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-checksum-crc32c"
 
+        },
 
+        "ChecksumSHA1":{
 
+          "shape":"ChecksumSHA1",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-checksum-sha1"
 
+        },
 
+        "ChecksumSHA256":{
 
+          "shape":"ChecksumSHA256",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-checksum-sha256"
 
+        },
 
+        "DeleteMarker":{
 
+          "shape":"DeleteMarker",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-delete-marker"
 
+        },
 
+        "ETag":{
 
+          "shape":"ETag",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-ETag"
 
+        },
 
+        "Expires":{
 
+          "shape":"Expires",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-Expires"
 
+        },
 
+        "Expiration":{
 
+          "shape":"Expiration",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-expiration"
 
+        },
 
+        "LastModified":{
 
+          "shape":"LastModified",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-Last-Modified"
 
+        },
 
+        "MissingMeta":{
 
+          "shape":"MissingMeta",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-missing-meta"
 
+        },
 
+        "Metadata":{
 
+          "shape":"Metadata",
 
+          
+          "location":"headers",
 
+          "locationName":"x-amz-meta-"
 
+        },
 
+        "ObjectLockMode":{
 
+          "shape":"ObjectLockMode",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-object-lock-mode"
 
+        },
 
+        "ObjectLockLegalHoldStatus":{
 
+          "shape":"ObjectLockLegalHoldStatus",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-object-lock-legal-hold"
 
+        },
 
+        "ObjectLockRetainUntilDate":{
 
+          "shape":"ObjectLockRetainUntilDate",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-object-lock-retain-until-date"
 
+        },
 
+        "PartsCount":{
 
+          "shape":"PartsCount",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-mp-parts-count"
 
+        },
 
+        "ReplicationStatus":{
 
+          "shape":"ReplicationStatus",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-replication-status"
 
+        },
 
+        "RequestCharged":{
 
+          "shape":"RequestCharged",
 
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-request-charged"
 
+        },
 
+        "Restore":{
 
+          "shape":"Restore",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-restore"
 
+        },
 
+        "ServerSideEncryption":{
 
+          "shape":"ServerSideEncryption",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-server-side-encryption"
 
+        },
 
+        "SSECustomerAlgorithm":{
 
+          "shape":"SSECustomerAlgorithm",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-server-side-encryption-customer-algorithm"
 
+        },
 
+        "SSEKMSKeyId":{
 
+          "shape":"SSEKMSKeyId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-server-side-encryption-aws-kms-key-id"
 
+        },
 
+        "SSECustomerKeyMD5":{
 
+          "shape":"SSECustomerKeyMD5",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-server-side-encryption-customer-key-MD5"
 
+        },
 
+        "StorageClass":{
 
+          "shape":"StorageClass",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-storage-class"
 
+        },
 
+        "TagCount":{
 
+          "shape":"TagCount",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-tagging-count"
 
+        },
 
+        "VersionId":{
 
+          "shape":"ObjectVersionId",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-version-id"
 
+        },
 
+        "BucketKeyEnabled":{
 
+          "shape":"BucketKeyEnabled",
 
+          
+          "location":"header",
 
+          "locationName":"x-amz-fwd-header-x-amz-server-side-encryption-bucket-key-enabled"
 
+        }
 
+      },
 
+      "payload":"Body"
 
+    },
 
+    "Years":{"type":"integer"}
 
+  },
 
+  
+  "clientContextParams":{
 
+    "Accelerate":{
 
+      
+      "type":"boolean"
 
+    },
 
+    "DisableMultiRegionAccessPoints":{
 
+      
+      "type":"boolean"
 
+    },
 
+    "ForcePathStyle":{
 
+      
+      "type":"boolean"
 
+    },
 
+    "UseArnRegion":{
 
+      
+      "type":"boolean"
 
+    }
 
+  }
 
+}

+ 4 - 0
aws/test.bat
مشاهده فایل 

@@ -1,11 +1,15 @@
 
+aws sts get-caller-identity --endpoint-url http://localhost:8080
 
 aws s3 ls --endpoint-url http://localhost:8080
 
 aws s3 mb s3://my-test-bucket --endpoint-url http://localhost:8080
 
 echo "Hello, S3!" > test.txt
 
 aws s3 cp test.txt s3://my-test-bucket/test.txt --endpoint-url http://localhost:8080
 
+aws s3 cp "DSC01472 copy.jpg" "s3://my-test-bucket/DSC01472 copy.jpg" --endpoint-url http://localhost:8080
 
 aws s3 cp s3://my-test-bucket/test.txt downloaded.txt --endpoint-url http://localhost:8080
 
 aws s3 ls --endpoint-url http://localhost:8080
 
 aws s3 ls s3://my-test-bucket/ --endpoint-url http://localhost:8080
 
 aws s3 rm s3://my-test-bucket/test.txt --endpoint-url http://localhost:8080
 
+aws s3 rm "s3://my-test-bucket/DSC01472 copy.jpg" --endpoint-url http://localhost:8080
 
 aws sts get-caller-identity --endpoint-url http://localhost:8080
 
 aws s3 rb s3://my-test-bucket --endpoint-url=http://localhost:8080
 
 aws s3 ls --endpoint-url http://localhost:8080
 
+

BIN
aws/uploads/123456789012/my-test-bucket/DSC01472 copy.jpg
مشاهده فایل


برخی فایل ها در این مقایسه diff نمایش داده نمی شوند زیرا تعداد فایل ها بسیار زیاد است