AWS SDK for Go v2 - S3 Multipart Upload Operations

func (c *Client) CreateMultipartUpload(
    ctx context.Context,
    params *CreateMultipartUploadInput,
    optFns ...func(*Options)
) (*CreateMultipartUploadOutput, error)

type CreateMultipartUploadInput struct {
    // Required: The name of the bucket where the multipart upload is initiated
    Bucket *string

    // Required: Object key for which the multipart upload is to be initiated
    Key *string

    // The canned ACL to apply to the object (not supported for directory buckets)
    ACL types.ObjectCannedACL

    // Whether Amazon S3 should use an S3 Bucket Key for object encryption with SSE-KMS
    BucketKeyEnabled *bool

    // Specifies caching behavior along the request/reply chain
    CacheControl *string

    // Algorithm to create the checksum for the object (CRC32, CRC32C, SHA1, SHA256)
    ChecksumAlgorithm types.ChecksumAlgorithm

    // Checksum type that determines how part-level checksums combine to create object-level checksum
    ChecksumType types.ChecksumType

    // Specifies presentational information for the object
    ContentDisposition *string

    // Content encodings applied to the object
    ContentEncoding *string

    // The language that the content is in
    ContentLanguage *string

    // A standard MIME type describing the format of the object data
    ContentType *string

    // The account ID of the expected bucket owner
    ExpectedBucketOwner *string

    // The date and time at which the object is no longer cacheable
    Expires *time.Time

    // Grant full control permissions (not supported for directory buckets)
    GrantFullControl *string

    // Grant read permissions (not supported for directory buckets)
    GrantRead *string

    // Grant read ACL permissions (not supported for directory buckets)
    GrantReadACP *string

    // Grant write ACL permissions (not supported for directory buckets)
    GrantWriteACP *string

    // A map of metadata to store with the object in S3
    Metadata map[string]string

    // Legal hold status to apply to the uploaded object (not supported for directory buckets)
    ObjectLockLegalHoldStatus types.ObjectLockLegalHoldStatus

    // Object Lock mode to apply (not supported for directory buckets)
    ObjectLockMode types.ObjectLockMode

    // Date and time when Object Lock expires (not supported for directory buckets)
    ObjectLockRetainUntilDate *time.Time

    // Confirms requester knows they will be charged (not supported for directory buckets)
    RequestPayer types.RequestPayer

    // Algorithm to use for SSE-C encryption (not supported for directory buckets)
    SSECustomerAlgorithm *string

    // Customer-provided encryption key for SSE-C (not supported for directory buckets)
    SSECustomerKey *string

    // MD5 digest of the SSE-C encryption key (not supported for directory buckets)
    SSECustomerKeyMD5 *string

    // KMS Encryption Context as Base64 encoded UTF-8 JSON
    SSEKMSEncryptionContext *string

    // KMS key ID (Key ID, Key ARN, or Key Alias) for object encryption
    SSEKMSKeyId *string

    // Server-side encryption algorithm (AES256, aws:kms, aws:kms:dsse)
    ServerSideEncryption types.ServerSideEncryption

    // Storage class (STANDARD, REDUCED_REDUNDANCY, GLACIER, etc.)
    StorageClass types.StorageClass

    // Tag-set for the object (not supported for directory buckets)
    Tagging *string

    // Redirect requests for this object to another object or URL (not supported for directory buckets)
    WebsiteRedirectLocation *string
}

type CreateMultipartUploadOutput struct {
    // Date when the initiated multipart upload becomes eligible for abort
    AbortDate *time.Time

    // Lifecycle rule ID that defines the abort action
    AbortRuleId *string

    // Name of the bucket to which the multipart upload was initiated
    Bucket *string

    // Whether the multipart upload uses an S3 Bucket Key for SSE-KMS
    BucketKeyEnabled *bool

    // Algorithm used to create a checksum of the object
    ChecksumAlgorithm types.ChecksumAlgorithm

    // Checksum type that will be used
    ChecksumType types.ChecksumType

    // Object key for which the multipart upload was initiated
    Key *string

    // Indicates requester was successfully charged (not supported for directory buckets)
    RequestCharged types.RequestCharged

    // SSE-C algorithm confirmation (not supported for directory buckets)
    SSECustomerAlgorithm *string

    // SSE-C key MD5 for integrity verification (not supported for directory buckets)
    SSECustomerKeyMD5 *string

    // KMS Encryption Context if present
    SSEKMSEncryptionContext *string

    // ID of the KMS key used for object encryption
    SSEKMSKeyId *string

    // Server-side encryption algorithm used
    ServerSideEncryption types.ServerSideEncryption

    // Required: ID for the initiated multipart upload
    UploadId *string

    // Metadata pertaining to the operation's result
    ResultMetadata middleware.Metadata
}

func (c *Client) UploadPart(
    ctx context.Context,
    params *UploadPartInput,
    optFns ...func(*Options)
) (*UploadPartOutput, error)

type UploadPartInput struct {
    // Required: The name of the bucket to which the multipart upload was initiated
    Bucket *string

    // Required: Object key for which the multipart upload was initiated
    Key *string

    // Required: Part number (1-10,000). Uniquely identifies the part and its position
    PartNumber *int32

    // Required: Upload ID identifying the multipart upload
    UploadId *string

    // Object data to upload
    Body io.Reader

    // Checksum algorithm used by SDK (CRC32, CRC32C, SHA1, SHA256, CRC64NVME)
    ChecksumAlgorithm types.ChecksumAlgorithm

    // Base64 encoded, 32-bit CRC32 checksum of the object
    ChecksumCRC32 *string

    // Base64 encoded, 32-bit CRC32C checksum of the object
    ChecksumCRC32C *string

    // Base64 encoded, 64-bit CRC64NVME checksum of the part
    ChecksumCRC64NVME *string

    // Base64 encoded, 160-bit SHA1 digest of the object
    ChecksumSHA1 *string

    // Base64 encoded, 256-bit SHA256 digest of the object
    ChecksumSHA256 *string

    // Size of the body in bytes (useful when size cannot be determined automatically)
    ContentLength *int64

    // Base64 encoded 128-bit MD5 digest of the part data (not supported for directory buckets)
    ContentMD5 *string

    // The account ID of the expected bucket owner
    ExpectedBucketOwner *string

    // Confirms requester knows they will be charged (not supported for directory buckets)
    RequestPayer types.RequestPayer

    // Algorithm to use for SSE-C encryption (not supported for directory buckets)
    SSECustomerAlgorithm *string

    // Customer-provided encryption key for SSE-C (not supported for directory buckets)
    SSECustomerKey *string

    // MD5 digest of the SSE-C encryption key (not supported for directory buckets)
    SSECustomerKeyMD5 *string
}

type UploadPartOutput struct {
    // Whether the multipart upload uses an S3 Bucket Key for SSE-KMS
    BucketKeyEnabled *bool

    // Base64 encoded, 32-bit CRC32 checksum of the object
    ChecksumCRC32 *string

    // Base64 encoded, 32-bit CRC32C checksum of the object
    ChecksumCRC32C *string

    // Base64 encoded, 64-bit CRC64NVME checksum of the part
    ChecksumCRC64NVME *string

    // Base64 encoded, 160-bit SHA1 digest of the object
    ChecksumSHA1 *string

    // Base64 encoded, 256-bit SHA256 digest of the object
    ChecksumSHA256 *string

    // Entity tag for the uploaded object
    ETag *string

    // Indicates requester was successfully charged (not supported for directory buckets)
    RequestCharged types.RequestCharged

    // SSE-C algorithm confirmation (not supported for directory buckets)
    SSECustomerAlgorithm *string

    // SSE-C key MD5 for integrity verification (not supported for directory buckets)
    SSECustomerKeyMD5 *string

    // ID of the KMS key used for object encryption
    SSEKMSKeyId *string

    // Server-side encryption algorithm used
    ServerSideEncryption types.ServerSideEncryption

    // Metadata pertaining to the operation's result
    ResultMetadata middleware.Metadata
}

func (c *Client) UploadPartCopy(
    ctx context.Context,
    params *UploadPartCopyInput,
    optFns ...func(*Options)
) (*UploadPartCopyOutput, error)

type UploadPartCopyInput struct {
    // Required: The destination bucket name
    Bucket *string

    // Required: Specifies the source object (format: sourcebucket/sourcekey or ARN)
    CopySource *string

    // Required: Object key for which the multipart upload was initiated
    Key *string

    // Required: Part number (1-10,000)
    PartNumber *int32

    // Required: Upload ID identifying the multipart upload
    UploadId *string

    // Copies the object if its ETag matches the specified tag
    CopySourceIfMatch *string

    // Copies the object if it has been modified since the specified time
    CopySourceIfModifiedSince *time.Time

    // Copies the object if its ETag is different than the specified ETag
    CopySourceIfNoneMatch *string

    // Copies the object if it hasn't been modified since the specified time
    CopySourceIfUnmodifiedSince *time.Time

    // Range of bytes to copy (format: bytes=first-last, minimum 5 MB)
    CopySourceRange *string

    // Algorithm to decrypt the source object with SSE-C (not supported when source is directory bucket)
    CopySourceSSECustomerAlgorithm *string

    // Customer-provided encryption key to decrypt source (not supported when source is directory bucket)
    CopySourceSSECustomerKey *string

    // MD5 digest of the source SSE-C encryption key (not supported when source is directory bucket)
    CopySourceSSECustomerKeyMD5 *string

    // The account ID of the expected destination bucket owner
    ExpectedBucketOwner *string

    // The account ID of the expected source bucket owner
    ExpectedSourceBucketOwner *string

    // Confirms requester knows they will be charged (not supported for directory buckets)
    RequestPayer types.RequestPayer

    // Algorithm to encrypt the destination object with SSE-C (not supported when destination is directory bucket)
    SSECustomerAlgorithm *string

    // Customer-provided encryption key for destination SSE-C (not supported when destination is directory bucket)
    SSECustomerKey *string

    // MD5 digest of the destination SSE-C encryption key (not supported when destination is directory bucket)
    SSECustomerKeyMD5 *string
}

type UploadPartCopyOutput struct {
    // Whether the multipart upload uses an S3 Bucket Key for SSE-KMS
    BucketKeyEnabled *bool

    // Container for all response elements
    CopyPartResult *types.CopyPartResult

    // Version of the source object that was copied (not supported when source is directory bucket)
    CopySourceVersionId *string

    // Indicates requester was successfully charged (not supported for directory buckets)
    RequestCharged types.RequestCharged

    // SSE-C algorithm confirmation (not supported for directory buckets)
    SSECustomerAlgorithm *string

    // SSE-C key MD5 for integrity verification (not supported for directory buckets)
    SSECustomerKeyMD5 *string

    // ID of the KMS key used for object encryption
    SSEKMSKeyId *string

    // Server-side encryption algorithm used
    ServerSideEncryption types.ServerSideEncryption

    // Metadata pertaining to the operation's result
    ResultMetadata middleware.Metadata
}

type CopyPartResult struct {
    // Base64 encoded, 32-bit CRC32 checksum of the part
    ChecksumCRC32 *string

    // Base64 encoded, 32-bit CRC32C checksum of the part
    ChecksumCRC32C *string

    // Base64 encoded, 64-bit CRC64NVME checksum of the part
    ChecksumCRC64NVME *string

    // Base64 encoded, 160-bit SHA1 digest of the part
    ChecksumSHA1 *string

    // Base64 encoded, 256-bit SHA256 digest of the part
    ChecksumSHA256 *string

    // Entity tag of the object
    ETag *string

    // Date and time the object was last modified
    LastModified *time.Time
}

func (c *Client) CompleteMultipartUpload(
    ctx context.Context,
    params *CompleteMultipartUploadInput,
    optFns ...func(*Options)
) (*CompleteMultipartUploadOutput, error)

type CompleteMultipartUploadInput struct {
    // Required: Name of the bucket to which the multipart upload was initiated
    Bucket *string

    // Required: Object key for which the multipart upload was initiated
    Key *string

    // Required: ID for the initiated multipart upload
    UploadId *string

    // Base64 encoded, 32-bit CRC32 checksum of the object
    ChecksumCRC32 *string

    // Base64 encoded, 32-bit CRC32C checksum of the object
    ChecksumCRC32C *string

    // Base64 encoded, 64-bit CRC64NVME checksum of the object
    ChecksumCRC64NVME *string

    // Base64 encoded, 160-bit SHA1 digest of the object
    ChecksumSHA1 *string

    // Base64 encoded, 256-bit SHA256 digest of the object
    ChecksumSHA256 *string

    // Checksum type of the object
    ChecksumType types.ChecksumType

    // The account ID of the expected bucket owner
    ExpectedBucketOwner *string

    // Uploads only if ETag matches (conditional write)
    IfMatch *string

    // Uploads only if key doesn't exist (conditional write, expects '*')
    IfNoneMatch *string

    // Expected total object size of the multipart upload
    MpuObjectSize *int64

    // Container for the multipart upload request information
    MultipartUpload *types.CompletedMultipartUpload

    // Confirms requester knows they will be charged (not supported for directory buckets)
    RequestPayer types.RequestPayer

    // SSE-C algorithm (needed when object was created with checksum, not supported for directory buckets)
    SSECustomerAlgorithm *string

    // SSE-C customer managed key (not supported for directory buckets)
    SSECustomerKey *string

    // MD5 of SSE-C key (not supported for directory buckets)
    SSECustomerKeyMD5 *string
}

type CompletedMultipartUpload struct {
    // Array of CompletedPart data types (must be in ascending order by part number)
    Parts []CompletedPart
}

type CompletedPart struct {
    // Base64 encoded, 32-bit CRC32 checksum of the part
    ChecksumCRC32 *string

    // Base64 encoded, 32-bit CRC32C checksum of the part
    ChecksumCRC32C *string

    // Base64 encoded, 64-bit CRC64NVME checksum of the part
    ChecksumCRC64NVME *string

    // Base64 encoded, 160-bit SHA1 digest of the part
    ChecksumSHA1 *string

    // Base64 encoded, 256-bit SHA256 digest of the part
    ChecksumSHA256 *string

    // Entity tag returned when the part was uploaded
    ETag *string

    // Part number identifying the part (1-10,000)
    PartNumber *int32
}

type CompleteMultipartUploadOutput struct {
    // Name of the bucket containing the newly created object
    Bucket *string

    // Whether the multipart upload uses an S3 Bucket Key for SSE-KMS
    BucketKeyEnabled *bool

    // Base64 encoded, 32-bit CRC32 checksum of the object
    ChecksumCRC32 *string

    // Base64 encoded, 32-bit CRC32C checksum of the object
    ChecksumCRC32C *string

    // Base64 encoded, 64-bit CRC64NVME checksum of the object
    ChecksumCRC64NVME *string

    // Base64 encoded, 160-bit SHA1 digest of the object
    ChecksumSHA1 *string

    // Base64 encoded, 256-bit SHA256 digest of the object
    ChecksumSHA256 *string

    // Checksum type used
    ChecksumType types.ChecksumType

    // Entity tag that identifies the newly created object's data
    ETag *string

    // Expiration date (expiry-date) and rule ID (rule-id) if configured (not supported for directory buckets)
    Expiration *string

    // Object key of the newly created object
    Key *string

    // URI that identifies the newly created object
    Location *string

    // Indicates requester was successfully charged (not supported for directory buckets)
    RequestCharged types.RequestCharged

    // ID of the KMS key used for object encryption
    SSEKMSKeyId *string

    // Server-side encryption algorithm used
    ServerSideEncryption types.ServerSideEncryption

    // Version ID of the newly created object (not supported for directory buckets)
    VersionId *string

    // Metadata pertaining to the operation's result
    ResultMetadata middleware.Metadata
}

func (c *Client) AbortMultipartUpload(
    ctx context.Context,
    params *AbortMultipartUploadInput,
    optFns ...func(*Options)
) (*AbortMultipartUploadOutput, error)

type AbortMultipartUploadInput struct {
    // Required: The bucket name to which the upload was taking place
    Bucket *string

    // Required: Key of the object for which the multipart upload was initiated
    Key *string

    // Required: Upload ID that identifies the multipart upload
    UploadId *string

    // The account ID of the expected bucket owner
    ExpectedBucketOwner *string

    // Aborts upload only if initiated on the provided timestamp (directory buckets only)
    IfMatchInitiatedTime *time.Time

    // Confirms requester knows they will be charged (not supported for directory buckets)
    RequestPayer types.RequestPayer
}

type AbortMultipartUploadOutput struct {
    // Indicates requester was successfully charged (not supported for directory buckets)
    RequestCharged types.RequestCharged

    // Metadata pertaining to the operation's result
    ResultMetadata middleware.Metadata
}

func (c *Client) ListMultipartUploads(
    ctx context.Context,
    params *ListMultipartUploadsInput,
    optFns ...func(*Options)
) (*ListMultipartUploadsOutput, error)

type ListMultipartUploadsInput struct {
    // Required: The name of the bucket to which the multipart upload was initiated
    Bucket *string

    // Character used to group keys (delimiter filtering)
    Delimiter *string

    // Encoding type for object keys in response (url)
    EncodingType types.EncodingType

    // The account ID of the expected bucket owner
    ExpectedBucketOwner *string

    // Specifies the multipart upload after which listing should begin
    KeyMarker *string

    // Maximum number of multipart uploads to return (1-1,000, default 1,000)
    MaxUploads *int32

    // Lists uploads only for keys that begin with the specified prefix
    Prefix *string

    // Confirms requester knows they will be charged (not supported for directory buckets)
    RequestPayer types.RequestPayer

    // Together with key-marker, specifies where listing should begin (not supported for directory buckets)
    UploadIdMarker *string
}

type ListMultipartUploadsOutput struct {
    // Name of the bucket to which the multipart upload was initiated
    Bucket *string

    // Distinct key prefixes containing the delimiter
    CommonPrefixes []types.CommonPrefix

    // Delimiter specified in the request
    Delimiter *string

    // Encoding type used by Amazon S3 to encode object keys
    EncodingType types.EncodingType

    // Whether the returned list is truncated
    IsTruncated *bool

    // Key at or after which the listing began
    KeyMarker *string

    // Maximum number of multipart uploads that could have been included
    MaxUploads *int32

    // Value to use for key-marker in subsequent request when list is truncated
    NextKeyMarker *string

    // Value to use for upload-id-marker in subsequent request (not supported for directory buckets)
    NextUploadIdMarker *string

    // Prefix specified in the request
    Prefix *string

    // Indicates requester was successfully charged (not supported for directory buckets)
    RequestCharged types.RequestCharged

    // Upload ID marker from the request (not supported for directory buckets)
    UploadIdMarker *string

    // Container for elements related to multipart uploads
    Uploads []types.MultipartUpload

    // Metadata pertaining to the operation's result
    ResultMetadata middleware.Metadata
}

type MultipartUpload struct {
    // Algorithm used to create a checksum of the object
    ChecksumAlgorithm ChecksumAlgorithm

    // Checksum type for the object
    ChecksumType ChecksumType

    // Date and time at which the multipart upload was initiated
    Initiated *time.Time

    // Identifies who initiated the multipart upload
    Initiator *Initiator

    // Key of the object for which the multipart upload was initiated
    Key *string

    // Owner of the object that is part of the multipart upload
    Owner *Owner

    // Class of storage used to store the object
    StorageClass StorageClass

    // Upload ID that identifies the multipart upload
    UploadId *string
}

type Initiator struct {
    // Name of the Principal (not supported for directory buckets after November 21, 2025)
    DisplayName *string

    // Canonical User ID for AWS accounts or user ARN for IAM users
    ID *string
}

type Owner struct {
    // Display name of the owner (supported in specific regions only)
    DisplayName *string

    // ID of the owner
    ID *string
}

type ListMultipartUploadsPaginator struct {
    // Use to iterate through pages
}

// Constructor
func NewListMultipartUploadsPaginator(
    client ListMultipartUploadsAPIClient,
    params *ListMultipartUploadsInput,
    optFns ...func(*ListMultipartUploadsPaginatorOptions)
) *ListMultipartUploadsPaginator

// Check if more pages are available
func (p *ListMultipartUploadsPaginator) HasMorePages() bool

// Retrieve the next page
func (p *ListMultipartUploadsPaginator) NextPage(
    ctx context.Context,
    optFns ...func(*Options)
) (*ListMultipartUploadsOutput, error)

type ListMultipartUploadsPaginatorOptions struct {
    // Maximum number of multipart uploads to return per page
    Limit int32

    // Stop pagination if service returns duplicate token
    StopOnDuplicateToken bool
}

func (c *Client) ListParts(
    ctx context.Context,
    params *ListPartsInput,
    optFns ...func(*Options)
) (*ListPartsOutput, error)

type ListPartsInput struct {
    // Required: The name of the bucket to which the parts are being uploaded
    Bucket *string

    // Required: Object key for which the multipart upload was initiated
    Key *string

    // Required: Upload ID identifying the multipart upload whose parts are being listed
    UploadId *string

    // The account ID of the expected bucket owner
    ExpectedBucketOwner *string

    // Maximum number of parts to return (default/max 1,000)
    MaxParts *int32

    // Part number after which listing should begin
    PartNumberMarker *string

    // Confirms requester knows they will be charged (not supported for directory buckets)
    RequestPayer types.RequestPayer

    // SSE-C algorithm (needed when object was created with checksum, not supported for directory buckets)
    SSECustomerAlgorithm *string

    // SSE-C customer managed key (not supported for directory buckets)
    SSECustomerKey *string

    // MD5 of SSE-C key (not supported for directory buckets)
    SSECustomerKeyMD5 *string
}

type ListPartsOutput struct {
    // Date when the initiated multipart upload becomes eligible for abort (not supported for directory buckets)
    AbortDate *time.Time

    // Lifecycle rule ID that defines the abort action (not supported for directory buckets)
    AbortRuleId *string

    // Name of the bucket to which the multipart upload was initiated
    Bucket *string

    // Algorithm used to create a checksum of the object
    ChecksumAlgorithm types.ChecksumAlgorithm

    // Checksum type used
    ChecksumType types.ChecksumType

    // Identifies who initiated the multipart upload
    Initiator *types.Initiator

    // Indicates whether the returned list of parts is truncated
    IsTruncated *bool

    // Object key for which the multipart upload was initiated
    Key *string

    // Maximum number of parts allowed in the response
    MaxParts *int32

    // When list is truncated, specifies the last part and value for next request
    NextPartNumberMarker *string

    // Object owner (for directory buckets, returns bucket owner for all parts)
    Owner *types.Owner

    // Part number after which listing should begin
    PartNumberMarker *string

    // Container for elements related to parts (zero or more Part elements)
    Parts []types.Part

    // Indicates requester was successfully charged (not supported for directory buckets)
    RequestCharged types.RequestCharged

    // Class of storage used to store the uploaded object
    StorageClass types.StorageClass

    // Upload ID identifying the multipart upload
    UploadId *string

    // Metadata pertaining to the operation's result
    ResultMetadata middleware.Metadata
}

type Part struct {
    // Base64 encoded, 32-bit CRC32 checksum of the part
    ChecksumCRC32 *string

    // Base64 encoded, 32-bit CRC32C checksum of the part
    ChecksumCRC32C *string

    // Base64 encoded, 64-bit CRC64NVME checksum of the part
    ChecksumCRC64NVME *string

    // Base64 encoded, 160-bit SHA1 digest of the part
    ChecksumSHA1 *string

    // Base64 encoded, 256-bit SHA256 digest of the part
    ChecksumSHA256 *string

    // Entity tag returned when the part was uploaded
    ETag *string

    // Date and time at which the part was uploaded
    LastModified *time.Time

    // Part number identifying the part (1-10,000)
    PartNumber *int32

    // Size in bytes of the uploaded part data
    Size *int64
}

type ListPartsPaginator struct {
    // Use to iterate through pages
}

// Constructor
func NewListPartsPaginator(
    client ListPartsAPIClient,
    params *ListPartsInput,
    optFns ...func(*ListPartsPaginatorOptions)
) *ListPartsPaginator

// Check if more pages are available
func (p *ListPartsPaginator) HasMorePages() bool

// Retrieve the next page
func (p *ListPartsPaginator) NextPage(
    ctx context.Context,
    optFns ...func(*Options)
) (*ListPartsOutput, error)

type ListPartsPaginatorOptions struct {
    // Maximum number of parts to return per page
    Limit int32

    // Stop pagination if service returns duplicate token
    StopOnDuplicateToken bool
}

package main

import (
    "bytes"
    "context"
    "fmt"
    "io"
    "log"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/s3"
    "github.com/aws/aws-sdk-go-v2/service/s3/types"
)

func main() {
    ctx := context.TODO()

    // Load AWS configuration
    cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion("us-west-2"))
    if err != nil {
        log.Fatalf("unable to load SDK config: %v", err)
    }

    // Create S3 client
    client := s3.NewFromConfig(cfg)

    bucketName := "my-bucket"
    objectKey := "large-file.dat"
    partSize := int64(5 * 1024 * 1024) // 5 MB parts

    // Step 1: Initiate multipart upload
    createResp, err := client.CreateMultipartUpload(ctx, &s3.CreateMultipartUploadInput{
        Bucket: aws.String(bucketName),
        Key:    aws.String(objectKey),
        // Optional: Specify metadata, encryption, storage class, etc.
        Metadata: map[string]string{
            "description": "Large file uploaded via multipart",
        },
        ServerSideEncryption: types.ServerSideEncryptionAes256,
        ChecksumAlgorithm:    types.ChecksumAlgorithmCrc32,
    })
    if err != nil {
        log.Fatalf("failed to create multipart upload: %v", err)
    }

    uploadId := createResp.UploadId
    fmt.Printf("Initiated multipart upload with ID: %s\n", *uploadId)

    // Step 2: Upload parts
    // In a real application, you would read from a file or stream
    totalSize := int64(15 * 1024 * 1024) // 15 MB total (3 parts)
    numParts := (totalSize + partSize - 1) / partSize
    completedParts := make([]types.CompletedPart, 0, numParts)

    for partNum := int32(1); partNum <= int32(numParts); partNum++ {
        // Calculate part size (last part may be smaller)
        currentPartSize := partSize
        if int64(partNum)*partSize > totalSize {
            currentPartSize = totalSize - int64(partNum-1)*partSize
        }

        // Create sample data for this part
        partData := bytes.Repeat([]byte("x"), int(currentPartSize))

        // Upload the part
        uploadResp, err := client.UploadPart(ctx, &s3.UploadPartInput{
            Bucket:     aws.String(bucketName),
            Key:        aws.String(objectKey),
            PartNumber: aws.Int32(partNum),
            UploadId:   uploadId,
            Body:       bytes.NewReader(partData),
            ContentLength: aws.Int64(currentPartSize),
        })
        if err != nil {
            // If upload fails, abort the multipart upload
            _, abortErr := client.AbortMultipartUpload(ctx, &s3.AbortMultipartUploadInput{
                Bucket:   aws.String(bucketName),
                Key:      aws.String(objectKey),
                UploadId: uploadId,
            })
            if abortErr != nil {
                log.Printf("failed to abort multipart upload: %v", abortErr)
            }
            log.Fatalf("failed to upload part %d: %v", partNum, err)
        }

        fmt.Printf("Uploaded part %d, ETag: %s\n", partNum, *uploadResp.ETag)

        // Add completed part to the list
        completedParts = append(completedParts, types.CompletedPart{
            ETag:       uploadResp.ETag,
            PartNumber: aws.Int32(partNum),
        })
    }

    // Step 3: Complete the multipart upload
    completeResp, err := client.CompleteMultipartUpload(ctx, &s3.CompleteMultipartUploadInput{
        Bucket:   aws.String(bucketName),
        Key:      aws.String(objectKey),
        UploadId: uploadId,
        MultipartUpload: &types.CompletedMultipartUpload{
            Parts: completedParts,
        },
    })
    if err != nil {
        log.Fatalf("failed to complete multipart upload: %v", err)
    }

    fmt.Printf("Successfully completed multipart upload!\n")
    fmt.Printf("Location: %s\n", *completeResp.Location)
    fmt.Printf("ETag: %s\n", *completeResp.ETag)
}

// Example: Upload part by copying from existing object
func uploadPartCopyExample(ctx context.Context, client *s3.Client) {
    uploadResp, err := client.UploadPartCopy(ctx, &s3.UploadPartCopyInput{
        Bucket:     aws.String("destination-bucket"),
        Key:        aws.String("destination-key"),
        PartNumber: aws.Int32(1),
        UploadId:   aws.String("upload-id-here"),
        CopySource: aws.String("source-bucket/source-key"),
        // Optional: Copy only a byte range
        CopySourceRange: aws.String("bytes=0-5242879"), // First 5 MB
    })
    if err != nil {
        log.Fatalf("failed to upload part copy: %v", err)
    }

    fmt.Printf("Part copied, ETag: %s\n", *uploadResp.CopyPartResult.ETag)
}

// Example: List in-progress multipart uploads
func listUploadsExample(ctx context.Context, client *s3.Client) {
    // Using paginator for automatic pagination
    paginator := s3.NewListMultipartUploadsPaginator(client, &s3.ListMultipartUploadsInput{
        Bucket: aws.String("my-bucket"),
    })

    for paginator.HasMorePages() {
        page, err := paginator.NextPage(ctx)
        if err != nil {
            log.Fatalf("failed to list uploads: %v", err)
        }

        for _, upload := range page.Uploads {
            fmt.Printf("Upload ID: %s, Key: %s, Initiated: %v\n",
                *upload.UploadId, *upload.Key, *upload.Initiated)
        }
    }
}

// Example: List parts of an upload
func listPartsExample(ctx context.Context, client *s3.Client, uploadId string) {
    // Using paginator
    paginator := s3.NewListPartsPaginator(client, &s3.ListPartsInput{
        Bucket:   aws.String("my-bucket"),
        Key:      aws.String("my-key"),
        UploadId: aws.String(uploadId),
    })

    for paginator.HasMorePages() {
        page, err := paginator.NextPage(ctx)
        if err != nil {
            log.Fatalf("failed to list parts: %v", err)
        }

        for _, part := range page.Parts {
            fmt.Printf("Part %d: Size=%d bytes, ETag=%s\n",
                *part.PartNumber, *part.Size, *part.ETag)
        }
    }
}

// Example: Abort a multipart upload
func abortUploadExample(ctx context.Context, client *s3.Client, uploadId string) {
    _, err := client.AbortMultipartUpload(ctx, &s3.AbortMultipartUploadInput{
        Bucket:   aws.String("my-bucket"),
        Key:      aws.String("my-key"),
        UploadId: aws.String(uploadId),
    })
    if err != nil {
        log.Fatalf("failed to abort upload: %v", err)
    }

    fmt.Println("Multipart upload aborted successfully")
}

uploadResp, err := client.UploadPart(ctx, input)
if err != nil {
    // Abort the multipart upload on error
    client.AbortMultipartUpload(ctx, &s3.AbortMultipartUploadInput{
        Bucket:   input.Bucket,
        Key:      input.Key,
        UploadId: input.UploadId,
    })
    return fmt.Errorf("upload failed: %w", err)
}

// Use goroutines and sync.WaitGroup for concurrent uploads
var wg sync.WaitGroup
partsChan := make(chan types.CompletedPart, numParts)

for partNum := 1; partNum <= numParts; partNum++ {
    wg.Add(1)
    go func(pn int32) {
        defer wg.Done()
        // Upload part...
        partsChan <- completedPart
    }(int32(partNum))
}

wg.Wait()
close(partsChan)

// Parts from incomplete multipart uploads will be cleaned up after 7 days
AbortIncompleteMultipartUpload: &types.AbortIncompleteMultipartUpload{
    DaysAfterInitiation: aws.Int32(7),
}

createResp, err := client.CreateMultipartUpload(ctx, &s3.CreateMultipartUploadInput{
    Bucket:            aws.String(bucket),
    Key:               aws.String(key),
    ChecksumAlgorithm: types.ChecksumAlgorithmCrc32c,
})

// SDK will automatically calculate and include checksums in UploadPart

// Save to persistent storage
type UploadState struct {
    UploadId       string
    CompletedParts []types.CompletedPart
}

// On resume, list already uploaded parts
listResp, _ := client.ListParts(ctx, &s3.ListPartsInput{
    Bucket:   aws.String(bucket),
    Key:      aws.String(key),
    UploadId: aws.String(uploadId),
})

// Continue from where you left off