What's new in ImagePlayground

extension ImagePlaygroundOptions.CreationStrategy : Equatable {
}

extension ImagePlaygroundOptions.CreationStrategy : Hashable {
}

extension ImagePlaygroundOptions.CreationStrategy : RawRepresentable {
}

public enum CreationStrategy : Int, Codable, Sendable {

    /// An option to let the system select the creation strategy.
    ///
    /// The system chooses the ``CreationStrategy/generateNew`` option by default.
    case automatic

    /// An option to create an image that more closely resembles the original image,
    /// but also has the modifications you specify.
    ///
    /// This option modifies the image using the prompts you specify, but otherwise
    /// tries to preserve as much of the original image as possible. If the system is
    /// unable to apply the prompts to the image in a suitable way, it falls back to
    /// using the ``CreationStrategy/generateNew`` option.
    case editExisting

    /// An option to create a brand new image, driven primarily by the specified
    /// concepts and loosely inspired by the input image.
    ///
    /// This option provides the most reliable way to generate the image and apply
    /// prompts to it.
    case generateNew

    /// Creates a new instance with the specified raw value.
    ///
    /// If there is no value of the type that corresponds with the specified raw
    /// value, this initializer returns `nil`. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     print(PaperSize(rawValue: "Legal"))
    ///     // Prints "Optional(PaperSize.Legal)"
    ///
    ///     print(PaperSize(rawValue: "Tabloid"))
    ///     // Prints "nil"
    ///
    /// - Parameter rawValue: The raw value to use for the new instance.
    public init?(rawValue: Int)

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, *)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    public typealias RawValue = Int

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public var rawValue: Int { get }
}

public struct SizeSpecification : Hashable, Sendable {

    /// Creates a new instance of this structure with a size value that best matches
    /// the specified size.
    ///
    /// - Parameters:
    ///     - size: The image size you want.
    /// - Returns: A structure with a supported size that most closely matches the
    /// requested value in `size`.
    ///
    /// This method finds the supported image size that’s closest to the value in the
    /// `size` parameter. The method considers both the resolution and aspect ratio
    /// of the requested size when choosing the output size.
    public static func closest(to size: CGSize) -> ImagePlaygroundOptions.SizeSpecification

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (a: ImagePlaygroundOptions.SizeSpecification, b: ImagePlaygroundOptions.SizeSpecification) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}