<artifactId>maven-dependency-plugin</artifactId>
        <executions>
          <execution>
            <id>unpack-jline-native</id>
            <goals>
              <goal>unpack-dependencies</goal>
            </goals>
            <configuration>
              <includeArtifactIds>jline-native</includeArtifactIds>
              <includes>org/jline/nativ/**</includes>
            </configuration>
          </execution>

		}
	}

	modTime = UTCNow() // We only preserve modTime if dstOpts.MTime is true.
	// in all other cases mtime is latest.

	fi.VersionID = versionID // set any new versionID we might have created
	fi.ModTime = modTime     // set modTime for the new versionID
	if !dstOpts.MTime.IsZero() {
		modTime = dstOpts.MTime
		fi.ModTime = dstOpts.MTime
	}

			if modTime.IsZero() {
				wait := deleteMultipartCleanupSleeper.Timer(ctx)
				fi, err := disk.ReadVersion(ctx, "", minioMetaMultipartBucket, uploadIDPath, "", ReadOptions{})
				if err != nil {
					return nil
				}
				modTime = fi.ModTime
				wait()
			}
			if time.Since(modTime) < globalAPIConfig.getStaleUploadsExpiry() {
				return nil
			}

   * symmetry. Moreover, we don't want to reconstruct a native type variable {@code <A>} using our
   * implementation unless some of its bounds have changed in resolution. This avoids creating
   * unequal TypeVariable implementation unnecessarily. When the bounds do change, however, it's
   * fine for the synthetic TypeVariable to be unequal to any native TypeVariable anyway.
   */

// object should be returned by ObjectLayer.Walk method
type WalkVersionsSortOrder uint8

const (
	// WalkVersionsSortAsc - Sort in ascending order of ModTime
	WalkVersionsSortAsc WalkVersionsSortOrder = iota
	// WalkVersionsSortDesc - Sort in descending order of ModTime
	WalkVersionsSortDesc
)

// ObjectOptions represents object options for ObjectLayer object operations
type ObjectOptions struct {

   * symmetry. Moreover, we don't want to reconstruct a native type variable {@code <A>} using our
   * implementation unless some of its bounds have changed in resolution. This avoids creating
   * unequal TypeVariable implementation unnecessarily. When the bounds do change, however, it's
   * fine for the synthetic TypeVariable to be unequal to any native TypeVariable anyway.
   */

		return
	}

	OA := new(getObjectAttributesResponse)

	if opts.Versioned {
		w.Header().Set(xhttp.AmzVersionID, objInfo.VersionID)
	}

	lastModified := objInfo.ModTime.UTC().Format(http.TimeFormat)
	w.Header().Set(xhttp.LastModified, lastModified)
	w.Header().Del(xhttp.ContentType)

	if _, ok := opts.ObjectAttributes[xhttp.Checksum]; ok {

					_, err := z.DeleteObject(ctx,
						bucket,
						version.Name,
						ObjectOptions{
							Versioned:         true,
							VersionID:         versionID,
							MTime:             version.ModTime,
							DeleteReplication: version.ReplicationState,
							SrcPoolIdx:        poolIdx,
							DataMovement:      true,
							DeleteMarker:      true, // make sure we create a delete marker

		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}
	if r.Header.Get(xMinIOExtract) == "true" && HasSuffix(object, archiveExt) {
		opts := ObjectOptions{VersionID: objInfo.VersionID, MTime: objInfo.ModTime}
		if _, err := updateObjectMetadataWithZipInfo(ctx, objectAPI, bucket, object, opts); err != nil {
			writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
			return
		}
	}

main ones is that now the parameters of your functions with `Annotated` would **not be affected** at all.

If you call those functions in **other places in your code**, the actual **default values** will be kept, your editor will help you notice missing **required arguments**, Python will require you to pass required arguments at **runtime**, you will be able to **use the same functions** for different things and with different libraries (e.g. **Typer** will soon support `Annotated` too,...