What's new in FoundationModels

public struct AnyDynamicInstructions : DynamicInstructions {

    /// Creates an instance from the dynamic instructions you specify.
    ///
    /// - Parameters:
    ///   - dynamicInstructions: The dynamic instructions.
    public init(_ dynamicInstructions: any DynamicInstructions)

    /// Creates an instance from the dynamic instructions you specify.
    ///
    /// - Parameters:
    ///   - dynamicInstructions: The dynamic instructions.
    public init(erasing dynamicInstructions: some DynamicInstructions)

    /// The content of the dynamic instructions.
    public var body: Never { get }

    /// The type of dynamic instructions that represent these instructions.
    @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public typealias Body = Never
}

public struct AnyTool : Tool {

    /// A unique name for the tool, such as "get_weather", "toggleDarkMode", or "search contacts".
    public var name: String { get }

    /// A natural language description of when and how to use the tool.
    public var description: String { get }

    /// A schema for the parameters this tool accepts.
    public var parameters: GenerationSchema { get }

    /// A language model will call this method when it wants to leverage this tool.
    ///
    /// If errors are throw in the body of this method, they will be wrapped in a
    /// ``LanguageModelSession/ToolCallError`` and rethrown at the call site
    /// of ``LanguageModelSession/respond(to:options:)-(Prompt,_)``.
    ///
    /// - Note: This method may be invoked concurrently with itself or with other tools.
    nonisolated(nonsending) public func call(arguments: GeneratedContent) async throws -> Prompt

    /// Creates a tool that wraps the given tool.
    ///
    /// - Parameters:
    ///   - tool: The tool to wrap.
    public init(_ tool: some Tool)

    /// The arguments that this tool should accept.
    ///
    /// Typically arguments are either a ``Generable`` type or ``GeneratedContent``.
    @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public typealias Arguments = GeneratedContent

    /// The output that this tool produces for the language model to reason about in subsequent
    /// interactions.
    ///
    /// Typically output is either a `String` or a ``Generable`` type.
    @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public typealias Output = Prompt
}

extension Array : Generable where Element : Generable {

    /// A representation of partially generated content
    public typealias PartiallyGenerated = [Element.PartiallyGenerated]

    /// An instance of the generation schema.
    public static var generationSchema: GenerationSchema { get }
}

extension Array : ConvertibleToGeneratedContent where Element : ConvertibleToGeneratedContent {

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    public var generatedContent: GeneratedContent { get }
}

extension Array : ConvertibleFromGeneratedContent where Element : ConvertibleFromGeneratedContent {

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    public init(_ content: GeneratedContent) throws
}

extension Array : InstructionsRepresentable where Element : InstructionsRepresentable {

    /// An instance that represents the instructions.
    public var instructionsRepresentation: Instructions { get }
}

extension Array : PromptRepresentable where Element : PromptRepresentable {

    /// An instance that represents a prompt.
    public var promptRepresentation: Prompt { get }
}

public struct Attachment<Content> where Content : AttachmentContent {

    /// Assigns a label to an attachment.
    ///
    /// Labels help the model identify specific attachments when making tool calls.
    ///
    /// ```swift
    /// Attachment(image)
    ///     .label("profile-photo")
    /// ```
    ///
    /// - Parameter label: A string that identifies this attachment.
    public func label(_ label: String) -> Attachment<Content>
}

extension Attachment : PromptRepresentable, InstructionsRepresentable where Content == ImageAttachmentContent {

    /// An instance that represents a prompt.
    public var promptRepresentation: Prompt { get }

    /// An instance that represents the instructions.
    public var instructionsRepresentation: Instructions { get }
}

extension Attachment where Content == ImageAttachmentContent {

    public init(_ uiImage: UIImage, orientation: UIImage.Orientation? = nil)
}

public protocol AttachmentContent {
}

extension Bool : Generable {

    /// An instance of the generation schema.
    public static var generationSchema: GenerationSchema { get }

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    public init(_ content: GeneratedContent) throws

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    public var generatedContent: GeneratedContent { get }
}

public struct ConditionalDynamicInstructions<TrueContent, FalseContent> : DynamicInstructions where TrueContent : DynamicInstructions, FalseContent : DynamicInstructions {

    /// An enumeration that represents a condition to evaluate.
    public enum Branch {

        /// A branch that represents true.
        case trueContent(TrueContent)

        /// A branch that represents false.
        case falseContent(FalseContent)
    }

    /// Creates a dynamic instructions instance that selects between two conditions.
    ///
    /// - Parameters:
    ///   - branch: The condition to evaluate.
    public init(_ branch: ConditionalDynamicInstructions<TrueContent, FalseContent>.Branch)

    /// The content of the dynamic instructions.
    public var body: Never { get }

    /// The type of dynamic instructions that represent these instructions.
    @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public typealias Body = Never
}

public struct ContextOptions : Sendable, Equatable {

    /// Controls the amount of thinking that the model is allowed to output before producing a response.
    public enum ReasoningLevel : Sendable, Equatable {

        /// A level that indicates light thinking that's good for quick responses.
        case light

        /// A level that indicates a moderate amount thinking.
        case moderate

        /// A level that indicates deep thinking that's good for more analysis over a request.
        case deep

        /// A custom level that indicates a level not supported by the other cases.
        case custom(String)

        /// 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: ContextOptions.ReasoningLevel, b: ContextOptions.ReasoningLevel) -> Bool
    }

    /// Inject the schema into the prompt to bias the model.
    ///
    /// Has no effect if there's no schema provided
    public var includeSchemaInPrompt: Bool?

    /// Controls the amount of thinking that the model is allowed to output before producing a response.
    public var reasoningLevel: ContextOptions.ReasoningLevel?

    /// Creates prompting options that controls how the model is prompted.
    ///
    /// - Parameters:
    ///   - includeSchemaInPrompt: Inject the schema into the prompt to bias the model.
    ///   - reasoningLevel: Controls the amount of thinking that the model is allowed to output before producing a response
    public init(includeSchemaInPrompt: Bool? = nil, reasoningLevel: ContextOptions.ReasoningLevel? = nil)

    /// 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: ContextOptions, b: ContextOptions) -> Bool
}

public protocol ConvertibleFromGeneratedContent : SendableMetatype {

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    init(_ content: GeneratedContent) throws
}

public protocol ConvertibleToGeneratedContent : InstructionsRepresentable, PromptRepresentable {

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    var generatedContent: GeneratedContent { get }
}

extension ConvertibleToGeneratedContent {

    /// An instance that represents the instructions.
    public var instructionsRepresentation: Instructions { get }

    /// An instance that represents a prompt.
    public var promptRepresentation: Prompt { get }
}

extension Decimal : Generable {

    /// An instance of the generation schema.
    public static var generationSchema: GenerationSchema { get }

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    public init(_ content: GeneratedContent) throws

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    public var generatedContent: GeneratedContent { get }
}

extension Double : Generable {

    /// An instance of the generation schema.
    public static var generationSchema: GenerationSchema { get }

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    public init(_ content: GeneratedContent) throws

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    public var generatedContent: GeneratedContent { get }
}

public struct DynamicGenerationSchema : Sendable {

    /// Creates a null schema.
    ///
    /// You can use null schemas as a way to express types that
    /// cannot be absent, but may have an empty value.
    ///
    ///     let person = DynamicGenerationSchema(
    ///         name: "Person",
    ///         properties: []
    ///             DynamicGenerationSchema.Property(
    ///               name: "fullName",
    ///               schema: DynamicGenerationSchema(type: String.self)
    ///             )
    ///         ]
    ///     )
    ///
    ///     let nullablePerson = DynamicGenerationSchema(
    ///       name: "NullablePerson",
    ///       anyOf: [person, .null]
    ///     )
    ///
    ///     let schema = try GenerationSchema(root: nullablePerson, dependencies: [])
    ///
    @available(iOS 26.4, macOS 26.4, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public static var null: DynamicGenerationSchema { get }

    /// Creates an object schema.
    ///
    /// - Parameters:
    ///   - name: A name this dynamic schema can be referenced by.
    ///   - description: A natural language description of this schema.
    ///   - properties: The properties to associated with this schema.
    public init(name: String, description: String? = nil, properties: [DynamicGenerationSchema.Property])

    /// Creates an object schema.
    ///
    /// - Parameters:
    ///   - name: A name this dynamic schema can be referenced by.
    ///   - description: A natural language description of this schema.
    ///   - representNilExplicitlyInGeneratedContent: Controls how the model will represent nil.
    ///   - properties: The properties to associated with this schema.
    @available(iOS 26.4, macOS 26.4, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public init(name: String, description: String? = nil, representNilExplicitlyInGeneratedContent explicitNil: Bool, properties: [DynamicGenerationSchema.Property])

    /// Creates an any-of schema.
    ///
    /// - Parameters:
    ///   - name: A name this schema can be referenecd by.
    ///   - description: A natural language description of this ``DynamicGenerationSchema``.
    ///   - choices: An array of schemas this one will be a union of.
    public init(name: String, description: String? = nil, anyOf choices: [DynamicGenerationSchema])

    /// Creates an enum schema.
    ///
    /// - Parameters:
    ///   - name: A name this schema can be referenced by.
    ///   - description: A natural language description of this ``DynamicGenerationSchema``.
    ///   - choices: An array of strings this one will be a union of.
    public init(name: String, description: String? = nil, anyOf choices: [String])

    /// Creates an array schema.
    ///
    /// - Parameters:
    ///   - itemSchema: A schema to use as the elements of the array.
    ///   - minimumElements: A minimum number of elements the array should contain.
    ///   - maximumElements: The maximum number of element the array should contain.
    public init(arrayOf itemSchema: DynamicGenerationSchema, minimumElements: Int? = nil, maximumElements: Int? = nil)

    /// Creates a schema from a generable type and guides.
    ///
    /// - Parameters:
    ///   - type: A `Generable` type
    ///   - guides: Generation guides to apply to this `DynamicGenerationSchema`.
    public init<Value>(type: Value.Type, guides: [GenerationGuide<Value>] = []) where Value : Generable

    /// Creates an refrence schema.
    ///

Truncated.

public protocol DynamicInstructions {

    /// The type of dynamic instructions that represent these instructions.
    associatedtype Body : DynamicInstructions

    /// The content of the dynamic instructions.
    @DynamicInstructionsBuilder var body: Self.Body { get }
}

extension DynamicInstructions {

    public typealias SessionProperty = LanguageModelSession.SessionProperty
}

@resultBuilder public struct DynamicInstructionsBuilder {

    /// Creates a builder with a tool expression.
    public static func buildExpression<T>(_ expression: T) -> some DynamicInstructions where T : Tool


    /// Creates a builder with a dynamic instructions expression.
    public static func buildExpression<T>(_ expression: T) -> T where T : DynamicInstructions

    /// Creates a builder with a list of tools expression.
    public static func buildExpression(_ tools: [any Tool]) -> some DynamicInstructions


    public static func buildBlock<each Content>(_ contents: repeat each Content) -> TupleDynamicInstructions<repeat each Content> where repeat each Content : DynamicInstructions

    /// Creates a builder with a block.
    public static func buildBlock<T>(_ content: T) -> T where T : DynamicInstructions

    /// Creates a builder with an empty block.
    public static func buildBlock() -> EmptyDynamicInstructions

    /// Creates a builder with the first component.
    public static func buildEither<TrueContent, FalseContent>(first content: TrueContent) -> ConditionalDynamicInstructions<TrueContent, FalseContent> where TrueContent : DynamicInstructions, FalseContent : DynamicInstructions

    /// Creates a builder with the second component.
    public static func buildEither<TrueContent, FalseContent>(second content: FalseContent) -> ConditionalDynamicInstructions<TrueContent, FalseContent> where TrueContent : DynamicInstructions, FalseContent : DynamicInstructions

    /// Creates a builder with an optional component.
    public static func buildOptional<Content>(_ content: Content?) -> Content? where Content : DynamicInstructions
}

public struct EmptyDynamicInstructions : DynamicInstructions, Sendable {

    /// The content of the dynamic instructions.
    public var body: Never { get }

    /// Creates an empty instance.
    public init()

    /// The type of dynamic instructions that represent these instructions.
    @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public typealias Body = Never
}

extension Float : Generable {

    /// An instance of the generation schema.
    public static var generationSchema: GenerationSchema { get }

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    public init(_ content: GeneratedContent) throws

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    public var generatedContent: GeneratedContent { get }
}

public protocol Generable : ConvertibleFromGeneratedContent, ConvertibleToGeneratedContent {

    /// A representation of partially generated content
    associatedtype PartiallyGenerated : ConvertibleFromGeneratedContent = Self

    /// An instance of the generation schema.
    static var generationSchema: GenerationSchema { get }
}

extension Generable {

    /// A representation of partially generated content
    public typealias PartiallyGenerated = Self
}

public struct GeneratedContent : Sendable, Equatable, Generable, CustomDebugStringConvertible {

    /// An instance of the generation schema.
    public static var generationSchema: GenerationSchema { get }

    /// A unique id that is stable for the duration of a generated response.
    ///
    /// A ``LanguageModelSession`` produces instances of ``GeneratedContent`` that have a
    /// non-nil `id`. When you stream a response, the `id` is the same for all partial generations in the
    /// response stream.
    ///
    /// Instances of ``GeneratedContent`` that you produce manually with initializers have a nil `id`
    /// because the framework didn't create them as part of a generation.
    public var id: GenerationID?

    /// Creates generated content from another value.
    ///
    /// This is used to satisfy `Generable.init(_:)`.
    public init(_ content: GeneratedContent) throws

    /// A representation of this instance.
    public var generatedContent: GeneratedContent { get }

    /// Creates generated content representing a structure with the properties you specify.
    ///
    /// The order of properties is important. For ``Generable`` types, the order
    /// must match the order properties in the types `schema`.
    public init(properties: KeyValuePairs<String, any ConvertibleToGeneratedContent>, id: GenerationID? = nil)

    /// Creates new generated content from the key-value pairs in the given sequence,
    /// using a combining closure to determine the value for any duplicate keys.
    ///
    /// The order of properties is important. For ``Generable`` types, the order
    /// must match the order properties in the types `schema`.
    ///
    /// You use this initializer to create generated content when you have a sequence
    /// of key-value tuples that might have duplicate keys. As the content is
    /// built, the initializer calls the `combine` closure with the current and
    /// new values for any duplicate keys. Pass a closure as `combine` that
    /// returns the value to use in the resulting content: The closure can
    /// choose between the two values, combine them to produce a new value, or
    /// even throw an error.
    ///
    /// The following example shows how to choose the first and last values for
    /// any duplicate keys:
    ///
    /// ```swift
    ///     let content = GeneratedContent(
    ///       properties: [("name", "John"), ("name", "Jane"), ("married", true)],
    ///       uniquingKeysWith: { (first, _) in first }
    ///     )
    ///     // GeneratedContent(["name": "John", "married": true])
    /// ```
    ///
    /// - Parameters:
    ///   - properties: A sequence of key-value pairs to use for the new content.
    ///   - id: A unique id associated with ``GeneratedContent``.
    ///   - combine: A closure that is called with the values to resolve any duplicates
    ///     keys that are encountered. The closure returns the desired value for the final content.
    public init<S>(properties: S, id: GenerationID? = nil, uniquingKeysWith combine: (GeneratedContent, GeneratedContent) throws -> some ConvertibleToGeneratedContent) rethrows where S : Sequence, S.Element == (String, any ConvertibleToGeneratedContent)

    /// Creates content representing an array of elements you specify.
    public init<S>(elements: S, id: GenerationID? = nil) where S : Sequence, S.Element == any ConvertibleToGeneratedContent

    /// Creates content that contains a single value.
    ///
    /// - Parameters:
    ///   - value: The underlying value.
    public init(_ value: some ConvertibleToGeneratedContent)

    /// Creates content that contains a single value with a custom `GenerationID`.
    ///
    /// - Parameters:
    ///   - value: The underlying value.
    ///   - id: The ``GenerationID`` for this content.
    public init(_ value: some ConvertibleToGeneratedContent, id: GenerationID)

    /// Creates equivalent content from a JSON string.
    ///
    /// The JSON string you provide may be incomplete. This is useful for correctly handling partially generated responses.

Truncated.

extension GeneratedContent {

    /// A failure that occurs when a string cannot be parsed into GeneratedContent.
    @available(iOS 27.0, macOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public struct ParsingError : LocalizedError, CustomDebugStringConvertible, Sendable {

        /// The raw content that could not be parsed.
        public var rawContent: String

        /// The underlying error that caused the parsing failure, if any.
        public var underlyingError: (any Error)?

        /// A debug description of what failed to parse.
        public var debugDescription: String

        /// Creates a parsing failure value.
        /// - Parameters:
        ///   - rawContent: The raw content that could not be parsed.
        ///   - underlyingError: The underlying error that caused the parsing failure, if any.
        ///   - debugDescription: A debug description of what failed to parse.
        public init(rawContent: String, underlyingError: (any Error)? = nil, debugDescription: String)

        /// A localized message describing what error occurred.
        public var errorDescription: String? { get }
    }
}

public struct GenerationGuide<Value> {
}

extension GenerationGuide where Value == String {

    /// Enforces that the string be precisely the given value.
    public static func constant(_ value: String) -> GenerationGuide<String>

    /// Enforces that the string be one of the provided values.
    public static func anyOf(_ values: [String]) -> GenerationGuide<String>

    /// Enforces that the string follows the pattern.
    public static func pattern<Output>(_ regex: Regex<Output>) -> GenerationGuide<String>
}

extension GenerationGuide where Value == Int {

    /// Enforces a minimum value.
    ///
    /// Use a `minimum` generation guide --- whose bounds are inclusive --- to ensure the model produces
    /// a value greater than or equal to some minimum value. For example, you can specify that all characters
    /// in your game start at level 1:
    ///
    /// ```swift
    /// @Generable
    /// struct GameCharacter {
    ///     @Guide(description: "A creative name appropriate for a fantasy RPG character")
    ///     var name: String
    ///
    ///     @Guide(description: "A level for the character", .minimum(1))
    ///     var level: Int
    /// }
    /// ```
    public static func minimum(_ value: Int) -> GenerationGuide<Int>

    /// Enforces a maximum value.
    ///
    /// Use a `maximum` generation guide --- whose bounds are inclusive --- to ensure the model produces
    /// a value less than or equal to some maximum value. For example, you can specify that the highest level
    /// a character in your game can achieve is 100:
    ///
    /// ```swift
    /// @Generable
    /// struct GameCharacter {
    ///     @Guide(description: "A creative name appropriate for a fantasy RPG character")
    ///     var name: String
    ///
    ///     @Guide(description: "A level for the character", .maximum(100))
    ///     var level: Int
    /// }
    /// ```
    public static func maximum(_ value: Int) -> GenerationGuide<Int>

    /// Enforces values that fall within a range.
    ///
    /// Use a `range` generation guide --- whose bounds are inclusive --- to ensure the model produces a
    /// value that falls within a range. For example, you can specify that the level of characters in your game
    /// are between 1 and 100:
    ///
    /// ```swift
    /// @Generable
    /// struct GameCharacter {
    ///     @Guide(description: "A creative name appropriate for a fantasy RPG character")
    ///     var name: String
    ///
    ///     @Guide(description: "A level for the character", .range(1...100))
    ///     var level: Int
    /// }
    /// ```
    public static func range(_ range: ClosedRange<Int>) -> GenerationGuide<Int>
}

extension GenerationGuide where Value == Float {

    /// Enforces a minimum value.
    ///
    /// Use a `minimum` generation guide --- whose bounds are inclusive --- to ensure the model produces
    /// a value greater than or equal to some minimum value. For example, you can specify that all characters
    /// in your game start at level 1.0:
    ///
    /// ```swift
    /// @Generable
    /// struct GameCharacter {
    ///     @Guide(description: "A creative name appropriate for a fantasy RPG character")
    ///     var name: String
    ///
    ///     @Guide(description: "A level for the character", .minimum(1.0))
    ///     var level: Float
    /// }
    /// ```
    public static func minimum(_ value: Float) -> GenerationGuide<Float>

    /// Enforces a maximum value.
    ///
    /// Use a `maximum` generation guide --- whose bounds are inclusive --- to ensure the model produces
    /// a value less than or equal to some maximum value. For example, you can specify that the highest level
    /// a character in your game can achieve is 100.0:
    ///
    /// ```swift
    /// @Generable
    /// struct GameCharacter {
    ///     @Guide(description: "A creative name appropriate for a fantasy RPG character")
    ///     var name: String
    ///
    ///     @Guide(description: "A level for the character", .maximum(100.0))
    ///     var level: Float
    /// }
    /// ```
    public static func maximum(_ value: Float) -> GenerationGuide<Float>

    /// Enforces values fall within a range.
    ///
    /// Bounds are inclusive.
    ///
    /// A `range` generation guide may be used when you want to ensure the model
    /// produces a value that falls in some range, such as the cost for an item
    /// in a game.
    ///
    /// ```swift
    /// @Generable
    /// struct ShopItem {
    ///     @Guide(description: "A creative name for an item sold in a fantasy RPG")
    ///     var name: String
    ///
    ///     @Guide(description: "A cost for the item", .range(1...1000))
    ///     var cost: Float
    /// }
    /// ```
    public static func range(_ range: ClosedRange<Float>) -> GenerationGuide<Float>
}

extension GenerationGuide where Value == Decimal {

    /// Enforces a minimum value.
    ///
    /// Use a `minimum` generation guide --- whose bounds are inclusive --- to ensure the model produces
    /// a value greater than or equal to some minimum value. For example, you can specify that all characters
    /// in your game start at level 0.75:
    ///
    /// ```swift
    /// @Generable
    /// struct GameCharacter {
    ///     @Guide(description: "A creative name appropriate for a fantasy RPG character")
    ///     var name: String
    ///
    ///     @Guide(description: "A level for the character", .minimum(0.75))
    ///     var level: Decimal
    /// }
    /// ```
    public static func minimum(_ value: Decimal) -> GenerationGuide<Decimal>

    /// Enforces a maximum value.
    ///
    /// Use a `maximum` generation guide --- whose bounds are inclusive --- to ensure the model produces
    /// a value less than or equal to some maximum value. For example, you can specify that the highest level
    /// a character in your game can achieve is 99.9:
    ///
    /// ```swift
    /// @Generable
    /// struct GameCharacter {
    ///     @Guide(description: "A creative name appropriate for a fantasy RPG character")
    ///     var name: String
    ///
    ///     @Guide(description: "A level for the character", .maximum(99.9))
    ///     var level: Decimal
    /// }
    /// ```
    public static func maximum(_ value: Decimal) -> GenerationGuide<Decimal>

    /// Enforces values fall within a range.
    ///
    /// Bounds are inclusive.
    ///
    /// A `range` generation guide may be used when you want to ensure the model
    /// produces a value that falls in some range, such as the cost for an item
    /// in a game.
    ///
    /// ```swift
    /// @Generable
    /// struct ShopItem {
    ///     @Guide(description: "A creative name for an item sold in a fantasy RPG")
    ///     var name: String
    ///
    ///     @Guide(description: "A cost for the item", .range(0.25...1000))
    ///     var cost: Decimal
    /// }
    /// ```
    public static func range(_ range: ClosedRange<Decimal>) -> GenerationGuide<Decimal>
}

extension GenerationGuide where Value == Double {

    /// Enforces a minimum value.
    ///
    /// Use a `minimum` generation guide --- whose bounds are inclusive --- to ensure the model produces
    /// a value greater than or equal to some minimum value. For example, you can specify that all characters
    /// in your game start at level 1.0:
    ///
    /// ```swift
    /// @Generable
    /// struct GameCharacter {
    ///     @Guide(description: "A creative name appropriate for a fantasy RPG character")
    ///     var name: String
    ///
    ///     @Guide(description: "A level for the character", .minimum(1.0))
    ///     var level: Double
    /// }
    /// ```
    public static func minimum(_ value: Double) -> GenerationGuide<Double>

    /// Enforces a maximum value.
    ///
    /// Use a `maximum` generation guide --- whose bounds are inclusive --- to ensure the model produces
    /// a value less than or equal to some maximum value. For example, you can specify that the highest level
    /// a character in your game can achieve is 5000.0:
    ///
    /// ```swift
    /// @Generable
    /// struct GameCharacter {
    ///     @Guide(description: "A creative name appropriate for a fantasy RPG character")
    ///     var name: String
    ///
    ///     @Guide(description: "A level for the character", .maximum(5000.0))
    ///     var level: Double
    /// }
    /// ```
    public static func maximum(_ value: Double) -> GenerationGuide<Double>

    /// Enforces values fall within a range.
    ///
    /// Bounds are inclusive.
    ///
    /// A `range` generation guide may be used when you want to ensure the model
    /// produces a value that falls in some range, such as the cost for an item
    /// in a game.
    ///
    /// ```swift
    /// @Generable
    /// struct ShopItem {
    ///     @Guide(description: "A creative name for an item sold in a fantasy RPG")
    ///     var name: String
    ///
    ///     @Guide(description: "A cost for the item", .range(1...1000))
    ///     var cost: Double
    /// }
    /// ```
    public static func range(_ range: ClosedRange<Double>) -> GenerationGuide<Double>
}

extension GenerationGuide {

    /// Enforces a minimum number of elements in the array.
    ///
    /// The bounds are inclusive.
    ///
    /// A `minimumCount` generation guide may be used when you want to ensure the
    /// model produces a number of array elements greater than or equal to to some
    /// minimum value, such as the number of items in a game's shop.
    ///
    /// ```swift
    /// @Generable
    /// struct Shop {
    ///     @Guide(description: "A creative name for a shop in a fantasy RPG")
    ///     var name: String
    ///
    ///     @Guide(description: "A list of items for sale", .minimumCount(3))
    ///     var inventory: [ShopItem]
    /// }
    /// ```
    public static func minimumCount<Element>(_ count: Int) -> GenerationGuide<[Element]> where Value == [Element]

    /// Enforces a maximum number of elements in the array.
    ///
    /// The bounds are inclusive.
    ///
    /// A `maximumCount` generation guide may be used when you want to ensure the
    /// model produces a number of array elements less than or equal to to some
    /// maximum value, such as the number of items in a game's shop.
    ///
    /// ```swift
    /// @Generable
    /// struct Shop {
    ///     @Guide(description: "A creative name for a shop in a fantasy RPG")
    ///     var name: String
    ///
    ///     @Guide(description: "A list of items for sale", .maximumCount(10))
    ///     var inventory: [ShopItem]
    /// }
    /// ```
    public static func maximumCount<Element>(_ count: Int) -> GenerationGuide<[Element]> where Value == [Element]

    /// Enforces that the number of elements in the array fall within a closed range.
    ///
    /// Bounds are inclusive.
    ///
    /// A `count` generation guide may be used when you want to ensure the
    /// model produces a number of array elements that falls within a given range,
    /// such as the number of items in a game's shop.
    ///
    /// ```swift
    /// @Generable
    /// struct Shop {
    ///     @Guide(description: "A creative name for a shop in a fantasy RPG")
    ///     var name: String
    ///
    ///     @Guide(description: "A list of items for sale", .count(2...10))
    ///     var inventory: [ShopItem]
    /// }
    /// ```
    public static func count<Element>(_ range: ClosedRange<Int>) -> GenerationGuide<[Element]> where Value == [Element]

    /// Enforces that the array has exactly a certain number elements.
    ///
    /// A `count` generation guide may be used when you want to ensure the
    /// model produces exactly a certain number array elements, such as the
    /// number of items in a game's shop.
    ///
    /// ```swift
    /// @Generable
    /// struct Shop {
    ///     @Guide(description: "A creative name for a shop in a fantasy RPG")
    ///     var name: String
    ///
    ///     @Guide(description: "A list of items for sale", .count(3))
    ///     var inventory: [ShopItem]
    /// }
    /// ```
    public static func count<Element>(_ count: Int) -> GenerationGuide<[Element]> where Value == [Element]

Truncated.

extension GenerationGuide where Value == [Never] {

    /// Enforces a minimum number of elements in the array.
    ///
    /// Bounds are inclusive.
    ///
    /// - Warning: This overload is only used for macro expansion. Don't call `GenerationGuide<[Never]>.minimumCount(_:)` on your own.
    public static func minimumCount(_ count: Int) -> GenerationGuide<Value>

    /// Enforces a maximum number of elements in the array.
    ///
    /// Bounds are inclusive.
    ///
    /// - Warning: This overload is only used for macro expansion. Don't call `GenerationGuide<[Never]>.maximumCount(_:)` on your own.
    public static func maximumCount(_ count: Int) -> GenerationGuide<Value>

    /// Enforces that the number of elements in the array fall within a closed range.
    ///
    /// - Warning: This overload is only used for macro expansion. Don't call `GenerationGuide<[Never]>.count(_:)` on your own.
    public static func count(_ range: ClosedRange<Int>) -> GenerationGuide<Value>

    /// Enforces that the array has exactly a certain number elements.
    ///
    /// - Warning: This overload is only used for macro expansion. Don't call `GenerationGuide<[Never]>.count(_:)` on your own.
    public static func count(_ count: Int) -> GenerationGuide<Value>
}

public struct GenerationID : Sendable, Hashable {

    /// Create a new, unique `GenerationID`.
    public init()

    /// 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: GenerationID, b: GenerationID) -> 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 }
}

public struct GenerationOptions : Sendable, Equatable {

    /// A sampling strategy for how the model picks tokens when generating a
    /// response.
    ///
    /// When you execute a prompt on a model, the model produces a probability
    /// for every token in its vocabulary. The sampling strategy controls how
    /// the model narrows down the list of tokens to consider during that process.
    /// A strategy that picks the single most likely token yields a predictable
    /// response every time, but other strategies offer results that often
    /// sound more natural to a person.
    ///
    /// - Note: Leaving the `sampling` nil lets the system choose a
    ///   a reasonable default on your behalf.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @backDeployed(before: iOS 27.0, macOS 27.0, visionOS 27.0)
    @available(tvOS, unavailable)
    public var samplingMode: GenerationOptions.SamplingMode?

    /// Temperature influences the confidence of the models response.
    ///
    /// The value of this property must be a number between `0` and `1` inclusive.
    ///
    /// Temperature is an adjustment applied to the probability distribution
    /// prior to sampling. A value of `1` results in no adjustment. Values less
    /// than `1` will make the probability distribution sharper, with already
    /// likely tokens becoming even more likely.
    ///
    /// The net effect is that low temperatures manifest as more stable and
    /// predictable responses, while high temperatures give the model more
    /// creative license.
    ///
    /// - Note: Leaving `temperature` nil lets the system choose a reasonable
    ///   default on your behalf.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public var temperature: Double?

    /// The maximum number of tokens the model is allowed to produce in its response.
    ///
    /// If the model produce `maximumResponseTokens` before it naturally completes its response,
    /// the response will be terminated early. No error will be thrown. This property
    /// can be used to protect against unexpectedly verbose responses and runaway generations.
    ///
    /// If no value is specified, then the model is allowed to produce the longest answer
    /// its context size supports. If the response exceeds that limit without terminating,
    /// an error will be thrown.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public var maximumResponseTokens: Int?

    /// Configure the tool calling requirements.
    @available(iOS 27.0, macOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public var toolCallingMode: GenerationOptions.ToolCallingMode?

    /// Creates generation options that control token sampling behavior.
    ///
    /// - Parameters:
    ///   - samplingMode: A strategy to use for sampling from a distribution.
    ///   - temperature: Increasing temperature makes it possible for the model to produce less likely
    ///     responses. Must be between `0` and `1`, inclusive.
    ///   - maximumResponseTokens: The maximum number of tokens the model is allowed
    ///     to produce before being artificially halted. Must be positive.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @backDeployed(before: iOS 27.0, macOS 27.0, visionOS 27.0)
    @available(tvOS, unavailable)
    public init(samplingMode: GenerationOptions.SamplingMode? = nil, temperature: Double? = nil, maximumResponseTokens: Int? = nil)

    /// Creates generation options that control token sampling behavior.
    ///
    /// - Parameters:
    ///   - samplingMode: A strategy to use for sampling from a distribution.
    ///   - temperature: Increasing temperature makes it possible for the model to produce less likely
    ///     responses. Must be between `0` and `1`, inclusive.
    ///   - maximumResponseTokens: The maximum number of tokens the model is allowed
    ///     to produce before being artificially halted. Must be positive.
    ///   - toolCalling: The requirements defining how the model should call tools.
    @available(iOS 27.0, macOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)

Truncated.

extension GenerationOptions {

    /// A type that defines how values are sampled from a probability distribution.
    ///
    /// A model builds its response to a prompt in a loop. At each iteration in the
    /// loop the model produces a probability distribution for all the tokens in its
    /// vocabulary. The sampling mode controls how a token is selected from that
    /// distribution.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public struct SamplingMode : Sendable, Equatable {

        /// A sampling mode that always chooses the most likely token.
        ///
        /// Using this mode will always result in the same output
        /// for a given input. Responses produced with greedy sampling
        /// are statistically likely, but may lack the human-like quality
        /// and variety of other sampling strategies.
        /// - SeeAlso: Sampling modes ``random(top:seed:)`` and ``random(probabilityThreshold:seed:)``
        @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
        @available(tvOS, unavailable)
        public static var greedy: GenerationOptions.SamplingMode { get }

        /// A sampling mode that considers a fixed number of high-probability tokens.
        ///
        /// Also known as top-k.
        ///
        /// During the token-selection process, the vocabulary is sorted by probability a
        /// token is selected from among the top K candidates. Smaller values of K will
        /// ensure only the most probable tokens are candidates for selection, resulting
        /// in more deterministic and confident answers. Larger values of K will allow less
        /// probably tokens to be selected, raising non-determinism and creativity.
        ///
        /// - Note: Setting a random seed is not guaranteed to result in fully deterministic
        ///   output. It is best effort.
        ///
        /// - Parameters:
        ///   - k: The number of tokens to consider.
        ///   - seed: An optional random seed used to make output more deterministic.
        /// - SeeAlso: Sampling modes ``greedy`` and ``random(probabilityThreshold:seed:)``
        @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
        @available(tvOS, unavailable)
        public static func random(top k: Int, seed: UInt64? = nil) -> GenerationOptions.SamplingMode

        /// A mode that considers a variable number of high-probability tokens
        /// based on the specified threshold.
        ///
        /// Also known as top-p or nucleus sampling.
        ///
        /// With nucleus sampling, tokens are sorted by probability and added to a
        /// pool of candidates until the cumulative probability of the pool exceeds
        /// the specified threshold, and then a token is sampled from the pool.
        ///
        /// Because the number of tokens isn't predetermined, the selection pool size
        /// will be larger when the distribution is flat and smaller when it is spikey.
        /// This variability can lead to a wider variety of options to choose from, and
        /// potentially more creative responses.
        ///
        /// - Note: Setting a random seed is not guaranteed to result in fully deterministic
        ///   output. It is best effort.
        ///
        /// - Parameters:
        ///     - probabilityThreshold: A number between `0.0` and `1.0` that
        ///       increases sampling pool size.
        ///     - seed: An optional random seed used to make output more deterministic.
        /// - SeeAlso: Sampling modes ``greedy`` and ``random(top:seed:)``
        @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
        @available(tvOS, unavailable)
        public static func random(probabilityThreshold: Double, seed: UInt64? = nil) -> GenerationOptions.SamplingMode

        @available(iOS 27.0, macOS 27.0, watchOS 27.0, *)
        @available(tvOS, unavailable)
        public let kind: GenerationOptions.SamplingMode.Kind

        @available(iOS 27.0, macOS 27.0, watchOS 27.0, *)
        @available(tvOS, unavailable)
        public enum Kind : Sendable, Equatable {

            case greedy

Truncated.

extension GenerationOptions.ToolCallingMode.Kind : Hashable {
}

public struct GenerationSchema : Sendable, Codable, CustomDebugStringConvertible {

    /// Fields are named members of object types. Fields are strongly
    /// typed and have optional descriptions and guides.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public struct Property : Sendable {

        /// Create a property that contains a generable type.
        ///
        /// - Parameters:
        ///   - name: The property's name.
        ///   - description: A natural language description of what content
        ///     should be generated for this property.
        ///   - type: The type this property represents.
        ///   - guides: A list of guides to apply to this property.
        public init<Value>(name: String, description: String? = nil, type: Value.Type, guides: [GenerationGuide<Value>] = []) where Value : Generable

        /// Create an optional property that contains a generable type.
        ///
        /// - Parameters:
        ///   - name: The property's name.
        ///   - description: A natural language description of what content
        ///     should be generated for this property.
        ///   - type: The type this property represents.
        ///   - guides: A list of guides to apply to this property.
        public init<Value>(name: String, description: String? = nil, type: Value?.Type, guides: [GenerationGuide<Value>] = []) where Value : Generable

        /// Create a property that contains a string type.
        ///
        /// - Parameters:
        ///   - name: The property's name.
        ///   - description: A natural language description of what content
        ///     should be generated for this property.
        ///   - type: The type this property represents.
        ///   - guides: An array of regexes to be applied to this string. If there're multiple regexes in the array, only the last one will be applied.
        public init<RegexOutput>(name: String, description: String? = nil, type: String.Type, guides: [Regex<RegexOutput>] = [])

        /// Create an optional property that contains a generable type.
        ///
        /// - Parameters:
        ///   - name: The property's name.
        ///   - description: A natural language description of what content
        ///     should be generated for this property.
        ///   - type: The type this property represents.
        ///   - guides: An array of regexes to be applied to this string. If there're multiple regexes in the array, only the last one will be applied.
        public init<RegexOutput>(name: String, description: String? = nil, type: String?.Type, guides: [Regex<RegexOutput>] = [])
    }

    /// Creates a schema by providing an array of properties.
    ///
    /// - Parameters:
    ///   - type: The type this schema represents.
    ///   - description: A natural language description of this schema.
    ///   - properties: An array of properties.
    public init(type: any Generable.Type, description: String? = nil, properties: [GenerationSchema.Property])

    /// Creates a new instance by decoding from the given decoder.
    ///
    /// This initializer throws an error if reading from the decoder fails, or
    /// if the data read is corrupted or otherwise invalid.
    ///
    /// - Parameter decoder: The decoder to read data from.
    public init(from decoder: any Decoder) throws

    /// Encodes this value into the given encoder.
    ///
    /// If the value fails to encode anything, `encoder` will encode an empty
    /// keyed container in its place.
    ///
    /// This function throws an error if any values are invalid for the given
    /// encoder's format.
    ///
    /// - Parameter encoder: The encoder to write data to.
    public func encode(to encoder: any Encoder) throws

    /// A textual representation of this instance, suitable for debugging.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(reflecting:)`

Truncated.

public struct ImageAttachmentContent : AttachmentContent, Sendable, Equatable {

    /// 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: ImageAttachmentContent, b: ImageAttachmentContent) -> Bool
}

public struct ImageReference : Sendable, Equatable {

    /// The label of the referenced image.
    public let attachmentLabel: String

    /// Returns the referenced image from the transcript.
    ///
    /// - Parameters:
    ///   - transcript: The transcript to resolve the reference against.
    /// - Returns: The ``ImageAttachment`` for this reference, or `nil` if no attachment
    ///   with label ``attachmentLabel`` is found in the transcript.
    public func resolve(in transcript: Transcript) -> Transcript.ImageAttachment?

    /// An instance of the generation schema.
    nonisolated public static var generationSchema: GenerationSchema { get }

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    nonisolated public var generatedContent: GeneratedContent { get }

    /// A representation of partially generated content
    nonisolated public struct PartiallyGenerated : Identifiable, nonisolated ConvertibleFromGeneratedContent, Equatable {

        /// The stable identity of the entity associated with this instance.
        public var id: GenerationID

        public var attachmentLabel: String.PartiallyGenerated?

        /// Creates an instance from content generated by a model.
        ///
        /// Conformance to this protocol is provided by the `@Generable` macro.
        /// A manual implementation may be used to map values onto properties using
        /// different names. To manually initialize your type from generated content,
        /// decode the values as shown below:
        ///
        /// ```swift
        /// struct Person: ConvertibleFromGeneratedContent {
        ///     var name: String
        ///     var age: Int
        ///
        ///     init(_ content: GeneratedContent) {
        ///         self.name = try content.value(forProperty: "firstName")
        ///         self.age = try content.value(forProperty: "ageInYears")
        ///     }
        /// }
        /// ```
        ///
        /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
        /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
        ///
        /// - SeeAlso: `@Generable` macro ``Generable(description:)``
        nonisolated public init(_ content: GeneratedContent) throws

        /// 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:

Truncated.

extension ImageReference : nonisolated Generable {

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    nonisolated public init(_ content: GeneratedContent) throws
}

extension Instructions : DynamicInstructions {

    /// The content of the dynamic instructions.
    public var body: some DynamicInstructions { get }

    /// The type of dynamic instructions that represent these instructions.
    @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public typealias Body = some DynamicInstructions
}

public struct Instructions : Sendable {

    /// Creates an instance with the content you specify.
    public init(_ content: some InstructionsRepresentable)
}

extension Instructions : InstructionsRepresentable {

    /// An instance that represents the instructions.
    public var instructionsRepresentation: Instructions { get }
}

extension Instructions {

    public init(@InstructionsBuilder _ content: () throws -> Instructions) rethrows
}

@resultBuilder public struct InstructionsBuilder {

    /// Creates a builder with a block.
    public static func buildBlock<each I>(_ components: repeat each I) -> Instructions where repeat each I : InstructionsRepresentable

    /// Creates a builder with the an array of prompts.
    public static func buildArray(_ instructions: [some InstructionsRepresentable]) -> Instructions

    /// Creates a builder with the first component.
    public static func buildEither(first component: some InstructionsRepresentable) -> Instructions

    /// Creates a builder with the second component.
    public static func buildEither(second component: some InstructionsRepresentable) -> Instructions

    /// Creates a builder with an optional component.
    public static func buildOptional(_ instructions: Instructions?) -> Instructions

    /// Creates a builder with a limited availability prompt.
    public static func buildLimitedAvailability(_ instructions: some InstructionsRepresentable) -> Instructions

    /// Creates a builder with an expression.
    public static func buildExpression<I>(_ expression: I) -> I where I : InstructionsRepresentable

    /// Creates a builder with a prompt expression.
    public static func buildExpression(_ expression: Instructions) -> Instructions
}

public protocol InstructionsRepresentable {

    /// An instance that represents the instructions.
    @InstructionsBuilder var instructionsRepresentation: Instructions { get }
}

extension Int : Generable {

    /// An instance of the generation schema.
    public static var generationSchema: GenerationSchema { get }

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    public init(_ content: GeneratedContent) throws

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    public var generatedContent: GeneratedContent { get }
}

public protocol LanguageModel : Sendable {

    associatedtype Executor : LanguageModelExecutor where Self == Self.Executor.Model

    /// The capabilities of this language model.
    ///
    /// If a developer attempts to use capabilities that your model does not support,
    /// then the system will automatically throw a
    /// ``LanguageModelSession.GenerationError.unsupportedFeature`` error for
    /// you instead of calling ``respond(to:)``.
    var capabilities: LanguageModelCapabilities { get }

    /// A configuration for an executor capable of running this model.
    var executorConfiguration: Self.Executor.Configuration { get }
}

public struct LanguageModelCapabilities : Sendable {

    /// Check if a specific ability is supported.
    public func contains(_ capability: LanguageModelCapabilities.Capability) -> Bool

    /// Specify a list of supported capabilities
    public init(capabilities: [LanguageModelCapabilities.Capability])

    /// A capability that a given language model may or may not have.
    public struct Capability : Sendable, Hashable {

        /// The capability to accept image inputs in prompts.
        public static var vision: LanguageModelCapabilities.Capability { get }

        /// The capability to ensure model output conforms to a given generation schema.
        public static var guidedGeneration: LanguageModelCapabilities.Capability { get }

        /// The capability to reason, structurally separately from producing a response.
        public static var reasoning: LanguageModelCapabilities.Capability { get }

        /// The capability to call tools to gather information or trigger side effects.
        public static var toolCalling: LanguageModelCapabilities.Capability { get }

        /// 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: LanguageModelCapabilities.Capability, b: LanguageModelCapabilities.Capability) -> 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 }
    }
}

public enum LanguageModelError : LocalizedError, CustomDebugStringConvertible {

    /// The session's transcript exceeded the model's context size.
    ///
    /// You can recover from this error by removing entries from the transcript and trying again.
    ///
    /// For more information on managing the context window size, see <doc:managing-the-context-window>.
    case contextSizeExceeded(LanguageModelError.ContextSizeExceeded)

    /// The session has been rate limited.
    ///
    /// This failure can happen if you make too many requests in a short window.
    /// You can recover from this error by spacing your requests or reducing system load. The
    /// exact solution may be model dependent.
    case rateLimited(LanguageModelError.RateLimited)

    /// The model's safety guardrails were triggered by content in a
    /// prompt or the response generated by the model.
    case guardrailViolation(LanguageModelError.GuardrailViolation)

    /// The model refused to answer.
    ///
    /// This failure can happen for prompts that do not violate any guardrail policy, but
    /// the model isn't able to provide the kind of response you requested. You can
    /// choose to handle this by showing a predetermined message of your choice.
    case refusal(LanguageModelError.Refusal)

    /// The model being used doesn't support a particular feature.
    ///
    /// This failure can happen if you use capabilities like guided generation or tool calling
    /// with a model that does not support them.
    case unsupportedCapability(LanguageModelError.UnsupportedCapability)

    /// The prompt contains content that the model cannot process.
    ///
    /// This failure occurs when you include unsupported file types, corrupted data, or custom
    /// content formats that the model doesn't recognize.
    case unsupportedTranscriptContent(LanguageModelError.UnsupportedTranscriptContent)

    /// An unsupported generation guide was used
    ///
    /// This failure occurs if you attempt to use generation guides that a model does not support.
    /// For example, many models don't support certain guides using certain regex patterns.
    case unsupportedGenerationGuide(LanguageModelError.UnsupportedGenerationGuide)

    /// The model was prompted to respond in a language that it does not support.
    case unsupportedLanguageOrLocale(LanguageModelError.UnsupportedLanguageOrLocale)

    /// The request timed out before the model could produce a response.
    case timeout(LanguageModelError.Timeout)

    /// Information about exceeding the context window size.
    public struct ContextSizeExceeded : Sendable {

        public var contextSize: Int

        public var tokenCount: Int

        public var debugDescription: String

        public var metadata: [String : any Sendable]

        public init(contextSize: Int, tokenCount: Int, debugDescription: String, metadata: [String : any Sendable] = [:])
    }

    /// Information about a rate limiting event.
    public struct RateLimited : Sendable {

        public var resetDate: Date?

        public var debugDescription: String

        public var metadata: [String : any Sendable]

        public init(resetDate: Date?, debugDescription: String, metadata: [String : any Sendable] = [:])
    }

    /// Information about a guardrail violation.
    public struct GuardrailViolation : Sendable {

Truncated.

public protocol LanguageModelExecutor : Sendable {

    associatedtype Configuration : Hashable, Sendable

    /// The model type this executor processes requests for.
    associatedtype Model : LanguageModel

    /// The system invokes this method in response to prewarming the session and provides an
    /// opportunity to load assets into memory or pre-fill caches.
    ///
    /// - Note: The default implementation is a no-op.
    func prewarm(model: Self.Model, transcript: Transcript)

    /// Creates an executor from a configuration.
    init(configuration: Self.Configuration) throws

    /// Creates a response stream containing deltas.
    ///
    /// - Parameters:
    ///    - request: The generation request.
    ///    - model: The model instance for this request, providing live model state.
    ///    - channel: A channel used to send events.
    ///
    /// - Note: If the model declares that it does not have a given capability
    /// via ``LanguageModel/capabilities``, then the system will automatically
    /// throw a ``LanguageModelSession.GenerationError.unsupportedCapability`` instead
    /// of invoking this method. You do not need to manually validate the request
    /// for any functionality captured by ``LanguageModelCapabilities``.
    nonisolated(nonsending) func respond(to request: LanguageModelExecutorGenerationRequest, model: Self.Model, streamingInto channel: LanguageModelExecutorGenerationChannel) async throws
}

extension LanguageModelExecutor {

    /// The system invokes this method in response to prewarming the session and provides an
    /// opportunity to load assets into memory or pre-fill caches.
    ///
    /// - Note: The default implementation is a no-op.
    public func prewarm(model: Self.Model, transcript: Transcript)
}

public struct LanguageModelExecutorGenerationChannel : AsyncSequence, Sendable {

    /// The type of element produced by this asynchronous sequence.
    public typealias Element = any LanguageModelExecutorGenerationChannel.Event

    /// The type of asynchronous iterator that produces elements of this
    /// asynchronous sequence.
    public struct AsyncIterator : AsyncIteratorProtocol {

        /// Asynchronously advances to the next element and returns it, or ends the
        /// sequence if there is no next element.
        ///
        /// - Returns: The next element, if it exists, or `nil` to signal the end of
        ///   the sequence.
        public mutating func next(isolation actor: isolated (any Actor)?) async throws -> (any LanguageModelExecutorGenerationChannel.Event)?

        @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
        @available(tvOS, unavailable)
        public typealias Element = any LanguageModelExecutorGenerationChannel.Event
    }

    /// Creates the asynchronous iterator that produces elements of this
    /// asynchronous sequence.
    ///
    /// - Returns: An instance of the `AsyncIterator` type used to produce
    /// elements of the asynchronous sequence.
    public func makeAsyncIterator() -> LanguageModelExecutorGenerationChannel.AsyncIterator

    /// Creates a new generation channel instance.
    public init()

    /// Performs a send on the channel.
    ///
    /// - Parameters:
    ///   - event: The event to send.
    nonisolated(nonsending) public func send(_ event: some LanguageModelExecutorGenerationChannel.Event) async

    /// A typed event that can be sent on a generation channel.
    public protocol Event : Sendable {

        var kind: LanguageModelExecutorGenerationChannel.EventKind { get }
    }

    /// A kind of event that can be sent on a generation channel.
    public struct EventKind : Sendable {
    }
}

extension LanguageModelExecutorGenerationChannel {

    /// Snapshot of an entry's metadata dictionary.
    ///
    /// Each event replaces the prior metadata wholesale; keys absent from `values` are
    /// considered removed.
    public struct Metadata : Sendable {

        public var values: [String : any Sendable & Codable & Equatable]
    }

    /// Snapshot of an entry's token totals.
    ///
    /// Producers report the current cumulative totals on every update and consumers replace prior totals
    /// wholesale.
    public struct Usage : Sendable {

        /// The input token counts from the transcript.
        public var input: LanguageModelExecutorGenerationChannel.Usage.Input

        /// The output token counts from the response.
        public var output: LanguageModelExecutorGenerationChannel.Usage.Output

        /// Token counts for the transcript submitted to the model.
        public struct Input : Sendable {

            /// The total number of input tokens from the transcript.
            public var totalTokenCount: Int

            /// The number of input tokens that were served from a cache.
            public var cachedTokenCount: Int

            public init(totalTokenCount: Int, cachedTokenCount: Int)
        }

        /// Token counts for the output produced by the model.
        public struct Output : Sendable {

            /// The total number of output tokens.
            public var totalTokenCount: Int

            /// The number of output tokens that were part of the model's
            /// reasoning output.
            public var reasoningTokenCount: Int

            public init(totalTokenCount: Int, reasoningTokenCount: Int)
        }

        /// Creates a usage update.
        ///
        /// - Parameters:
        ///   - input: Token counts for the transcript.
        ///   - output: Token counts for the response.
        public init(input: LanguageModelExecutorGenerationChannel.Usage.Input, output: LanguageModelExecutorGenerationChannel.Usage.Output)
    }

    /// Append text to a streaming entry's current text segment. Used by both
    /// ``Response/Action/appendText(_:)`` and ``Reasoning/Action/appendText(_:)``.
    public struct TextFragment : Sendable {

        public var content: String

        public var segmentID: String?

        public var tokenCount: Int
    }

    /// Replace a streaming entry's current text segment with `content`.
    ///
    /// The `tokenCount` is the producer's count of tokens carried by `content` and
    /// is used by safety or usage accounting to credit the replacement against
    public struct TextSegmentReplacement : Sendable {

        public var content: String

        public var segmentID: String?

        public var tokenCount: Int
    }

Truncated.

extension LanguageModelExecutorGenerationChannel.Event where Self == LanguageModelExecutorGenerationChannel.Response {

    /// Constructs a ``LanguageModelExecutorGenerationChannel/Response`` event for
    /// use at `channel.send(.response(entryID:action:))` call sites.
    public static func response(entryID: String? = nil, action: LanguageModelExecutorGenerationChannel.Response.Action) -> Self
}

extension LanguageModelExecutorGenerationChannel.Event where Self == LanguageModelExecutorGenerationChannel.ToolCalls {

    /// Constructs a ``LanguageModelExecutorGenerationChannel/ToolCalls`` event for
    /// use at `channel.send(.toolCalls(entryID:action:))` call sites.
    public static func toolCalls(entryID: String? = nil, action: LanguageModelExecutorGenerationChannel.ToolCalls.Action) -> Self
}

extension LanguageModelExecutorGenerationChannel.Event where Self == LanguageModelExecutorGenerationChannel.Reasoning {

    /// Constructs a ``LanguageModelExecutorGenerationChannel/Reasoning`` event for
    /// use at `channel.send(.reasoning(entryID:action:))` call sites.
    public static func reasoning(entryID: String? = nil, action: LanguageModelExecutorGenerationChannel.Reasoning.Action) -> Self
}

extension LanguageModelExecutorGenerationChannel.Reasoning.Action {

    public static func appendText(_ text: String, segmentID: String? = nil, tokenCount: Int) -> LanguageModelExecutorGenerationChannel.Reasoning.Action

    public static func replaceTextSegment(_ text: String, segmentID: String? = nil, tokenCount: Int) -> LanguageModelExecutorGenerationChannel.Reasoning.Action

    public static func updateSignature(_ signature: Data, tokenCount: Int) -> LanguageModelExecutorGenerationChannel.Reasoning.Action

    public static func updateMetadata(_ values: [String : any Sendable & Codable & Equatable]) -> LanguageModelExecutorGenerationChannel.Reasoning.Action

    public static func updateUsage(input: LanguageModelExecutorGenerationChannel.Usage.Input, output: LanguageModelExecutorGenerationChannel.Usage.Output) -> LanguageModelExecutorGenerationChannel.Reasoning.Action
}

extension LanguageModelExecutorGenerationChannel.Response.Action {

    public static func appendText(_ text: String, segmentID: String? = nil, tokenCount: Int) -> LanguageModelExecutorGenerationChannel.Response.Action

    public static func replaceTextSegment(_ text: String, segmentID: String? = nil, tokenCount: Int) -> LanguageModelExecutorGenerationChannel.Response.Action

    public static func updateMetadata(_ values: [String : any Sendable & Codable & Equatable]) -> LanguageModelExecutorGenerationChannel.Response.Action

    public static func updateUsage(input: LanguageModelExecutorGenerationChannel.Usage.Input, output: LanguageModelExecutorGenerationChannel.Usage.Output) -> LanguageModelExecutorGenerationChannel.Response.Action
}

extension LanguageModelExecutorGenerationChannel.ToolCalls.Action {

    public static func toolCall(id: String, name: String, action: LanguageModelExecutorGenerationChannel.ToolCalls.ToolCall.Action) -> LanguageModelExecutorGenerationChannel.ToolCalls.Action

    public static func updateMetadata(_ values: [String : any Sendable & Codable & Equatable]) -> LanguageModelExecutorGenerationChannel.ToolCalls.Action

    public static func updateUsage(input: LanguageModelExecutorGenerationChannel.Usage.Input, output: LanguageModelExecutorGenerationChannel.Usage.Output) -> LanguageModelExecutorGenerationChannel.ToolCalls.Action
}

extension LanguageModelExecutorGenerationChannel.ToolCalls.ToolCall.Action {

    public static func appendArguments(_ content: String, tokenCount: Int) -> LanguageModelExecutorGenerationChannel.ToolCalls.ToolCall.Action

    public static func updateMetadata(_ values: [String : any Sendable & Codable & Equatable]) -> LanguageModelExecutorGenerationChannel.ToolCalls.ToolCall.Action
}

public struct LanguageModelExecutorGenerationRequest : Sendable {

    /// A request id for logging and tracing purposes
    public var id: UUID

    /// A transcript to generate the next entry for
    public var transcript: Transcript

    /// The subset tool definitions that the model is allowed to call
    public var enabledToolDefinitions: [Transcript.ToolDefinition]

    /// An optional schema dictating the required output format
    public var schema: GenerationSchema?

    /// Generation options that control sampling behavior
    public var generationOptions: GenerationOptions

    /// Settings that configure how the model is prompted
    public var contextOptions: ContextOptions

    /// Metadata to attach to the request
    public var metadata: [String : any Sendable & Codable & Equatable]

    /// Creates a new generation request.
    ///
    /// - Parameters:
    ///   - id: The request identifier..
    ///   - transcript: The transcript to generate the next entry for.
    ///   - enabledTools: The subset tool definitions that the model can call.
    ///   - schema: The schema dictating the required output format.
    ///   - generationOptions: The generation options to use.
    ///   - contextOptions: The settings that configure how the model is prompted.
    ///   - metadata: The metadata to attach to the request.
    public init(id: UUID, transcript: Transcript, enabledTools: [Transcript.ToolDefinition], schema: GenerationSchema? = nil, generationOptions: GenerationOptions, contextOptions: ContextOptions, metadata: [String : any Sendable & Codable & Equatable])
}

public struct LanguageModelFeedback {

    /// A sentiment regarding the model's response.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public enum Sentiment : Sendable, CaseIterable {

        /// A positive sentiment
        case positive

        /// A negative sentiment
        case negative

        /// A neutral sentiment
        case neutral

        /// 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: LanguageModelFeedback.Sentiment, b: LanguageModelFeedback.Sentiment) -> Bool

        /// A type that can represent a collection of all values of this type.
        @available(macOS 26.0, iOS 26.0, watchOS 27.0, *)
        @available(tvOS, unavailable)
        public typealias AllCases = [LanguageModelFeedback.Sentiment]

        /// A collection of all values of this type.
        nonisolated public static var allCases: [LanguageModelFeedback.Sentiment] { get }

        /// 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 }
    }

    /// An issue with the model's response.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public struct Issue : Sendable {

        /// Categories for model response issues.
        @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
        @available(tvOS, unavailable)
        public enum Category : Sendable, CaseIterable {

            /// The response was not unhelpful.
            ///
            /// An unhelpful issue might be where you asked for a recipe, and the model gave you a list of
            /// ingredients but not amounts.
            case unhelpful

            /// The response was too verbose.
            ///

Truncated.

extension LanguageModelFeedback.Issue.Category : Equatable {
}

extension LanguageModelFeedback.Issue.Category : Hashable {
}

extension LanguageModelFeedback.Sentiment : Equatable {
}

extension LanguageModelFeedback.Sentiment : Hashable {
}

extension LanguageModelSession {

    /// Logs and serializes a feedback attachment that can be submitted to Apple.
    ///
    /// This method creates a structured feedback attachment containing the session's transcript
    /// and any provided feedback information. The attachment can be saved to a file and submitted
    /// to Apple using [Feedback Assistant](https://feedbackassistant.apple.com).
    ///
    /// If an error occurred during a previous response, any rejected entries that were rolled
    /// back from the transcript are included in the feedback data.
    ///
    /// ```swift
    /// let session = LanguageModelSession()
    /// let response = try await session.respond(to: "What is the capital of France?")
    ///
    /// // Create feedback for a helpful response
    /// let feedbackData = session.logFeedbackAttachment(sentiment: .positive)
    ///
    /// // Or create feedback for a problematic response
    /// let feedbackData = session.logFeedbackAttachment(
    ///     sentiment: .negative,
    ///     issues: [
    ///         LanguageModelFeedback.Issue(
    ///             category: .incorrect,
    ///             explanation: "The model provided outdated information"
    ///         )
    ///     ],
    ///     desiredOutput: Transcript.Entry.response(...)
    /// )
    /// ```
    ///
    /// If your `desiredOutput` is a string, use ``Transcript/Entry/response(_:)`` to turn your desired output into a
    /// ``Transcript`` entry:
    ///
    /// ```swift
    /// let text = Transcript.TextSegment(content: "The capital of France is Paris.")
    /// let segment = Transcript.Segment.text(text)
    /// let response = Transcript.Response(segments: [segment])
    /// let entry = Transcript.Entry.response(response)
    /// ```
    ///
    /// If your `desiredOutput` is a ``Generable`` type, turning that into a ``Transcript`` entry is slightly different:
    ///
    /// ```swift
    /// let customType = MyCustomType(...) // A generable type.
    /// let structure = Transcript.StructuredSegment(schemaName: String(describing: Foo.self), content: customType.generatedContent)
    /// let segment = Transcript.Segment.structure(structure)
    /// let response = Transcript.Response(segments: [segment])
    /// let entry = Transcript.Entry.response(response)
    /// ```
    ///
    /// Finally, if you'd like to submit the feedback to Apple, write your feedback to a `.json` file and include the file as an
    /// attachment to [Feedback Assistant](https://feedbackassistant.apple.com). You can include one or many
    /// feedback attachment in the same file:
    ///
    /// ```swift
    /// let allFeedback = feedbackData + feedbackData2 + feedbackData3
    /// let url = URL(fileURLWithPath: "path/to/save/feedback.json")
    /// try allFeedback.write(to: url)
    /// ```
    ///
    /// - Parameters:
    ///   - sentiment: An optional sentiment rating about the model's output (positive, negative, or neutral).
    ///   - issues: An array of specific issues identified with the model's response. Defaults to an empty array.
    ///   - desiredOutput: An optional transcript entry showing what the desired output should have been.
    /// - Returns: A `Data` object containing the JSON-encoded feedback attachment that can be submitted to Feedback Assistant.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    @discardableResult
    final public func logFeedbackAttachment(sentiment: LanguageModelFeedback.Sentiment?, issues: [LanguageModelFeedback.Issue] = [], desiredOutput: Transcript.Entry? = nil) -> Data

    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @backDeployed(before: iOS 26.1, macOS 26.1, visionOS 26.1)
    @available(tvOS, unavailable)
    @discardableResult
    final public func logFeedbackAttachment(sentiment: LanguageModelFeedback.Sentiment?, issues: [LanguageModelFeedback.Issue] = [], desiredResponseText: String?) -> Data

    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @backDeployed(before: iOS 26.1, macOS 26.1, visionOS 26.1)
    @available(tvOS, unavailable)

Truncated.

extension LanguageModelSession : nonisolated Observable {
}

extension LanguageModelSession : @unchecked Sendable {
}

extension LanguageModelSession.DynamicProfile {

    public typealias SessionProperty = LanguageModelSession.SessionProperty
}

extension LanguageModelSession.DynamicProfileModifier {

    public typealias SessionProperty = LanguageModelSession.SessionProperty
}

extension LanguageModelSession.Error : Equatable {
}

extension LanguageModelSession.Error : Hashable {
}

extension LanguageModelSession.ResponseStream : AsyncSequence {

    /// The type of element produced by this asynchronous sequence.
    public typealias Element = LanguageModelSession.ResponseStream<Content>.Snapshot

    /// The type of asynchronous iterator that produces elements of this
    /// asynchronous sequence.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public struct AsyncIterator : AsyncIteratorProtocol {

        /// Asynchronously advances to the next element and returns it, or ends the
        /// sequence if there is no next element.
        ///
        /// - Returns: The next element, if it exists, or `nil` to signal the end of
        ///   the sequence.
        public mutating func next(isolation actor: isolated (any Actor)? = #isolation) async throws -> LanguageModelSession.ResponseStream<Content>.Snapshot?

        @available(macOS 26.0, iOS 26.0, watchOS 27.0, *)
        @available(tvOS, unavailable)
        public typealias Element = LanguageModelSession.ResponseStream<Content>.Snapshot
    }

    /// Creates the asynchronous iterator that produces elements of this
    /// asynchronous sequence.
    ///
    /// - Returns: An instance of the `AsyncIterator` type used to produce
    /// elements of the asynchronous sequence.
    public func makeAsyncIterator() -> LanguageModelSession.ResponseStream<Content>.AsyncIterator

    /// The result from a streaming response, after it completes.
    ///
    /// If the streaming response was finished successfully before calling
    /// `collect()`, this method `Response` returns immediately.
    ///
    /// If the streaming response was finished with an error before calling
    /// `collect()`, this method propagates that error.
    nonisolated(nonsending) public func collect() async throws -> sending LanguageModelSession.Response<Content>
}

extension LanguageModelSession.SessionProperty : Sendable where Value : Sendable {
}

extension Never : DynamicInstructions {

    /// The content of the dynamic instructions.
    public var body: Never { get }

    /// The type of dynamic instructions that represent these instructions.
    @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public typealias Body = Never
}

extension Never : LanguageModelSession.DynamicProfile {
}

extension Never : Generable {

    /// An instance of the generation schema.
    public static var generationSchema: GenerationSchema { get }

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    public init(_ content: GeneratedContent) throws

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    public var generatedContent: GeneratedContent { get }
}

extension Optional : DynamicInstructions where Wrapped : DynamicInstructions {

    /// The content of the dynamic instructions.
    public var body: Never { get }

    /// The type of dynamic instructions that represent these instructions.
    @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public typealias Body = Never
}

extension Optional where Wrapped : Generable {

    public typealias PartiallyGenerated = Wrapped.PartiallyGenerated
}

extension Optional : ConvertibleToGeneratedContent, PromptRepresentable, InstructionsRepresentable where Wrapped : ConvertibleToGeneratedContent {

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    public var generatedContent: GeneratedContent { get }
}

extension PrivateCloudComputeLanguageModel {

    /// The usage quota state for a Private Cloud Compute language model.
    ///
    /// A quota describes the model's per-user request budget and where the
    /// caller currently sits relative to it. Quotas are orthogonal to a
    /// model's availability — a model can be available even after its usage
    /// limit has been reached.
    public struct QuotaUsage : Sendable {

        /// The current quota status.
        public var status: PrivateCloudComputeLanguageModel.QuotaUsage.Status

        /// A Boolean indicating whether the usage limit has been reached.
        public var isLimitReached: Bool { get }

        /// A suggestion the user can act on to increase their quota.
        ///
        /// A `nil` value indicates that the model provider does not surface an
        /// upgrade path through this API.
        public var limitIncreaseSuggestion: PrivateCloudComputeLanguageModel.QuotaUsage.LimitIncreaseSuggestion?

        /// The date at which the quota will refresh.
        ///
        /// A `nil` value indicates that the model provider has not reported a reset
        /// time. This may be because the provider's limit does not refresh on a
        /// fixed schedule, or because the provider does not expose this information.
        public var resetDate: Date?

        /// The quota status of a language model.
        public enum Status : Sendable {

            case belowLimit(PrivateCloudComputeLanguageModel.QuotaUsage.Status.BelowLimit)

            case limitReached(PrivateCloudComputeLanguageModel.QuotaUsage.Status.LimitReached)

            public struct BelowLimit : Sendable {

                public var isApproachingLimit: Bool
            }

            public struct LimitReached : Sendable {
            }
        }

        /// An offer that a user can act on to increase their quota for a language model.
        public struct LimitIncreaseSuggestion : Sendable {

            /// Presents the limit increase flow to the user.
            public func show()
        }
    }
}

extension PrivateCloudComputeLanguageModel : nonisolated Observable {
}

extension PrivateCloudComputeLanguageModel : LanguageModel {

    /// The capabilities of this language model.
    ///
    /// If a developer attempts to use capabilities that your model does not support,
    /// then the system will automatically throw a
    /// ``LanguageModelSession.GenerationError.unsupportedFeature`` error for
    /// you instead of calling ``respond(to:)``.
    final public var capabilities: LanguageModelCapabilities { get }

    /// A configuration for an executor capable of running this model.
    final public var executorConfiguration: PrivateCloudComputeLanguageModel.Executor.Configuration { get }

    public struct Executor : LanguageModelExecutor {

        /// The model type this executor processes requests for.
        public typealias Model = PrivateCloudComputeLanguageModel

        /// Creates an executor from a configuration.
        public init(configuration: PrivateCloudComputeLanguageModel.Executor.Configuration)

        /// The system invokes this method in response to prewarming the session and provides an
        /// opportunity to load assets into memory or pre-fill caches.
        ///
        /// - Note: The default implementation is a no-op.
        public func prewarm(model: PrivateCloudComputeLanguageModel.Executor.Model, transcript: Transcript)

        /// Creates a response stream containing deltas.
        ///
        /// - Parameters:
        ///    - request: The generation request.
        ///    - model: The model instance for this request, providing live model state.
        ///    - channel: A channel used to send events.
        ///
        /// - Note: If the model declares that it does not have a given capability
        /// via ``LanguageModel/capabilities``, then the system will automatically
        /// throw a ``LanguageModelSession.GenerationError.unsupportedCapability`` instead
        /// of invoking this method. You do not need to manually validate the request
        /// for any functionality captured by ``LanguageModelCapabilities``.
        nonisolated(nonsending) public func respond(to request: LanguageModelExecutorGenerationRequest, model: PrivateCloudComputeLanguageModel, streamingInto channel: LanguageModelExecutorGenerationChannel) async throws
    }
}

extension PrivateCloudComputeLanguageModel.Availability.UnavailableReason : Hashable {
}

extension PrivateCloudComputeLanguageModel.Executor {

    public struct Configuration : Hashable & Sendable {

        /// 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: PrivateCloudComputeLanguageModel.Executor.Configuration, b: PrivateCloudComputeLanguageModel.Executor.Configuration) -> 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 }
    }
}

public struct Prompt : Sendable {

    /// Creates an instance with the content you specify.
    public init(_ content: some PromptRepresentable)
}

extension Prompt : PromptRepresentable {

    /// An instance that represents a prompt.
    public var promptRepresentation: Prompt { get }
}

extension Prompt {

    public init(@PromptBuilder _ content: () throws -> Prompt) rethrows
}

@resultBuilder public struct PromptBuilder {

    /// Creates a builder with a block.
    public static func buildBlock<each P>(_ components: repeat each P) -> Prompt where repeat each P : PromptRepresentable

    /// Creates a builder with the an array of prompts.
    public static func buildArray(_ prompts: [some PromptRepresentable]) -> Prompt

    /// Creates a builder with the first component.
    public static func buildEither(first component: some PromptRepresentable) -> Prompt

    /// Creates a builder with the second component.
    public static func buildEither(second component: some PromptRepresentable) -> Prompt

    /// Creates a builder with an optional component.
    public static func buildOptional(_ component: Prompt?) -> Prompt

    /// Creates a builder with a limited availability prompt.
    public static func buildLimitedAvailability(_ prompt: some PromptRepresentable) -> Prompt

    /// Creates a builder with an expression.
    public static func buildExpression<P>(_ expression: P) -> P where P : PromptRepresentable

    /// Creates a builder with a prompt expression.
    public static func buildExpression(_ expression: Prompt) -> Prompt
}

public protocol PromptRepresentable {

    /// An instance that represents a prompt.
    @PromptBuilder var promptRepresentation: Prompt { get }
}

extension Result : PromptRepresentable where Success : PromptRepresentable, Failure : PromptRepresentable {

    /// An instance that represents a prompt.
    public var promptRepresentation: Prompt { get }
}

public protocol SessionPropertyKey : SendableMetatype {

    /// The type of value that represent this property key.
    associatedtype Value

    /// The default value of the property key.
    static var defaultValue: Self.Value { get }
}

extension SessionPropertyValues {

    /// The transcript of the session.
    final public var history: ArraySlice<Transcript.Entry>

    /// The root dynamic instructions.
    @available(iOS 27.0, macOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    final public var rootDynamicInstructions: any DynamicInstructions
}

extension SessionPropertyValues : nonisolated Observable {
}

extension String : Generable {

    /// An instance of the generation schema.
    public static var generationSchema: GenerationSchema { get }

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    public init(_ content: GeneratedContent) throws

    /// This instance represented as generated content.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. Use the generated content property as shown below, to
    /// manually return a new ``GeneratedContent`` with the properties you specify.
    ///
    /// ```swift
    /// struct Person: ConvertibleToGeneratedContent {
    ///    var name: String
    ///    var age: Int
    ///
    ///    var generatedContent: GeneratedContent {
    ///        GeneratedContent(properties: [
    ///            "firstName": name,
    ///            "ageInYears": age
    ///        ])
    ///    }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
    public var generatedContent: GeneratedContent { get }
}

extension String : InstructionsRepresentable {

    /// An instance that represents the instructions.
    public var instructionsRepresentation: Instructions { get }
}

extension String : PromptRepresentable {

    /// An instance that represents a prompt.
    public var promptRepresentation: Prompt { get }
}

extension SystemLanguageModel : LanguageModel {

    /// The capabilities of this language model.
    ///
    /// If a developer attempts to use capabilities that your model does not support,
    /// then the system will automatically throw a
    /// ``LanguageModelSession.GenerationError.unsupportedFeature`` error for
    /// you instead of calling ``respond(to:)``.
    final public var capabilities: LanguageModelCapabilities { get }

    /// A configuration for an executor capable of running this model.
    final public var executorConfiguration: SystemLanguageModel.Executor.Configuration { get }

    public struct Executor : LanguageModelExecutor {

        /// The model type this executor processes requests for.
        public typealias Model = SystemLanguageModel

        /// Creates an executor from a configuration.
        public init(configuration: SystemLanguageModel.Executor.Configuration)

        /// The system invokes this method in response to prewarming the session and provides an
        /// opportunity to load assets into memory or pre-fill caches.
        ///
        /// - Note: The default implementation is a no-op.
        public func prewarm(model: SystemLanguageModel.Executor.Model, transcript: Transcript)

        /// Creates a response stream containing deltas.
        ///
        /// - Parameters:
        ///    - request: The generation request.
        ///    - model: The model instance for this request, providing live model state.
        ///    - channel: A channel used to send events.
        ///
        /// - Note: If the model declares that it does not have a given capability
        /// via ``LanguageModel/capabilities``, then the system will automatically
        /// throw a ``LanguageModelSession.GenerationError.unsupportedCapability`` instead
        /// of invoking this method. You do not need to manually validate the request
        /// for any functionality captured by ``LanguageModelCapabilities``.
        nonisolated(nonsending) public func respond(to request: LanguageModelExecutorGenerationRequest, model: SystemLanguageModel, streamingInto channel: LanguageModelExecutorGenerationChannel) async throws
    }
}

extension SystemLanguageModel.Executor {

    public struct Configuration : Hashable & Sendable {

        /// 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: SystemLanguageModel.Executor.Configuration, b: SystemLanguageModel.Executor.Configuration) -> 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 }
    }
}

public protocol Tool<Arguments, Output> : Sendable {

    /// The output that this tool produces for the language model to reason about in subsequent
    /// interactions.
    ///
    /// Typically output is either a `String` or a ``Generable`` type.
    associatedtype Output : PromptRepresentable

    /// The arguments that this tool should accept.
    ///
    /// Typically arguments are either a ``Generable`` type or ``GeneratedContent``.
    associatedtype Arguments : ConvertibleFromGeneratedContent

    /// A unique name for the tool, such as "get_weather", "toggleDarkMode", or "search contacts".
    var name: String { get }

    /// A natural language description of when and how to use the tool.
    var description: String { get }

    /// A schema for the parameters this tool accepts.
    var parameters: GenerationSchema { get }

    /// If true, the model's name, description, and parameters schema will be injected
    /// into the instructions of sessions that leverage this tool.
    ///
    /// The default implementation is `true`
    ///
    /// - Note: This should only be `false` if the model has been trained to have
    /// innate knowledge of this tool. For zero-shot prompting, it should always be `true`.
    var includesSchemaInInstructions: Bool { get }

    /// A language model will call this method when it wants to leverage this tool.
    ///
    /// If errors are throw in the body of this method, they will be wrapped in a
    /// ``LanguageModelSession/ToolCallError`` and rethrown at the call site
    /// of ``LanguageModelSession/respond(to:options:)-(Prompt,_)``.
    ///
    /// - Note: This method may be invoked concurrently with itself or with other tools.
    @concurrent func call(arguments: Self.Arguments) async throws -> Self.Output
}

extension Tool {

    /// A unique name for the tool, such as "get_weather", "toggleDarkMode", or "search contacts".
    public var name: String { get }

    /// If true, the model's name, description, and parameters schema will be injected
    /// into the instructions of sessions that leverage this tool.
    ///
    /// The default implementation is `true`
    ///
    /// - Note: This should only be `false` if the model has been trained to have
    /// innate knowledge of this tool. For zero-shot prompting, it should always be `true`.
    public var includesSchemaInInstructions: Bool { get }
}

extension Tool where Self.Arguments : Generable {

    /// A schema for the parameters this tool accepts.
    public var parameters: GenerationSchema { get }
}

extension Transcript : MutableCollection {

    /// A type representing the sequence's elements.
    @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public typealias Element = Transcript.Entry

    /// A collection representing a contiguous subrange of this collection's
    /// elements. The subsequence shares indices with the original collection.
    ///
    /// The default subsequence type for collections that don't define their own
    /// is `Slice`.
    @available(macOS 27.0, iOS 27.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public typealias SubSequence = Slice<Transcript>
}

extension Transcript : RangeReplaceableCollection {

    /// Creates a new, empty collection.
    public init()

    /// Replaces the specified subrange of elements with the given collection.
    ///
    /// This method has the effect of removing the specified range of elements
    /// from the collection and inserting the new elements at the same location.
    /// The number of new elements need not match the number of elements being
    /// removed.
    ///
    /// In this example, three elements in the middle of an array of integers are
    /// replaced by the five elements of a `Repeated<Int>` instance.
    ///
    ///      var nums = [10, 20, 30, 40, 50]
    ///      nums.replaceSubrange(1...3, with: repeatElement(1, count: 5))
    ///      print(nums)
    ///      // Prints "[10, 1, 1, 1, 1, 1, 50]"
    ///
    /// If you pass a zero-length range as the `subrange` parameter, this method
    /// inserts the elements of `newElements` at `subrange.startIndex`. Calling
    /// the `insert(contentsOf:at:)` method instead is preferred.
    ///
    /// Likewise, if you pass a zero-length collection as the `newElements`
    /// parameter, this method removes the elements in the given subrange
    /// without replacement. Calling the `removeSubrange(_:)` method instead is
    /// preferred.
    ///
    /// Calling this method may invalidate any existing indices for use with this
    /// collection.
    ///
    /// - Parameters:
    ///   - subrange: The subrange of the collection to replace. The bounds of
    ///     the range must be valid indices of the collection.
    ///   - newElements: The new elements to add to the collection.
    ///
    /// - Complexity: O(*n* + *m*), where *n* is length of this collection and
    ///   *m* is the length of `newElements`. If the call to this method simply
    ///   appends the contents of `newElements` to the collection, this method is
    ///   equivalent to `append(contentsOf:)`.
    public mutating func replaceSubrange<C>(_ subrange: Range<Int>, with newElements: consuming C) where C : Collection, C.Element == Transcript.Entry
}

extension Transcript {

    /// The transcript entries excluding the leading instructions entry, if present.
    ///
    /// Use `history` to access just the conversational entries — prompts, responses,
    /// tool calls, and tool outputs — without the initial instructions that were used
    /// to configure the session.
    ///
    /// When reading, if the first entry in the transcript is an ``Entry/instructions(_:)``
    /// entry, it is excluded from the returned slice. All other entries, including any
    /// subsequent instructions entries, are included.
    ///
    /// When writing, the new value replaces all entries except the leading instructions
    /// entry, which is preserved.
    public var history: ArraySlice<Transcript.Entry>
}

public struct Transcript : Sendable, Equatable, RandomAccessCollection {

    /// A type that represents a position in the collection.
    ///
    /// Valid indices consist of the position of every element and a
    /// "past the end" position that's not valid for use as a subscript
    /// argument.
    public typealias Index = Int

    /// Accesses the element at the specified position.
    ///
    /// The following example accesses an element of an array through its
    /// subscript to print its value:
    ///
    ///     var streets = ["Adams", "Bryant", "Channing", "Douglas", "Evarts"]
    ///     print(streets[1])
    ///     // Prints "Bryant"
    ///
    /// You can subscript a collection with any valid index other than the
    /// collection's end index. The end index refers to the position one past
    /// the last element of a collection, so it doesn't correspond with an
    /// element.
    ///
    /// - Parameter position: The position of the element to access. `position`
    ///   must be a valid index of the collection that is not equal to the
    ///   `endIndex` property.
    ///
    /// - Complexity: O(1)
    public subscript(index: Transcript.Index) -> Transcript.Entry

    /// The position of the first element in a nonempty collection.
    ///
    /// If the collection is empty, `startIndex` is equal to `endIndex`.
    public var startIndex: Int { get }

    /// The collection's "past the end" position---that is, the position one
    /// greater than the last valid subscript argument.
    ///
    /// When you need a range that includes the last element of a collection, use
    /// the half-open range operator (`..<`) with `endIndex`. The `..<` operator
    /// creates a range that doesn't include the upper bound, so it's always
    /// safe to use with `endIndex`. For example:
    ///
    ///     let numbers = [10, 20, 30, 40, 50]
    ///     if let index = numbers.firstIndex(of: 30) {
    ///         print(numbers[index ..< numbers.endIndex])
    ///     }
    ///     // Prints "[30, 40, 50]"
    ///
    /// If the collection is empty, `endIndex` is equal to `startIndex`.
    public var endIndex: Int { get }

    /// Creates a transcript.
    ///
    /// - Parameters:
    ///   - entries: An array of entries to seed the transcript.
    public init(entries: some Sequence<Transcript.Entry> = [])

    /// An entry in a transcript.
    ///
    /// An individual entry in a transcript may represent instructions from you
    /// to the model, a prompt from a user, tool calls, or a response generated
    /// by the model.
    @available(iOS 26.0, macOS 26.0, watchOS 27.0, *)
    @available(tvOS, unavailable)
    public enum Entry : Sendable, Identifiable, Equatable {

        /// Instructions, typically provided by you, the developer.
        case instructions(Transcript.Instructions)

        /// A prompt, typically sourced from an end user.
        case prompt(Transcript.Prompt)

        /// A tool call containing a tool name and the arguments to invoke it with.
        case toolCalls(Transcript.ToolCalls)

        /// An tool output provided back to the model.
        case toolOutput(Transcript.ToolOutput)

        /// A response from the model.

Truncated.

extension Transcript : Codable {

    /// Creates a new instance by decoding from the given decoder.
    ///
    /// This initializer throws an error if reading from the decoder fails, or
    /// if the data read is corrupted or otherwise invalid.
    ///
    /// - Parameter decoder: The decoder to read data from.
    public init(from decoder: any Decoder) throws

    /// Encodes this value into the given encoder.
    ///
    /// If the value fails to encode anything, `encoder` will encode an empty
    /// keyed container in its place.
    ///
    /// This function throws an error if any values are invalid for the given
    /// encoder's format.
    ///
    /// - Parameter encoder: The encoder to write data to.
    public func encode(to encoder: any Encoder) throws
}

extension Transcript.AttachmentSegment : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension Transcript.CustomSegment {

    /// An instance that represents the instructions.
    public var instructionsRepresentation: Instructions { get }
}

extension Transcript.Entry : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension Transcript.Instructions : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension Transcript.Prompt : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension Transcript.Reasoning {

    public var description: String { get }
}

extension Transcript.Response : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension Transcript.ResponseFormat : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension Transcript.Segment : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension Transcript.StructuredSegment : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension Transcript.TextSegment : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension Transcript.ToolCall : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension Transcript.ToolCalls : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}