import Distributed
import Foundation
import Swift
import SymbolTests
import SymbolTestsCore
import _Concurrency
import _StringProcessing
import _SwiftConcurrencyShims

var globalConstant: Swift.Int {
    get
}
var globalVariable: Swift.String

func getContiguousArrayStorageType<A>(for: A.Type) -> Swift._ContiguousArrayStorage<A>.Type
func globalGenericFunction<A>(_: A) -> A.Body where A: SymbolTestsCore.Protocols.ProtocolTest
func globalThrowingFunction() throws -> Swift.String
func globalAsyncFunction() async -> Swift.Int
func globalFunction() -> Swift.Int

enum AccessorFunctionReferences {
    struct NoncopyableResourceTest: ~Swift.Copyable {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var fileDescriptor: Swift.Int

        init(fileDescriptor: Swift.Int)

        deinit
    }
    struct NoncopyableGenericBoxTest<A>: ~Swift.Copyable where A: ~Swift.Copyable {
        // Field offset: unknown (generic parameter not substituted)
        var wrapped: A
    }
    struct NoncopyableFieldHolderTest: ~Swift.Copyable {
        // Field offset: unknown (unsupported type kind AccessorFunctionReference)
        var resource: accessor function at <offset>
        // Field offset: unknown (preceding field unresolved)
        var boxedInteger: accessor function at <offset>
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailingOrdinaryField: Swift.Int

        init(resource: SymbolTestsCore.AccessorFunctionReferences.NoncopyableResourceTest, boxedInteger: SymbolTestsCore.AccessorFunctionReferences.NoncopyableGenericBoxTest<Swift.Int>, trailingOrdinaryField: Swift.Int)
    }
    enum NoncopyablePayloadEnumTest: ~Swift.Copyable {
        case holding(accessor function at <offset>)
        case boxed(accessor function at <offset>)
        case empty

        func consumeFileDescriptor() -> Swift.Int
    }
}
enum Actors {
    actor ActorTest {
        // Field offset: 0x10
        // Type Layout: (size: 96, stride: 96, alignment: 16, extraInhabitantCount: 0)
        var $defaultActor: Builtin.DefaultActorStorage
        // Field offset: 0x70
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var state: Swift.Int

        var unownedExecutor: Swift.UnownedSerialExecutor {
            get
        }

        func mutateState()
        func nonisolatedMethod() -> Swift.String
        func readState() -> Swift.Int

        deinit
    }
    @globalActor
    actor CustomGlobalActor {
        // Field offset: 0x10
        // Type Layout: (size: 96, stride: 96, alignment: 16, extraInhabitantCount: 0)
        var $defaultActor: Builtin.DefaultActorStorage

        var unownedExecutor: Swift.UnownedSerialExecutor {
            get
        }

        static let shared: SymbolTestsCore.Actors.CustomGlobalActor

        deinit
    }
    class GlobalActorAnnotatedClass {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int

        func method() -> Swift.Int

        deinit
    }
    class MainActorAnnotatedTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int

        func nonisolatedMethod() -> Swift.String
        func method() -> Swift.Int

        deinit
    }
    class GlobalActorIsolatedConformanceTest {
        init()

        func customIsolatedRequirement()
        func isolatedRequirement()

        deinit
    }
    protocol GlobalActorIsolatedProtocolTest {
        func isolatedRequirement()
    }
    protocol CustomGlobalActorIsolatedProtocolTest {
        func customIsolatedRequirement()
    }
}
enum AssociatedTypeWitnessPatterns {
    struct ConcreteWitnessTest {}
    struct NestedWitnessTest {
        struct NestedFirst {}
        struct NestedThird {}
    }
    struct GenericParameterWitnessTest<A> {}
    struct RecursiveWitnessTest {}
    struct DependentWitnessTest<A> where A: Swift.Collection {}
    protocol AssociatedPatternProtocol where Self.Second: Swift.Collection {
        associatedtype First
        associatedtype Second
        associatedtype Third
        associatedtype Fourth
        associatedtype Fifth
    }
}
enum AsyncSequenceTests {
    struct AsyncSequenceTest {
        struct AsyncIterator {
            func next() async -> Swift.Int?
        }
        func makeAsyncIterator() -> SymbolTestsCore.AsyncSequenceTests.AsyncSequenceTest.AsyncIterator
    }
    struct ThrowingAsyncSequenceTest {
        struct AsyncIterator {
            func next() async throws -> Swift.String?
        }
        func makeAsyncIterator() -> SymbolTestsCore.AsyncSequenceTests.ThrowingAsyncSequenceTest.AsyncIterator
    }
    struct GenericAsyncSequenceTest<A> {
        struct AsyncIterator {
            init()

            func next() async -> A?
        }
        func makeAsyncIterator() -> SymbolTestsCore.AsyncSequenceTests.GenericAsyncSequenceTest<A>.AsyncIterator
    }
}
enum Attributes {
    @propertyWrapper
    struct PropertyWrapperStruct<A> where A: Swift.Comparable {
        // Field offset: unknown (generic parameter not substituted)
        var wrappedValue: A
        // Field offset: unknown (preceding field unresolved)
        var projectedValue: Swift.ClosedRange<A>

        init(wrappedValue: A, range: Swift.ClosedRange<A>)
    }
    @resultBuilder
    struct ResultBuilderStruct<A> {
        static func buildBlock(_: A...) -> [A]
        static func buildOptional(_: [A]?) -> [A]
    }
    @dynamicMemberLookup
    struct DynamicMemberLookupStruct {
        subscript(dynamicMember: Swift.String) -> Swift.Int {
            get
        }
    }
    @dynamicCallable
    struct DynamicCallableStruct {
        func dynamicallyCall(withArguments: [Swift.Int]) -> Swift.Int
        func dynamicallyCall(withKeywordArguments: Swift.KeyValuePairs<Swift.String, Swift.Int>) -> Swift.Int
    }
    class ObjCAttributeClass: __C.NSObject {
        @objc init()

        @objc func objcMethod()
        func nonobjcMethod()
        @objc func objcDynamicMethod()

        deinit
    }
}
struct TestsValues {}
enum BasicTypes {
    class TestsObjects {
        deinit
    }
}
enum BuiltinTypeFields {
    struct IntegerTypesTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var intField: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var int8Field: Swift.Int8
        // Field offset: 0xa
        // Type Layout: (size: 2, stride: 2, alignment: 2, extraInhabitantCount: 0)
        var int16Field: Swift.Int16
        // Field offset: 0xc
        // Type Layout: (size: 4, stride: 4, alignment: 4, extraInhabitantCount: 0)
        var int32Field: Swift.Int32
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var int64Field: Swift.Int64
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var uintField: Swift.UInt
        // Field offset: 0x20
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var uint8Field: Swift.UInt8
        // Field offset: 0x22
        // Type Layout: (size: 2, stride: 2, alignment: 2, extraInhabitantCount: 0)
        var uint16Field: Swift.UInt16
        // Field offset: 0x24
        // Type Layout: (size: 4, stride: 4, alignment: 4, extraInhabitantCount: 0)
        var uint32Field: Swift.UInt32
        // Field offset: 0x28
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var uint64Field: Swift.UInt64

        init(intField: Swift.Int, int8Field: Swift.Int8, int16Field: Swift.Int16, int32Field: Swift.Int32, int64Field: Swift.Int64, uintField: Swift.UInt, uint8Field: Swift.UInt8, uint16Field: Swift.UInt16, uint32Field: Swift.UInt32, uint64Field: Swift.UInt64)
    }
    struct FloatingTypesTest {
        // Field offset: 0x0
        // Type Layout: (size: 4, stride: 4, alignment: 4, extraInhabitantCount: 0)
        var floatField: Swift.Float
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var doubleField: Swift.Double
        // Field offset: 0x10
        // Type Layout: (size: 4, stride: 4, alignment: 4, extraInhabitantCount: 0)
        var float32Field: Swift.Float
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var float64Field: Swift.Double

        init(floatField: Swift.Float, doubleField: Swift.Double, float32Field: Swift.Float, float64Field: Swift.Double)
    }
    struct PrimitiveTypesTest {
        // Field offset: 0x0
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 254)
        var boolField: Swift.Bool
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var characterField: Swift.Character
        // Field offset: 0x18
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var stringField: Swift.String

        init(boolField: Swift.Bool, characterField: Swift.Character, stringField: Swift.String)
    }
    struct TupleBuiltinTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var pairField: (Swift.Int, Swift.Double)
        // Field offset: 0x10
        // Type Layout: (size: 17, stride: 24, alignment: 8, extraInhabitantCount: 254)
        var tripleField: (Swift.Int, Swift.Double, Swift.Bool)
        // Field offset: 0x28
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var quadrupleField: (Swift.Int8, Swift.Int16, Swift.Int32, Swift.Int64)

        init(pairField: (Swift.Int, Swift.Double), tripleField: (Swift.Int, Swift.Double, Swift.Bool), quadrupleField: (Swift.Int8, Swift.Int16, Swift.Int32, Swift.Int64))
    }
}
enum ClassBoundGenerics {
    struct AnyObjectBoundTest<A> where A: AnyObject {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var element: A

        init(element: A)
    }
    struct AnyObjectAndProtocolBoundTest<A> where A: AnyObject, A: SymbolTestsCore.Protocols.ProtocolTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var element: A

        init(element: A)
    }
    class ClassBoundGenericClassTest<A> where A: AnyObject {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var element: A

        init(element: A)

        deinit
    }
    struct ClassBoundFunctionTest {
        func acceptClassBound<A>(_: A) -> A where A: AnyObject
        func acceptClassAndProtocol<A>(_: A) -> A where A: AnyObject, A: SymbolTestsCore.Protocols.ProtocolTest
    }
    protocol ClassBoundGenericProtocol: AnyObject where Self.Item: AnyObject {
        associatedtype Item

        var item: Self.Item {
            get
        }
    }
}
enum Classes {
    class ExternalSwiftSubclassTest: SymbolTestsHelper.Object {
        override init()

        override func instanceMethod() -> Swift.String

        deinit
    }
    class ExternalObjCSubclassTest: __C.NSObject {
        @objc init()

        @objc func isKind(of: Swift.AnyObject.Type) -> Swift.Bool

        deinit
    }
    class ClassTest {
        var dynamicVariable: Swift.Bool {
            get
            set
        }
        var instanceVariable: Swift.Bool {
            get
            set
        }

        func dynamicMethod()
        func instanceMethod() -> Self

        deinit
    }
    class SubclassTest: SymbolTestsCore.Classes.ClassTest {
        override var dynamicVariable: Swift.Bool {
            get
            set
        }
        override var instanceVariable: Swift.Bool {
            get
            set
        }

        func dynamicMethod()
        override func instanceMethod() -> Self

        deinit
    }
    class FinalClassTest: SymbolTestsCore.Classes.SubclassTest {
        override var dynamicVariable: Swift.Bool {
            get
            set
        }

        override func dynamicMethod()
        override func instanceMethod() -> Self

        deinit
    }
    class StoredPropertiesTest {
        // Field offset: 0x10
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        let constantProperty: Swift.String
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var variableProperty: Swift.Int
        // Field offset: 0x28
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        weak var weakDelegate: Swift.AnyObject?
        // Field offset: 0x30
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483646)
        lazy var lazyProperty: Swift.String?

        init(constantProperty: Swift.String, variableProperty: Swift.Int)

        deinit
    }
    class OpenAccessTest {
        init()

        var openProperty: Swift.Int {
            get
            set
        }

        func openMethod() -> Swift.String
        func publicMethod() -> Swift.Int

        deinit
    }
    class OpenAccessSubTest: SymbolTestsCore.Classes.OpenAccessTest {
        override init()

        override var openProperty: Swift.Int {
            get
            set
        }

        override func openMethod() -> Swift.String

        deinit
    }
    class ObjCMembersTest: __C.NSObject {
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var property: Swift.Int

        @objc init()

        @objc func method() -> Swift.Int

        deinit
    }
    class RequiredInitClassTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let identifier: Swift.Int

        init(identifier: Swift.Int)

        deinit
    }
    class DefaultParameterClassTest {
        init()

        func method(first: Swift.Int, second: Swift.String) -> Swift.Int

        class func classMethod(value: Swift.Int) -> Swift.Int

        deinit
    }
}
enum CodableTests {
    struct SynthesizedCodableTest {
        enum CodingKeys {
            case identifier
            case name
            case optionalValue
        }
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var identifier: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var name: Swift.String
        // Field offset: 0x18
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var optionalValue: Swift.Double?

        init(identifier: Swift.Int, name: Swift.String, optionalValue: Swift.Double?)
    }
    struct CustomCodableTest {
        enum CodingKeys {
            case displayName
            case hiddenCount
        }
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var displayName: Swift.String
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var hiddenCount: Swift.Int

        init(displayName: Swift.String, hiddenCount: Swift.Int)
    }
    class CodableClassTest {
        enum CodingKeys {
            case identifier
            case label
        }
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var identifier: Swift.Int
        // Field offset: 0x18
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var label: Swift.String

        init(identifier: Swift.Int, label: Swift.String)

        deinit
    }
    enum CodableEnumTest {
        enum CodingKeys {
            case empty
            case withValue
            case withPair
        }
        enum EmptyCodingKeys {}
        enum WithValueCodingKeys {
            case _0
        }
        enum WithPairCodingKeys {
            case left
            case right
        }
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        case withValue(Swift.Int)
        // Type Layout: (size: 24, stride: 24, alignment: 8, extraInhabitantCount: 2147483647)
        case withPair(left: Swift.String, right: Swift.Int)
        case empty
    }
    struct GenericCodableTest<A> where A: Swift.Decodable, A: Swift.Encodable {
        enum CodingKeys {
            case element
            case metadata
        }
        // Field offset: unknown (generic parameter not substituted)
        var element: A
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var metadata: [Swift.String : Swift.String]

        init(element: A, metadata: [Swift.String : Swift.String])
    }
}
enum CollectionConformances {
    struct CustomSequenceTest {
        struct Iterator {
            func next() -> Swift.Int?
        }
        func makeIterator() -> SymbolTestsCore.CollectionConformances.CustomSequenceTest.Iterator
    }
    struct CustomCollectionTest {
        var endIndex: Swift.Int {
            get
        }
        var startIndex: Swift.Int {
            get
        }

        func index(after: Swift.Int) -> Swift.Int

        subscript(_: Swift.Int) -> Swift.Int {
            get
        }
    }
    struct CustomBidirectionalCollectionTest {
        var endIndex: Swift.Int {
            get
        }
        var startIndex: Swift.Int {
            get
        }

        func index(before: Swift.Int) -> Swift.Int
        func index(after: Swift.Int) -> Swift.Int

        subscript(_: Swift.Int) -> Swift.String {
            get
        }
    }
    struct CustomRandomAccessCollectionTest {
        var endIndex: Swift.Int {
            get
        }
        var startIndex: Swift.Int {
            get
        }

        func index(after: Swift.Int) -> Swift.Int
        func index(before: Swift.Int) -> Swift.Int

        subscript(_: Swift.Int) -> Swift.Double {
            get
        }
    }
}
enum Concurrency {
    struct AsyncFunctionTest {
        func asyncFunction() async -> Swift.Int
        func asyncThrowsFunction() async throws -> Swift.Int
        func throwsFunction() throws -> Swift.Int
    }
    struct TypedThrowsErrorTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var message: Swift.String
    }
    struct TypedThrowsFunctionTest {
        func asyncTypedThrowsFunction() async throws(SymbolTestsCore.Concurrency.TypedThrowsErrorTest) -> Swift.Int
        func typedThrowsFunction() throws(SymbolTestsCore.Concurrency.TypedThrowsErrorTest) -> Swift.Int
    }
    struct SendableClosureTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var sendableClosure: @Sendable () -> ()

        func acceptSendable(_: @Sendable () -> ())
        func acceptSendableAsync(_: nonisolated(nonsending) @Sendable () async -> ())
        func acceptSendableThrows(_: @Sendable () throws -> ())
    }
    struct SendableTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var name: Swift.String
    }
}
enum ConditionalConformanceVariants {
    struct ConditionalContainerTest<A> {
        // Field offset: unknown (generic parameter not substituted)
        var element: A

        init(element: A)
    }
    protocol ConditionalFirstProtocol {}
    protocol ConditionalSecondProtocol {}
    protocol ConditionalThirdProtocol {}
}
enum CustomLiterals {
    struct IntegerLiteralTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let value: Swift.Int64

        init(integerLiteral: Swift.Int64)
    }
    struct StringLiteralTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        let value: Swift.String

        init(unicodeScalarLiteral: Swift.String)
        init(stringLiteral: Swift.String)
        init(extendedGraphemeClusterLiteral: Swift.String)
    }
    struct ArrayLiteralTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        let elements: [Swift.Int]

        init(arrayLiteral: Swift.Int...)
    }
    struct DictionaryLiteralTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        let elements: [Swift.String : Swift.Int]

        init(dictionaryLiteral: (Swift.String, Swift.Int)...)
    }
    struct BooleanLiteralTest {
        // Field offset: 0x0
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 254)
        let value: Swift.Bool

        init(booleanLiteral: Swift.Bool)
    }
    struct FloatLiteralTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let value: Swift.Double

        init(floatLiteral: Swift.Double)
    }
    struct NilLiteralTest {
        init(nilLiteral: ())
    }
}
enum DefaultImplementationVariants {
    protocol BasicDefaultProtocol {
        func required() -> Swift.Int
        func withDefault() -> Swift.String
        func withDefaultAndGeneric<A1>(_: A1) -> A1
    }
    protocol ConstrainedDefaultProtocol {
        associatedtype Element

        var element: Self.Element {
            get
        }
    }
}
enum DeinitVariants {
    class SimpleDeinitTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int

        init()

        deinit
    }
    class DeinitWithWorkTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var resource: Swift.Int

        init()

        deinit
    }
    actor ActorDeinitTest {
        // Field offset: 0x10
        // Type Layout: (size: 96, stride: 96, alignment: 16, extraInhabitantCount: 0)
        var $defaultActor: Builtin.DefaultActorStorage
        // Field offset: 0x70
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var state: Swift.Int

        init()

        var unownedExecutor: Swift.UnownedSerialExecutor {
            get
        }

        deinit
    }
    class GenericDeinitTest<A> {
        // Field offset: unknown (generic parameter not substituted)
        var element: A

        init(element: A)

        deinit
    }
}
enum DependentTypeAccess {
    struct DependentAccessTest<A> where A: SymbolTestsCore.DependentTypeAccess.OuterProtocol {
        // Field offset: unknown (generic parameter not substituted)
        var middleLeaf: A.Middle.Leaf?
        // Field offset: unknown (preceding field unresolved)
        var innerValue: A.Inner.Value?

        init(middleLeaf: A.Middle.Leaf?, innerValue: A.Inner.Value?)
    }
    struct DeepDependentAccessTest<A> where A: SymbolTestsCore.DependentTypeAccess.OuterProtocol {
        // Field offset: unknown (generic parameter not substituted)
        var branchFinal: A.Middle.Branch.Final?

        init(branchFinal: A.Middle.Branch.Final?)
    }
    struct DependentFunctionTest {
        func acceptDependent<A>(_: A, middleLeaf: A.Middle.Leaf, innerValue: A.Inner.Value) -> A.Middle.Branch.Final? where A: SymbolTestsCore.DependentTypeAccess.OuterProtocol
    }
    protocol OuterProtocol where Self.Inner: SymbolTestsCore.DependentTypeAccess.InnerProtocol, Self.Middle: SymbolTestsCore.DependentTypeAccess.MiddleProtocol {
        associatedtype Middle
        associatedtype Inner
    }
    protocol MiddleProtocol where Self.Branch: SymbolTestsCore.DependentTypeAccess.BranchProtocol {
        associatedtype Leaf
        associatedtype Branch
    }
    protocol BranchProtocol {
        associatedtype Final
    }
    protocol InnerProtocol {
        associatedtype Value
    }
    protocol DependentProtocol where Self.First == Self.Second.Leaf, Self.Second: SymbolTestsCore.DependentTypeAccess.MiddleProtocol {
        associatedtype First
        associatedtype Second
    }
}
enum DiamondInheritance {
    struct DiamondImplementationTest {
        init()

        func baseMethod() -> Swift.String
        func leftMethod() -> Swift.Int
        func rightMethod() -> Swift.Double
        func bottomMethod() -> Swift.Bool
    }
    protocol DiamondBaseProtocol {
        func baseMethod() -> Swift.String
    }
    protocol DiamondLeftProtocol: SymbolTestsCore.DiamondInheritance.DiamondBaseProtocol {
        func leftMethod() -> Swift.Int
    }
    protocol DiamondRightProtocol: SymbolTestsCore.DiamondInheritance.DiamondBaseProtocol {
        func rightMethod() -> Swift.Double
    }
    protocol DiamondBottomProtocol: SymbolTestsCore.DiamondInheritance.DiamondLeftProtocol, SymbolTestsCore.DiamondInheritance.DiamondRightProtocol {
        func bottomMethod() -> Swift.Bool
    }
    protocol TriDiamondRootProtocol {
        func root() -> Swift.String
    }
    protocol TriDiamondFirstProtocol: SymbolTestsCore.DiamondInheritance.TriDiamondRootProtocol {
        func first() -> Swift.Int
    }
    protocol TriDiamondSecondProtocol: SymbolTestsCore.DiamondInheritance.TriDiamondRootProtocol {
        func second() -> Swift.Int
    }
    protocol TriDiamondThirdProtocol: SymbolTestsCore.DiamondInheritance.TriDiamondRootProtocol {
        func third() -> Swift.Int
    }
    protocol TriDiamondLeafProtocol: SymbolTestsCore.DiamondInheritance.TriDiamondFirstProtocol, SymbolTestsCore.DiamondInheritance.TriDiamondSecondProtocol, SymbolTestsCore.DiamondInheritance.TriDiamondThirdProtocol {
        func leaf() -> Swift.Int
    }
}
enum DistributedActors {
    distributed actor DistributedActorTest {
        // Field offset: 0x10
        // Type Layout: (size: 96, stride: 96, alignment: 16, extraInhabitantCount: 0)
        var $defaultActor: Builtin.DefaultActorStorage
        // Field offset: 0x70
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        let id: Distributed.LocalTestingActorID
        // Field offset: 0x80
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        let actorSystem: Distributed.LocalTestingDistributedActorSystem

        init(actorSystem: Distributed.LocalTestingDistributedActorSystem)

        var nonisolatedProperty: Swift.String {
            get
        }
        var unownedExecutor: Swift.UnownedSerialExecutor {
            get
        }

        func remoteMethod(value: Swift.Int) -> Swift.Int
        func remoteThrowingMethod() throws -> Swift.String
        func parameterizedMethod(label: Swift.String, count: Swift.Int) -> Swift.String

        static func resolve(id: Distributed.LocalTestingActorID, using: Distributed.LocalTestingDistributedActorSystem) throws -> SymbolTestsCore.DistributedActors.DistributedActorTest

        deinit
    }
    distributed actor GenericDistributedActorTest<A> where A: Swift.Decodable, A: Swift.Encodable {
        // Field offset: 0x10
        // Type Layout: (size: 96, stride: 96, alignment: 16, extraInhabitantCount: 0)
        var $defaultActor: Builtin.DefaultActorStorage
        // Field offset: 0x70
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        let id: Distributed.LocalTestingActorID
        // Field offset: 0x80
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        let actorSystem: Distributed.LocalTestingDistributedActorSystem

        init(actorSystem: Distributed.LocalTestingDistributedActorSystem)

        var unownedExecutor: Swift.UnownedSerialExecutor {
            get
        }

        func process(element: A) -> A

        static func resolve(id: Distributed.LocalTestingActorID, using: Distributed.LocalTestingDistributedActorSystem) throws -> SymbolTestsCore.DistributedActors.GenericDistributedActorTest<A>

        deinit
    }
}
enum Enums {
    enum MultiPayloadEnumTests {
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        case closure(() -> ())
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case object(__C.NSObject)
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 0)
        case tuple(a: Swift.Int, b: Swift.Double)
        case empty
    }
    enum MultiPayloadEnumTests1 {
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        case string(Swift.String)
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 12)
        case data(Foundation.Data)
        // Type Layout: (size: 20, stride: 20, alignment: 4, extraInhabitantCount: 0)
        case nsNumber(__C.Decimal)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        case date(Foundation.Date)
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        case url(Foundation.URL)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case attributedString(Foundation.AttributedString)
    }
    enum MultiPayloadEnumTests2 {
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        case string(Swift.String)
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 12)
        case data(Foundation.Data)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case nsNumber(__C.NSNumber)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case nsNumber1(__C.NSNumber)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case nsNumber2(__C.NSNumber)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case nsNumber3(__C.NSNumber)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case nsNumber4(__C.NSNumber)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case nsNumber5(__C.NSNumber)
    }
    enum NoPayloadEnumTest {
        case north
        case south
        case east
        case west
    }
    enum SinglePayloadEnumTest {
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        case value(Swift.String)
        case none
        case error
    }
    class SinglePayloadBoxClass {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int

        init(value: Swift.Int)

        deinit
    }
    struct SinglePayloadBoxStruct {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var box: SymbolTestsCore.Enums.SinglePayloadBoxClass
    }
    enum SinglePayloadOverStructTest {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case wrapped(SymbolTestsCore.Enums.SinglePayloadBoxStruct)
        case first
        case second
    }
    enum IndirectEnumTest {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        indirect case leaf(Swift.Int)
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 126)
        indirect case node(SymbolTestsCore.Enums.IndirectEnumTest, SymbolTestsCore.Enums.IndirectEnumTest)
    }
    enum IndirectSinglePayloadEnumTest {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483645)
        indirect case node(SymbolTestsCore.Enums.IndirectSinglePayloadEnumTest)
        case leaf
        case sentinel
    }
    enum PartialIndirectEnumTest {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        case leaf(Swift.Int)
        // Type Layout: (size: 25, stride: 32, alignment: 8, extraInhabitantCount: 253)
        indirect case node(SymbolTestsCore.Enums.PartialIndirectEnumTest, SymbolTestsCore.Enums.PartialIndirectEnumTest)
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 253)
        indirect case chain(SymbolTestsCore.Enums.PartialIndirectEnumTest)
    }
    enum RawValueEnumTest {
        case first
        case second
        case third

        var description: Swift.String {
            get
        }

        func doubled() -> Swift.Int

        static func fromString(_: Swift.String) -> SymbolTestsCore.Enums.RawValueEnumTest?
    }
    enum StringRawValueEnumTest {
        case hello
        case world
    }
    enum CaseIterableEnumTest {
        case alpha
        case beta
        case gamma
    }
    enum ObjCEnumTest {}
    enum LargeFrozenEnumTest {
        case alpha
        case beta
        case gamma
        case delta
        case epsilon
        case zeta
        case eta
        case theta
        case iota
        case kappa
    }
    enum GenericPayloadEnumTest<A> {
        case first(A)
        case second(A, A)
        case empty
    }
    enum FunctionReferenceCaseTest {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        case first(Swift.Int)
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        case second(Swift.String)

        static func selectFirst() -> (_: Swift.Int) -> SymbolTestsCore.Enums.FunctionReferenceCaseTest
    }
    enum VoidPayloadEnumTest {
        // Type Layout: (size: 0, stride: 1, alignment: 1, extraInhabitantCount: 0)
        indirect case indirectUnitPayload()
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        case intPayload(Swift.Int)
        // Type Layout: (size: 0, stride: 1, alignment: 1, extraInhabitantCount: 0)
        case unitPayload()
        case plain
    }
}
enum ErrorTypes {
    enum SimpleErrorTest {
        case notFound
        case invalid
        case unknown
    }
    enum AssociatedValueErrorTest {
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        case withMessage(Swift.String)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        case withCode(Swift.Int)
        // Type Layout: (size: 32, stride: 32, alignment: 8, extraInhabitantCount: 2147483647)
        case withContext(message: Swift.String, code: Swift.Int, underlying: Swift.Error?)
    }
    struct LocalizedErrorTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483646)
        let errorDescription: Swift.String?
        // Field offset: 0x10
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483646)
        let failureReason: Swift.String?
        // Field offset: 0x20
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483646)
        let recoverySuggestion: Swift.String?
        // Field offset: 0x30
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483646)
        let helpAnchor: Swift.String?

        init(description: Swift.String, reason: Swift.String, suggestion: Swift.String, helpAnchor: Swift.String)
    }
    struct CustomNSErrorTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let errorCode: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        let errorUserInfo: [Swift.String : Any]

        init(errorCode: Swift.Int, errorUserInfo: [Swift.String : Any])

        static var errorDomain: Swift.String {
            get
        }
    }
    struct SendableErrorTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let identifier: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        let descriptionText: Swift.String

        init(identifier: Swift.Int, descriptionText: Swift.String)
    }
}
enum ExistentialAny {
    struct ExistentialFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 40, stride: 40, alignment: 8, extraInhabitantCount: 2147483647)
        var simpleExistential: SymbolTestsCore.Protocols.ProtocolTest
        // Field offset: 0x28
        // Type Layout: (size: 40, stride: 40, alignment: 8, extraInhabitantCount: 2147483647)
        var compositionExistential: SymbolTestsCore.Protocols.ProtocolTest
        // Field offset: 0x50
        // Type Layout: (size: 40, stride: 40, alignment: 8, extraInhabitantCount: 2147483646)
        var optionalExistential: SymbolTestsCore.Protocols.ProtocolTest?
        // Field offset: 0x78
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var existentialArray: [SymbolTestsCore.Protocols.ProtocolTest]
        // Field offset: 0x80
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var existentialDictionary: [Swift.String : SymbolTestsCore.Protocols.ProtocolTest]
        // Field offset: 0x88
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var existentialFunction: (_: SymbolTestsCore.Protocols.ProtocolTest) -> ()

        init(simpleExistential: SymbolTestsCore.Protocols.ProtocolTest, compositionExistential: Swift.Sendable & SymbolTestsCore.Protocols.ProtocolTest, optionalExistential: SymbolTestsCore.Protocols.ProtocolTest?, existentialArray: [SymbolTestsCore.Protocols.ProtocolTest], existentialDictionary: [Swift.String : SymbolTestsCore.Protocols.ProtocolTest], existentialFunction: @escaping (_: SymbolTestsCore.Protocols.ProtocolTest) -> ())
    }
    struct ExistentialClassBoundTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var classBound: SymbolTestsCore.Protocols.ClassBoundProtocolTest
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var anyObjectReference: Swift.AnyObject

        init(classBound: SymbolTestsCore.Protocols.ClassBoundProtocolTest, anyObjectReference: Swift.AnyObject)
    }
}
enum Extensions {
    struct ExtensionBaseStruct<A> {
        // Field offset: unknown (generic parameter not substituted)
        var element: A

        init(element: A)
    }
    struct ExtensionConstrainedStruct<A> {
        // Field offset: unknown (generic parameter not substituted)
        var element: A

        init(element: A)
    }
    protocol ExtensionProtocol {
        associatedtype Item

        var item: Self.Item {
            get
        }
    }
}
enum FieldDescriptorVariants {
    struct VarLetFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var mutableField: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        let immutableField: Swift.String
        // Field offset: 0x18
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var mutableOptional: Swift.Double?
        // Field offset: 0x28
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 0)
        let immutableOptional: Swift.Int?

        init(mutableField: Swift.Int, immutableField: Swift.String, mutableOptional: Swift.Double?, immutableOptional: Swift.Int?)
    }
    class ReferenceFieldTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        weak var weakVarField: Swift.AnyObject?
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        weak let weakLetField: Swift.AnyObject?
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        unowned var unownedVarField: Swift.AnyObject
        // Field offset: 0x28
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        unowned let unownedLetField: Swift.AnyObject
        // Field offset: 0x30
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        unowned(unsafe) var unownedUnsafeVarField: Swift.AnyObject
        // Field offset: 0x38
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        unowned(unsafe) let unownedUnsafeLetField: Swift.AnyObject
        // Field offset: 0x40
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var strongVarField: Swift.AnyObject
        // Field offset: 0x48
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        let strongLetField: Swift.AnyObject

        deinit
    }
    struct MangledNameVariantsTest<A> {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var concreteInt: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var concreteString: Swift.String
        // Field offset: unknown (generic parameter not substituted)
        var genericElement: A
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var arrayOfElement: [A]
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var dictionaryOfElement: [Swift.String : A]
        // Field offset: unknown (preceding field unresolved)
        var optionalElement: A?
        // Field offset: unknown (preceding field unresolved)
        var tupleField: (Swift.Int, A)
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var functionField: (_: A) -> Swift.Int

        init(concreteInt: Swift.Int, concreteString: Swift.String, genericElement: A, arrayOfElement: [A], dictionaryOfElement: [Swift.String : A], optionalElement: A?, tupleField: (Swift.Int, A), functionField: @escaping (_: A) -> Swift.Int)
    }
}
enum ForeignTypeFixtures {
    static func foreignClassReference() -> __C.CFStringRef
    static func foreignArrayReference() -> __C.CFArrayRef
}
enum FunctionFeatures {
    struct InoutFunctionTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int

        func increment()

        static func swap(_: inout Swift.Int, _: inout Swift.Int)
        static func modify(_: inout Swift.Int, by: Swift.Int)
    }
    class ClosureParameterTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var storedCallbacks: [() -> ()]

        func acceptEscaping(_: @escaping () -> ())
        func acceptAutoclosure(_: @autoclosure () -> Swift.Bool) -> Swift.Bool
        func acceptEscapingAutoclosure(_: @escaping @autoclosure () -> Swift.Bool)

        deinit
    }
    struct OwnershipParameterTest {
        class Box {
            // Field offset: 0x10
            // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
            var value: Swift.Int

            init(_: Swift.Int)

            deinit
        }
        func consumeBox(_: consuming SymbolTestsCore.FunctionFeatures.OwnershipParameterTest.Box)
        func twoConsuming(_: consuming SymbolTestsCore.FunctionFeatures.OwnershipParameterTest.Box, _: consuming SymbolTestsCore.FunctionFeatures.OwnershipParameterTest.Box)
        func consumeWithLabel(_: consuming SymbolTestsCore.FunctionFeatures.OwnershipParameterTest.Box, label: Swift.Int)

        static func staticConsume(_: consuming SymbolTestsCore.FunctionFeatures.OwnershipParameterTest.Box)
    }
    struct VariadicFunctionTest {
        func format(_: Swift.String, _: Swift.CVarArg...) -> Swift.String
        func sum(_: Swift.Int...) -> Swift.Int
    }
    struct ConventionFunctionTest {
        func acceptCFunction(_: @convention(c) (Swift.Int32, Swift.Int32) -> Swift.Int32) -> Swift.Int32
        func acceptBlockFunction(_: @convention(block) (_: Swift.Int32) -> Swift.Int32) -> Swift.Int32
    }
    struct ExistentialAndMetatypeTest {
        func returnExistential() -> Swift.Sendable & SymbolTestsCore.Protocols.ProtocolTest
        func acceptMetatype(_: Any.Type) -> Swift.String
        func acceptExistentialCollection(_: [SymbolTestsCore.Protocols.ProtocolTest]) -> Swift.Int
        func acceptProtocolMetatype(_: SymbolTestsCore.Protocols.ProtocolTest.Protocol) -> Swift.Bool
        func acceptExistential(_: SymbolTestsCore.Protocols.ProtocolTest)
        func acceptComposition(_: Swift.Sendable & SymbolTestsCore.Protocols.ProtocolTest)
    }
    struct FailableInitTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let value: Swift.Int

        init?(value: Swift.Int)
        init?(unsafeValue: Swift.Int)
    }
    struct MainActorClosureTest {
        func acceptMainActorAsync(_: @Swift.MainActor @Sendable () async -> ())
        func acceptMainActorClosure(_: @Swift.MainActor @Sendable () -> ())
    }
    struct DefaultParameterFunctionTest {
        func defaultMethod(value: Swift.Int, label: Swift.String, flag: Swift.Bool) -> Swift.String

        static func staticDefault(first: Swift.Int, second: Swift.Int) -> Swift.Int
    }
}
enum FunctionTypes {
    struct FunctionFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var simpleFunction: (_: Swift.Int) -> Swift.Int
        // Field offset: 0x10
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var multiArgumentFunction: (Swift.Int, Swift.String, Swift.Bool) -> Swift.Double
        // Field offset: 0x20
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var throwingFunction: () throws -> Swift.Int
        // Field offset: 0x30
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var asyncFunction: nonisolated(nonsending) () async -> Swift.String
        // Field offset: 0x40
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var asyncThrowingFunction: nonisolated(nonsending) () async throws -> Swift.Int

        init(simpleFunction: @escaping (_: Swift.Int) -> Swift.Int, multiArgumentFunction: @escaping (Swift.Int, Swift.String, Swift.Bool) -> Swift.Double, throwingFunction: @escaping () throws -> Swift.Int, asyncFunction: @escaping nonisolated(nonsending) () async -> Swift.String, asyncThrowingFunction: @escaping nonisolated(nonsending) () async throws -> Swift.Int)
    }
    struct OptionalFunctionFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483646)
        var callback: ((_: Swift.Int) -> Swift.Int)?
        // Field offset: 0x10
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailingMarker: Swift.Int8

        init(callback: ((_: Swift.Int) -> Swift.Int)?, trailingMarker: Swift.Int8)
    }
    struct HigherOrderFunctionTest {
        func acceptFunctionReturningFunction(_: @escaping (_: Swift.Int) -> (_: Swift.Double) -> Swift.String) -> Swift.String
        func returnFunctionReturningFunction() -> (_: Swift.Int) -> (_: Swift.Double) -> Swift.String
        func curriedFunction(_: Swift.Int) -> (_: Swift.Double) -> (_: Swift.String) -> Swift.Bool
    }
    struct FunctionTypealiasTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var transformer: (_: Swift.Int) -> Swift.String
        // Field offset: 0x10
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var predicate: (_: Swift.Int) -> Swift.Bool
        // Field offset: 0x20
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var biFunction: (Swift.Int, Swift.String) -> Swift.Bool

        init(transformer: @escaping (_: Swift.Int) -> Swift.String, predicate: @escaping (_: Swift.Int) -> Swift.Bool, biFunction: @escaping (Swift.Int, Swift.String) -> Swift.Bool)
    }
}
enum GenericFieldLayout {
    struct GenericStructNonRequirement<A> {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field1: Swift.Double
        // Field offset: unknown (generic parameter not substituted)
        var field2: A
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field3: Swift.Int
    }
    struct GenericStructLayoutRequirement<A> where A: AnyObject {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field1: Swift.Double
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var field2: A
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field3: Swift.Int
    }
    struct GenericStructSwiftProtocolRequirement<A> where A: Swift.Equatable {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field1: Swift.Double
        // Field offset: unknown (generic parameter not substituted)
        var field2: A
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field3: Swift.Int
    }
    struct GenericStructObjCProtocolRequirement<A> where A: __C.NSCopying {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field1: Swift.Double
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var field2: A
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field3: Swift.Int
    }
    class GenericClassNonRequirement<A> {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field1: Swift.Double
        // Field offset: unknown (generic parameter not substituted)
        var field2: A
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field3: Swift.Int

        init(field1: Swift.Double, field2: A, field3: Swift.Int)

        deinit
    }
    class GenericClassLayoutRequirement<A> where A: AnyObject {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field1: Swift.Double
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var field2: A
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field3: Swift.Int

        init(field1: Swift.Double, field2: A, field3: Swift.Int)

        deinit
    }
    class GenericClassNonRequirementInheritNSObject<A>: __C.NSObject {
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field1: Swift.Double
        // Field offset: unknown (generic parameter not substituted)
        var field2: A
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field3: Swift.Int

        @objc init(field1: Swift.Double, field2: A, field3: Swift.Int)
        @objc init()

        deinit
    }
    class GenericClassLayoutRequirementInheritNSObject<A>: __C.NSObject where A: AnyObject {
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field1: Swift.Double
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var field2: A
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field3: Swift.Int

        @objc init(field1: Swift.Double, field2: A, field3: Swift.Int)
        @objc init()

        deinit
    }
    struct Box<A> {
        // Field offset: unknown (generic parameter not substituted)
        var value: A
    }
    struct Pair<A, B> {
        // Field offset: unknown (generic parameter not substituted)
        var first: A
        // Field offset: unknown (preceding field unresolved)
        var second: B
    }
    enum SecondParameterPayloadEnum<A, B> {
        case payload(B)
        case empty
    }
    enum TwoPayloadGenericEnum<A, B> {
        case first(A)
        case second(B)
    }
    class GenericBaseClass<A> {
        // Field offset: unknown (generic parameter not substituted)
        var baseValue: A

        init(baseValue: A)

        deinit
    }
    struct ConcreteGenericStructFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 24, stride: 24, alignment: 8, extraInhabitantCount: 0)
        var intInstance: SymbolTestsCore.GenericFieldLayout.GenericStructNonRequirement<Swift.Int>
        // Field offset: 0x20
        // Type Layout: (size: 32, stride: 32, alignment: 8, extraInhabitantCount: 2147483647)
        var stringInstance: SymbolTestsCore.GenericFieldLayout.GenericStructNonRequirement<Swift.String>
        // Field offset: 0x40
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct NestedGenericFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var nested: SymbolTestsCore.GenericFieldLayout.Pair<SymbolTestsCore.GenericFieldLayout.Box<Swift.Int>, Swift.Int>
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct OptionalGenericFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var optional: SymbolTestsCore.GenericFieldLayout.Box<Swift.Int>?
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct TupleGenericFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 24, stride: 24, alignment: 8, extraInhabitantCount: 2147483647)
        var tuple: (SymbolTestsCore.GenericFieldLayout.Box<Swift.Int>, SymbolTestsCore.GenericFieldLayout.Box<Swift.String>)
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct SinglePayloadGenericEnumFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var enumField: SymbolTestsCore.GenericFieldLayout.SecondParameterPayloadEnum<Swift.Bool, Swift.Int64>
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct MultiPayloadGenericEnumFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 254)
        var enumField: SymbolTestsCore.GenericFieldLayout.TwoPayloadGenericEnum<Swift.Int, Swift.Double>
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct ClassReferenceGenericFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var classReference: SymbolTestsCore.GenericFieldLayout.GenericClassNonRequirement<Swift.Int>
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct FrozenGenericFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var array: [Swift.Int]
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        var pointer: Swift.UnsafePointer<Swift.Double>
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    class ConcreteGenericSuperclassSubclass: SymbolTestsCore.GenericFieldLayout.GenericBaseClass<Swift.Int> {
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var ownValue: Swift.Int

        init(baseValue: Swift.Int, ownValue: Swift.Int)
        init(baseValue: Swift.Int)

        deinit
    }
    struct VariadicPack<each A> {
        // Field offset: unknown (generic parameter not substituted)
        var values: (repeat A)
    }
    struct MixedScalarAndPack<A, each B> {
        // Field offset: unknown (generic parameter not substituted)
        var first: A
        // Field offset: unknown (preceding field unresolved)
        var rest: (repeat B?)
    }
    struct VariadicForwarder<each A> {
        // Field offset: unknown (generic parameter not substituted)
        var forwarded: SymbolTestsCore.GenericFieldLayout.VariadicPack<>
        // Field offset: unknown (preceding field unresolved)
        var wrapped: (repeat SymbolTestsCore.GenericFieldLayout.Box<A>)
    }
    struct ValueGenericBuffer<let a: Int> {
        // Field offset: unknown (generic parameter not substituted)
        var storage: Swift.InlineArray<A, Swift.Int8>
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 4, stride: 4, alignment: 4, extraInhabitantCount: 0)
        var tail: Swift.Int32
    }
    struct PackExpansionFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var triple: SymbolTestsCore.GenericFieldLayout.VariadicPack<>
        // Field offset: 0x18
        // Type Layout: (size: 2, stride: 2, alignment: 2, extraInhabitantCount: 0)
        var single: SymbolTestsCore.GenericFieldLayout.VariadicPack<>
        // Field offset: 0x0
        // Type Layout: (size: 0, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var empty: SymbolTestsCore.GenericFieldLayout.VariadicPack<>
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct MixedPackFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 11, stride: 16, alignment: 8, extraInhabitantCount: 253)
        var mixed: SymbolTestsCore.GenericFieldLayout.MixedScalarAndPack<Swift.Int, >
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct PackForwardingFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 13, stride: 16, alignment: 4, extraInhabitantCount: 254)
        var forwarder: SymbolTestsCore.GenericFieldLayout.VariadicForwarder<>
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct FixedArrayPayloadEnumFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 3, stride: 3, alignment: 1, extraInhabitantCount: 253)
        var enumField: SymbolTestsCore.GenericFieldLayout.SecondParameterPayloadEnum<Swift.Bool, Swift.InlineArray<3, Swift.Bool>>
        // Field offset: 0xb
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailing: Swift.Int8
    }
    struct ValueGenericFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 12, stride: 12, alignment: 4, extraInhabitantCount: 0)
        var buffer: SymbolTestsCore.GenericFieldLayout.ValueGenericBuffer<5>
        // Field offset: 0x18
        // Type Layout: (size: 24, stride: 24, alignment: 8, extraInhabitantCount: 0)
        var inline: Swift.InlineArray<3, Swift.Int64>
        // Field offset: 0x30
        // Type Layout: (size: 3, stride: 3, alignment: 1, extraInhabitantCount: 253)
        var optionalInline: Swift.InlineArray<3, Swift.Bool>?
        // Field offset: 0x38
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int
    }
    struct TupleExtraInhabitantFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 3, stride: 4, alignment: 2, extraInhabitantCount: 253)
        var optionalTuple: (Swift.Int16, Swift.Bool)?
        // Field offset: 0xb
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailing: Swift.Int8
    }
    struct GenericOuter<A> {
        struct Inner {
            // Field offset: 0x0
            // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 254)
            var flag: Swift.Bool
            // Field offset: 0x4
            // Type Layout: (size: 4, stride: 4, alignment: 4, extraInhabitantCount: 0)
            var count: Swift.Int32
        }
        enum InnerEnum {
            // Type Layout: (size: 2, stride: 2, alignment: 2, extraInhabitantCount: 0)
            case some(Swift.Int16)
            case none
        }
        // Field offset: unknown (generic parameter not substituted)
        var value: A
    }
    struct NestedInSpecializedParentFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 4, extraInhabitantCount: 254)
        var innerStruct: SymbolTestsCore.GenericFieldLayout.GenericOuter<Swift.Int>.Inner
        // Field offset: 0x10
        // Type Layout: (size: 3, stride: 4, alignment: 2, extraInhabitantCount: 0)
        var innerEnum: SymbolTestsCore.GenericFieldLayout.GenericOuter<Swift.String>.InnerEnum
        // Field offset: 0x13
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailing: Swift.Int8
    }
    struct AssociatedTypeStorage<A> where A: Swift.Collection {
        // Field offset: unknown (generic parameter not substituted)
        var index: A.Index
        // Field offset: unknown (preceding field unresolved)
        var element: A.Element
    }
    struct AssociatedTypeFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 10, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var storage: SymbolTestsCore.GenericFieldLayout.AssociatedTypeStorage<[Swift.Int16]>
        // Field offset: 0x12
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailing: Swift.Int8
    }
    struct ConstrainedExistentialFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 40, stride: 40, alignment: 8, extraInhabitantCount: 2147483647)
        var boxed: Swift.Int
        // Field offset: 0x30
        // Type Layout: (size: 40, stride: 40, alignment: 8, extraInhabitantCount: 2147483646)
        var optionalBoxed: (Swift.String)?
        // Field offset: 0x58
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailing: Swift.Int8
    }
    struct ParentArgumentUser<A> {
        enum Content {
            // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
            case keyPath(Swift.KeyPath<Swift.Int, A>)
            case value(A)
        }
        struct Storage {
            // Field offset: unknown (generic parameter not substituted)
            var stored: A
            // Field offset: unknown (preceding field unresolved)
            // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 254)
            var flag: Swift.Bool
        }
        enum SingleContent {
            case some(A)
            case none
        }
        // Field offset: unknown (generic parameter not substituted)
        var content: SymbolTestsCore.GenericFieldLayout.ParentArgumentUser<A>.Content
    }
    struct NestedParentArgumentFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 254)
        var wholeParent: SymbolTestsCore.GenericFieldLayout.ParentArgumentUser<Swift.Bool>
        // Field offset: 0x18
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 254)
        var content: SymbolTestsCore.GenericFieldLayout.ParentArgumentUser<Swift.Bool>.Content
        // Field offset: 0x28
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 253)
        var optionalContent: SymbolTestsCore.GenericFieldLayout.ParentArgumentUser<Swift.Bool>.Content?
        // Field offset: 0x34
        // Type Layout: (size: 5, stride: 8, alignment: 4, extraInhabitantCount: 254)
        var storage: SymbolTestsCore.GenericFieldLayout.ParentArgumentUser<Swift.Int32>.Storage
        // Field offset: 0x3a
        // Type Layout: (size: 3, stride: 4, alignment: 2, extraInhabitantCount: 0)
        var singleContent: SymbolTestsCore.GenericFieldLayout.ParentArgumentUser<Swift.Int16>.SingleContent
        // Field offset: 0x40
        // Type Layout: (size: 17, stride: 24, alignment: 8, extraInhabitantCount: 254)
        var wideContent: SymbolTestsCore.GenericFieldLayout.ParentArgumentUser<Swift.String>.Content
        // Field offset: 0x51
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailing: Swift.Int8
    }
    struct MultiLevelOuter<A> {
        struct Inner<A1> {
            // Field offset: unknown (generic parameter not substituted)
            var outerStored: A
            // Field offset: unknown (preceding field unresolved)
            var innerStored: A1
        }
        // Field offset: unknown (generic parameter not substituted)
        var value: A
    }
    struct MultiLevelNestedFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var inner: SymbolTestsCore.GenericFieldLayout.MultiLevelOuter<Swift.Int8>.Inner<Swift.Int64>
        // Field offset: 0x18
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailing: Swift.Int8
    }
    struct ObjCProtocolExistentialFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var bareElement: SymbolTestsCore.ObjCOnlyElementProtocol
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var anchoredElement: __C.NSObject & SymbolTestsCore.ObjCOnlyElementProtocol
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483646)
        var optionalElement: SymbolTestsCore.ObjCOnlyElementProtocol?
        // Field offset: 0x20
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var composedElement: SymbolTestsCore.DescriptorBackedSwiftProtocol & SymbolTestsCore.ObjCOnlyElementProtocol
        // Field offset: 0x30
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailing: Swift.Int8
    }
    class LayoutAncestorClass {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var ancestorIdentifier: Swift.Int

        init()

        deinit
    }
    struct GenericStructClassBoundSwiftProtocolRequirement<A> where A: SymbolTestsCore.GenericFieldLayout.ClassBoundElementProtocol {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field1: Swift.Double
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var field2: A
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field3: Swift.Int
    }
    struct GenericStructBaseClassRequirement<A> where A: SymbolTestsCore.GenericFieldLayout.LayoutAncestorClass {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field1: Swift.Double
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var field2: A
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var field3: Swift.Int
    }
    struct PartiallyClassBoundGenericStruct<A, B> where A: AnyObject {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var firstReference: A
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var counter: Swift.Int64
        // Field offset: unknown (generic parameter not substituted)
        var storedValue: B
        // Field offset: unknown (preceding field unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var trailingReference: A
    }
    struct ClassBoundWrappedFieldStruct<A> where A: AnyObject {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483646)
        var optionalElement: A?
        // Field offset: 0x8
        // Type Layout: (size: 12, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var elementPair: (A, Swift.Int32)
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var elementArray: [A]
        // Field offset: 0x20
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var elementClosure: (_: A) -> A
        // Field offset: 0x30
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailingMarker: Swift.Int8
    }
    enum ClassBoundContent<A> where A: AnyObject {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case first(A)
        // Type Layout: (size: 12, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        case second(A, Swift.Int32)
        case none
    }
    struct GenericStructWithClassBoundEnumField<A> where A: AnyObject {
        // Field offset: 0x0
        // Type Layout: (size: 13, stride: 16, alignment: 8, extraInhabitantCount: 253)
        var content: SymbolTestsCore.GenericFieldLayout.ClassBoundContent<A>
        // Field offset: 0xd
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailingMarker: Swift.Int8
    }
    struct SpareBitsNativeStorage<A, B> {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var storage: SymbolTestsCore.GenericFieldLayout.GenericBaseClass<A>
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var bucketIndex: Swift.Int
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var elementCount: Swift.Int

        init(storage: SymbolTestsCore.GenericFieldLayout.GenericBaseClass<A>, bucketIndex: Swift.Int, elementCount: Swift.Int)
    }
    enum SpareBitsVariantEnum<A, B> {
        // Type Layout: (size: 24, stride: 24, alignment: 8, extraInhabitantCount: 2147483647)
        case native(SymbolTestsCore.GenericFieldLayout.SpareBitsNativeStorage<A, B>)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        case bridged(SymbolTestsCore.GenericFieldLayout.GenericBaseClass<B>)
        case exhausted
    }
    struct SpareBitsVariantEnumFieldHolder {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var leading: Swift.Int
        // Field offset: 0x8
        // Type Layout: (size: 24, stride: 24, alignment: 8, extraInhabitantCount: 125)
        var enumField: SymbolTestsCore.GenericFieldLayout.SpareBitsVariantEnum<Swift.Int64, Swift.Bool>
        // Field offset: 0x20
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailing: Swift.Int8
    }
    class ClassBoundGenericBaseClass<A> where A: AnyObject {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var baseElement: A

        init(baseElement: A)

        deinit
    }
    class ClassBoundGenericSubclass<A>: SymbolTestsCore.GenericFieldLayout.ClassBoundGenericBaseClass<A> where A: AnyObject {
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var subclassElement: A
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var subclassIdentifier: Swift.Int64

        init(baseElement: A, subclassElement: A, subclassIdentifier: Swift.Int64)
        init(baseElement: A)

        deinit
    }
    class ClassBoundGenericNSObjectSubclass<A>: __C.NSObject where A: AnyObject {
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var element: A
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var identifier: Swift.Int

        @objc init(element: A, identifier: Swift.Int)
        @objc init()

        deinit
    }
    struct ClassBoundOuter<A> where A: AnyObject {
        struct ClassBoundInner<A1> where A1: AnyObject {
            // Field offset: 0x0
            // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
            var outerStored: A
            // Field offset: 0x8
            // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
            var innerStored: A1
            // Field offset: 0x10
            // Type Layout: (size: 2, stride: 2, alignment: 2, extraInhabitantCount: 0)
            var marker: Swift.Int16
        }
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var anchor: A
    }
    struct ConcreteMetatypeFieldStruct {
        // Field offset: 0x0
        // Type Layout: (size: 0, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var valueKind: Swift.Int64.Type
        // Field offset: 0x0
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var leadingMarker: Swift.Int8
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var classKind: SymbolTestsCore.GenericFieldLayout.LayoutAncestorClass.Type
        // Field offset: 0x10
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var optionalValueKind: Swift.Int64.Type?
        // Field offset: 0x11
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailingMarker: Swift.Int8
    }
    struct GenericMetatypeFieldStruct<A> {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var parameterKind: A.Type
        // Field offset: 0x8
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var leadingMarker: Swift.Int8
        // Field offset: 0x0
        // Type Layout: (size: 0, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var concreteKind: Swift.Int64.Type
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483646)
        var optionalParameterKind: A.Type?
        // Field offset: 0x18
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailingMarker: Swift.Int8
    }
    struct SameTypePinnedOuter<A> {
        // Field offset: unknown (generic parameter not substituted)
        var anchor: A
    }
    protocol Boxed {
        associatedtype Wrapped

        var wrapped: Self.Wrapped {
            get
        }
    }
    protocol ClassBoundElementProtocol: AnyObject {
        func classBoundIdentity() -> Swift.Int
    }
}
enum GenericRequirementVariants {
    struct ProtocolRequirementTest<A> where A: SymbolTestsCore.Protocols.ProtocolTest {
        // Field offset: unknown (generic parameter not substituted)
        var element: A

        init(element: A)
    }
    struct SameTypeRequirementTest<A, B> where A == B {
        // Field offset: unknown (generic parameter not substituted)
        var first: A
        // Field offset: unknown (preceding field unresolved)
        var second: A

        init(first: A, second: A)
    }
    class GenericBaseClassForRequirementTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var baseField: Swift.Int

        init()

        deinit
    }
    struct BaseClassRequirementTest<A> where A: SymbolTestsCore.GenericRequirementVariants.GenericBaseClassForRequirementTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var element: A

        init(element: A)
    }
    struct LayoutAnyObjectRequirementTest<A> where A: AnyObject {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var element: A

        init(element: A)
    }
    struct ParameterPackRequirementTest<each A> {
        // Field offset: unknown (generic parameter not substituted)
        var elements: (repeat A)

        init(elements: (repeat A))
    }
    struct ConstrainedParameterPackTest<each A> where repeat each A: SymbolTestsCore.Protocols.ProtocolTest {
        // Field offset: unknown (generic parameter not substituted)
        var elements: (repeat A)

        init(elements: (repeat A))
    }
    struct InvertibleProtocolRequirementTest<A>: ~Swift.Copyable where A: ~Swift.Copyable {
        // Field offset: unknown (generic parameter not substituted)
        var element: A
    }
}
enum Generics {
    struct GenericRequirementTest<A> where A: SymbolTestsCore.Protocols.ProtocolTest {
        // Field offset: unknown (generic parameter not substituted)
        var content: A

        init(content: A)

        var body: A {
            get
        }

        static func test(lhs: A, rhs: SymbolTestsCore.Generics.GenericRequirementTest<A>) -> Swift.Bool
    }
    struct GenericPackTest<A, each B, C> where repeat each B: SymbolTestsCore.Protocols.ProtocolTest {
        // Field offset: unknown (generic parameter not substituted)
        var _content: (repeat B)

        var body: Swift.Never {
            get
        }
    }
    struct GenericValueTest<A, let b: Int, C> {
        // Field offset: unknown (generic parameter not substituted)
        var content: C

        var body: Swift.Never {
            get
        }

        func function(value: C) -> Swift.Bool
    }
    struct GenericNestedFunction<A, B> {
        // Field offset: unknown (generic parameter not substituted)
        let a: A
        // Field offset: unknown (preceding field unresolved)
        let b: B

        func function<A1, B1>(a: A1, b: B1)
    }
}
enum GenericValueFixtures {
    struct FixedSizeArray<let a: Int, B> {
        init()
    }
}
enum Initializers {
    struct CustomInitializerError {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        let reason: Swift.String

        init(reason: Swift.String)
    }
    class ConvenienceInitializerTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let primaryValue: Swift.Int
        // Field offset: 0x18
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        let secondaryValue: Swift.String

        init(primaryValue: Swift.Int)
        init()
        init(primaryValue: Swift.Int, secondaryValue: Swift.String)

        deinit
    }
    class RequiredInitializerTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let value: Swift.Int

        init()
        init(value: Swift.Int)

        deinit
    }
    class RequiredInitializerSubclass: SymbolTestsCore.Initializers.RequiredInitializerTest {
        // Field offset: 0x18
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        let extraValue: Swift.String

        override init(value: Swift.Int)
        override init()

        deinit
    }
    struct FailableInitializerTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let value: Swift.Int

        init?(value: Swift.Int)
        init?(unsafe: Swift.Int)
    }
    struct TypedThrowingInitializerTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let value: Swift.Int

        init(value: Swift.Int) throws(SymbolTestsCore.Initializers.CustomInitializerError)
    }
    actor AsyncInitializerActorTest {
        // Field offset: 0x10
        // Type Layout: (size: 96, stride: 96, alignment: 16, extraInhabitantCount: 0)
        var $defaultActor: Builtin.DefaultActorStorage
        // Field offset: 0x70
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let identifier: Swift.Int

        init(identifier: Swift.Int) async

        var unownedExecutor: Swift.UnownedSerialExecutor {
            get
        }

        deinit
    }
}
enum KeyPaths {
    struct KeyPathHolderTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var readOnlyKeyPath: Swift.KeyPath<SymbolTestsCore.KeyPaths.KeyPathHolderTest, Swift.Int>
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var writableKeyPath: Swift.WritableKeyPath<SymbolTestsCore.KeyPaths.KeyPathHolderTest, Swift.Int>
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var referenceWritableKeyPath: Swift.ReferenceWritableKeyPath<SymbolTestsCore.KeyPaths.KeyPathReferenceTest, Swift.String>
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var partialKeyPath: Swift.PartialKeyPath<SymbolTestsCore.KeyPaths.KeyPathHolderTest>
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var anyKeyPath: Swift.AnyKeyPath
        // Field offset: 0x28
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int
        // Field offset: 0x30
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var text: Swift.String

        init(readOnlyKeyPath: Swift.KeyPath<SymbolTestsCore.KeyPaths.KeyPathHolderTest, Swift.Int>, writableKeyPath: Swift.WritableKeyPath<SymbolTestsCore.KeyPaths.KeyPathHolderTest, Swift.Int>, referenceWritableKeyPath: Swift.ReferenceWritableKeyPath<SymbolTestsCore.KeyPaths.KeyPathReferenceTest, Swift.String>, partialKeyPath: Swift.PartialKeyPath<SymbolTestsCore.KeyPaths.KeyPathHolderTest>, anyKeyPath: Swift.AnyKeyPath, value: Swift.Int, text: Swift.String)
    }
    class KeyPathReferenceTest {
        // Field offset: 0x10
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var mutableText: Swift.String
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var mutableInteger: Swift.Int

        init()

        deinit
    }
    struct KeyPathFactoryTest<A, B> {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var keyPathProducer: (_: A) -> Swift.KeyPath<A, B>

        init(keyPathProducer: @escaping (_: A) -> Swift.KeyPath<A, B>)
    }
}
enum MarkerProtocols {
    struct MarkerConformingStructTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int

        init(value: Swift.Int)
    }
    class MarkerConformingClassTest {
        // Field offset: 0x10
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var label: Swift.String

        init(label: Swift.String)

        deinit
    }
    enum MarkerConformingEnumTest {
        case first
        case second
    }
    protocol MarkerProtocolTest {}
    protocol EmptyMarkerProtocolTest {}
    protocol ClassBoundMarkerProtocol: AnyObject {}
    protocol InheritingMarkerProtocol: SymbolTestsCore.MarkerProtocols.MarkerProtocolTest {}
}
enum MetatypeUsage {
    struct MetatypeFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 0, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var concreteMetatype: Swift.Int.Type
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var anyMetatype: Any.Type
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var protocolMetatype: SymbolTestsCore.Protocols.ProtocolTest.Type
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var anyObjectMetatype: Swift.AnyObject.Type

        init(concreteMetatype: Swift.Int.Type, anyMetatype: Any.Type, protocolMetatype: SymbolTestsCore.Protocols.ProtocolTest.Type, anyObjectMetatype: Swift.AnyObject.Type)
    }
    struct MetatypeFunctionTest {
        func acceptProtocolMetatype(_: SymbolTestsCore.Protocols.ProtocolTest.Type) -> Swift.String
        func dynamicType<A>(of: A) -> A.Type
        func acceptMetatype<A>(_: A.Type) -> A.Type
        func returnMetatype() -> SymbolTestsCore.MetatypeUsage.MetatypeFunctionTest.Type
    }
}
enum NestedFunctions {
    struct NestedFunctionHolderTest {
        class LocalClass {
            // Field offset: 0x10
            // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
            var label: Swift.String
        }
        func outerWithLocalClass() -> Swift.String
    }
}
enum NestedGenerics {
    struct OuterGenericTest<A> {
        struct InnerGenericTest<A1> {
            struct InnerMostGenericTest<A2> {
                // Field offset: unknown (generic parameter not substituted)
                var outer: A
                // Field offset: unknown (preceding field unresolved)
                var inner: A1
                // Field offset: unknown (preceding field unresolved)
                var innerMost: A2

                init(outer: A, inner: A1, innerMost: A2)
            }
        }
    }
    struct NestedGenericWithConstraintsTest<A> where A: Swift.Comparable {
        struct InnerConstrainedTest<A1> where A1: Swift.Hashable {
            // Field offset: unknown (generic parameter not substituted)
            var outer: A
            // Field offset: unknown (preceding field unresolved)
            var inner: A1

            init(outer: A, inner: A1)
        }
    }
    struct NestedTypealiasGenericTest<A> {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var elements: [A]

        init(elements: [A])
    }
    struct NestedGenericThreeLevelConstraintTest<A> where A: Swift.Hashable {
        struct MiddleConstrainedTest<A1> where A1: Swift.Equatable {
            struct InnerMostConstrainedTest<A2> where A2: Swift.Comparable {
                // Field offset: unknown (generic parameter not substituted)
                var outer: A
                // Field offset: unknown (preceding field unresolved)
                var middle: A1
                // Field offset: unknown (preceding field unresolved)
                var innerMost: A2

                init(outer: A, middle: A1, innerMost: A2)
            }
        }
    }
}
enum Noncopyable {
    struct NoncopyableTest: ~Swift.Copyable {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int

        init(value: Swift.Int)

        func borrow() -> Swift.Int
        func mutate()
        func consume() -> Swift.Int

        deinit
    }
    enum NoncopyableEnumTest: ~Swift.Copyable {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        case value(Swift.Int)
        case empty

        func unwrap() -> Swift.Int
    }
    struct NoncopyableGenericTest<A>: ~Swift.Copyable where A: ~Swift.Copyable {
        // Field offset: unknown (generic parameter not substituted)
        let value: A
    }
}
enum ObjCClassWrapperFixtures {
    class ObjCBridge: __C.NSObject {
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var label: Swift.String

        @objc init()

        deinit
    }
    class ObjCBridgeWithProto: __C.NSObject {
        @objc init()

        @objc func ping()

        deinit
    }
}
enum ObjCResilientStubFixtures {
    class ResilientObjCStubChild: SymbolTestsHelper.Object {
        // Field offset: unknown (resilient field type unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var stubField: Swift.Int

        override init()

        deinit
    }
}
enum OpaqueReturnTypes {
    struct OpaqueReturnTypeTest {
        struct AnyProtocolTest<A, B> where A: SymbolTestsCore.Protocols.ProtocolTest, B == B.Body, A.Body == SymbolTestsCore.Generics.GenericRequirementTest<B> {
            init()

            var body: A {
                get
            }
        }
        var variable: some {
            get
        }

        func function<A>() -> some where A: SymbolTestsCore.Protocols.ProtocolTest
        func functionTuple<A>() -> (some, A?) where A: SymbolTestsCore.Protocols.ProtocolTest
        func functionWhere<A, B>() -> (some, (some)?, some)? where A: SymbolTestsCore.Protocols.ProtocolTest, B == B.Body, A.Body == SymbolTestsCore.Generics.GenericRequirementTest<B>
        func functionNested<A, B>(_: A, _: B) -> (some, (some)?, some)? where A: Swift.Equatable, A: SymbolTestsCore.Protocols.ProtocolTest, B: Swift.Equatable, B == B.Body, A.Body == SymbolTestsCore.Generics.GenericRequirementTest<B>
        func functionOptional<A>() -> (some)? where A: SymbolTestsCore.Protocols.ProtocolTest
    }
    enum ProtocolPrimaryAssociatedTypeFirst {
        var body: SymbolTestsCore.OpaqueReturnTypes.ProtocolPrimaryAssociatedTypeFirst {
            get
        }
    }
    enum ProtocolPrimaryAssociatedTypeSecond {
        var body: SymbolTestsCore.OpaqueReturnTypes.ProtocolPrimaryAssociatedTypeFirst {
            get
        }
    }
    enum UnderlyingPrimaryAssociatedTypeTest<A, B> where A: SymbolTestsCore.Protocols.ProtocolTest, B: SymbolTestsCore.Protocols.ProtocolTest, A.Body.Body.Body.Body.Body.Body == B.Body.Body.Body.Body.Body.Body {
        case none
    }
    struct OpaquePrimaryAssociatedTypeReturnTypeTest {
        var body: some {
            get
        }
    }
    protocol ProtocolPrimaryAssociatedTypeTest where Self.First: SymbolTestsCore.Protocols.ProtocolTest, Self.Second: SymbolTestsCore.Protocols.ProtocolTest, Self.First.Body.Body.Body.Body.Body.Body == Self.Second.Body.Body.Body.Body.Body.Body {
        associatedtype First
        associatedtype Second
    }
}
enum Operators {
    struct OperatorTestType {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int

        init(value: Swift.Int)

        static func + (_: SymbolTestsCore.Operators.OperatorTestType, _: SymbolTestsCore.Operators.OperatorTestType) -> SymbolTestsCore.Operators.OperatorTestType
        static func - (_: SymbolTestsCore.Operators.OperatorTestType, _: SymbolTestsCore.Operators.OperatorTestType) -> SymbolTestsCore.Operators.OperatorTestType
        static func * (_: SymbolTestsCore.Operators.OperatorTestType, _: SymbolTestsCore.Operators.OperatorTestType) -> SymbolTestsCore.Operators.OperatorTestType
        static func - (_: SymbolTestsCore.Operators.OperatorTestType) -> SymbolTestsCore.Operators.OperatorTestType
        static func += (_: inout SymbolTestsCore.Operators.OperatorTestType, _: SymbolTestsCore.Operators.OperatorTestType)
        static func < (_: SymbolTestsCore.Operators.OperatorTestType, _: SymbolTestsCore.Operators.OperatorTestType) -> Swift.Bool
        static func <=> (_: SymbolTestsCore.Operators.OperatorTestType, _: SymbolTestsCore.Operators.OperatorTestType) -> Swift.Int
    }
}
enum OptionSetAndRawRepresentable {
    struct OptionSetTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        let rawValue: Swift.UInt

        static let all: SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest
        static var first: SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest {
            get
        }
        static var second: SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest {
            get
        }
        static var third: SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest {
            get
        }
    }
    struct StringRawRepresentableTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        let rawValue: Swift.String
    }
    struct IntRawRepresentableTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var rawValue: Swift.Int
    }
    struct GenericRawRepresentableTest<A> where A: Swift.Hashable {
        // Field offset: unknown (generic parameter not substituted)
        var rawValue: A
    }
}
enum OverloadedMembers {
    struct OverloadedMethodTest {
        func process(_: Swift.String) -> Swift.String
        func process<A>(_: A) -> A
        func process<A>(equatable: A) -> Swift.Bool where A: Swift.Equatable
        func process(_: Swift.Int, label: Swift.String) -> Swift.String
        func process(_: Swift.Double) -> Swift.Double
        func process(_: Swift.Int) -> Swift.Int
        func process(_: Swift.Int, _: Swift.Int) -> Swift.Int
    }
    struct OverloadedInitializerTest {
        init(_: Swift.String)
        init<A>(element: A)
        init(first: Swift.Int, second: Swift.Int)
        init(_: Swift.Double)
        init(_: Swift.Int)
    }
}
enum PropertyWrapperVariants {
    @propertyWrapper
    struct ProjectedValueWrapperTest<A> {
        // Field offset: unknown (generic parameter not substituted)
        var storage: A

        init(wrappedValue: A)

        var projectedValue: SymbolTestsCore.PropertyWrapperVariants.ProjectedValueWrapperTest<A> {
            get
        }
        var wrappedValue: A {
            get
            set
        }
    }
    @propertyWrapper
    struct DefaultInitializableWrapperTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var wrappedValue: Swift.Int

        init(wrappedValue: Swift.Int)
        init()
    }
    @propertyWrapper
    struct StaticSubscriptWrapperTest<A, B> where A: AnyObject {
        // Field offset: unknown (generic parameter not substituted)
        var storage: B

        init(wrappedValue: B)

        var wrappedValue: B {
            get
            set
        }

        static subscript(_enclosingInstance: A, wrapped: Swift.ReferenceWritableKeyPath<A, B>, storage: Swift.ReferenceWritableKeyPath<A, SymbolTestsCore.PropertyWrapperVariants.StaticSubscriptWrapperTest<A, B>>) -> B {
            get
            set
        }
    }
}
enum ProtocolComposition {
    struct ProtocolCompositionFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 48, stride: 48, alignment: 8, extraInhabitantCount: 2147483647)
        var twoComposition: SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol & SymbolTestsCore.ProtocolComposition.ComposeSecondProtocol
        // Field offset: 0x30
        // Type Layout: (size: 56, stride: 56, alignment: 8, extraInhabitantCount: 2147483647)
        var threeComposition: SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol & SymbolTestsCore.ProtocolComposition.ComposeSecondProtocol & SymbolTestsCore.ProtocolComposition.ComposeThirdProtocol
        // Field offset: 0x68
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var classBoundComposition: SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol & Swift.AnyObject
        // Field offset: 0x78
        // Type Layout: (size: 40, stride: 40, alignment: 8, extraInhabitantCount: 2147483647)
        var sendableComposition: SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol

        init(twoComposition: SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol & SymbolTestsCore.ProtocolComposition.ComposeSecondProtocol, threeComposition: SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol & SymbolTestsCore.ProtocolComposition.ComposeSecondProtocol & SymbolTestsCore.ProtocolComposition.ComposeThirdProtocol, classBoundComposition: SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol & Swift.AnyObject, sendableComposition: Swift.Sendable & SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol)
    }
    struct ProtocolCompositionFunctionTest {
        func returnComposition() -> SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol & SymbolTestsCore.ProtocolComposition.ComposeSecondProtocol
        func acceptComposition(_: SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol & SymbolTestsCore.ProtocolComposition.ComposeSecondProtocol)
        func genericCompositionParameter<A>(_: A) where A: SymbolTestsCore.ProtocolComposition.ComposeFirstProtocol, A: SymbolTestsCore.ProtocolComposition.ComposeSecondProtocol
    }
    protocol ComposeFirstProtocol {
        func first() -> Swift.Int
    }
    protocol ComposeSecondProtocol {
        func second() -> Swift.String
    }
    protocol ComposeThirdProtocol {
        func third() -> Swift.Double
    }
}
enum Protocols {
    protocol ProtocolTest where Self.Body: SymbolTestsCore.Protocols.ProtocolTest {
        associatedtype Body

        var body: Self.Body {
            get
        }

        static var body: Self.Body? {
            get
        }
    }
    protocol ProtocolWitnessTableTest {
        func a()
        func b()
        func c()
        func d()
        func e()
    }
    protocol TestCollection {
        associatedtype Element
    }
    protocol BaseProtocolTest {
        func baseMethod() -> Swift.String
    }
    protocol DerivedProtocolTest: SymbolTestsCore.Protocols.BaseProtocolTest {
        func derivedMethod() -> Swift.Int
    }
    protocol ClassBoundProtocolTest: AnyObject {
        var classProperty: Swift.Int {
            get
            set
        }

        func classMethod()
    }
    protocol ObjCInheritingProtocolTest: __C.NSObject {
        func swiftMethod() -> Swift.String
    }
    protocol MultiInheritanceProtocolTest: SymbolTestsCore.Protocols.BaseProtocolTest, SymbolTestsCore.Protocols.ProtocolTest {
        func multiMethod()
    }
    protocol ProtocolWithInitTest {
        init()
        init(value: Swift.Int)
    }
    protocol ProtocolWithSubscriptTest {
        subscript(_: Swift.Int) -> Swift.String {
            get
        }
    }
    protocol ProtocolWithReadWriteSubscriptTest {
        subscript(_: Swift.String) -> Swift.Int {
            get
            set
        }
    }
    protocol ProtocolWithStaticTest {
        static var staticProperty: Swift.Int {
            get
        }

        static func staticMethod() -> Self
    }
    protocol SelfConstraintProtocolTest: AnyObject {
        func method() -> Self
    }
    protocol MultiPrimaryAssociatedTypeTest {
        associatedtype First
        associatedtype Second
        associatedtype Third
    }
}
enum RecursiveIndirectFieldLayout {
    struct ReferenceSpec {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var name: Swift.String
        // Field offset: 0x10
        // Type Layout: (size: 17, stride: 24, alignment: 8, extraInhabitantCount: 252)
        var value: SymbolTestsCore.RecursiveIndirectFieldLayout.ValueSpec<Swift.String>?
        // Field offset: 0x28
        // Type Layout: (size: 17, stride: 24, alignment: 8, extraInhabitantCount: 253)
        var direct: SymbolTestsCore.RecursiveIndirectFieldLayout.ValueSpec<Swift.String>
        // Field offset: 0x40
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var weight: Swift.Int

        init(name: Swift.String, value: SymbolTestsCore.RecursiveIndirectFieldLayout.ValueSpec<Swift.String>?, direct: SymbolTestsCore.RecursiveIndirectFieldLayout.ValueSpec<Swift.String>, weight: Swift.Int)
    }
    enum ValueSpec<A> {
        case literal(A)
        // Type Layout: (size: 72, stride: 72, alignment: 8, extraInhabitantCount: 2147483647)
        indirect case reference(SymbolTestsCore.RecursiveIndirectFieldLayout.ReferenceSpec)
        indirect case pair(SymbolTestsCore.RecursiveIndirectFieldLayout.ValueSpec<A>, SymbolTestsCore.RecursiveIndirectFieldLayout.ValueSpec<A>)
    }
    enum BoxedNode {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        indirect case leaf(Swift.Int)
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 126)
        indirect case branch(SymbolTestsCore.RecursiveIndirectFieldLayout.BoxedNode, SymbolTestsCore.RecursiveIndirectFieldLayout.BoxedNode)
    }
    struct AcyclicNesting {
        struct Inner {
            struct Innermost {
                // Field offset: 0x0
                // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
                var value: Swift.Int
                // Field offset: 0x8
                // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 254)
                var flag: Swift.Bool
            }
            // Field offset: 0x0
            // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 254)
            var innermost: SymbolTestsCore.RecursiveIndirectFieldLayout.AcyclicNesting.Inner.Innermost
            // Field offset: 0x10
            // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
            var label: Swift.String
        }
        // Field offset: 0x0
        // Type Layout: (size: 32, stride: 32, alignment: 8, extraInhabitantCount: 2147483647)
        var inner: SymbolTestsCore.RecursiveIndirectFieldLayout.AcyclicNesting.Inner
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var count: Swift.Int
    }
    static func makeSample() -> SymbolTestsCore.RecursiveIndirectFieldLayout.ReferenceSpec
    static func makeBoxedNode() -> SymbolTestsCore.RecursiveIndirectFieldLayout.BoxedNode
    static func makeAcyclicNesting() -> SymbolTestsCore.RecursiveIndirectFieldLayout.AcyclicNesting
}
enum ResilientClassFixtures {
    class ResilientChild: SymbolTestsHelper.ResilientBase {
        // Field offset: unknown (resilient field type unresolved)
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var extraField: Swift.Int

        override init()

        deinit
    }
}
enum ResultBuilderDSL {
    @resultBuilder
    struct FullResultBuilderTest {
        static func buildExpression(_: Swift.Int) -> [Swift.Int]
        static func buildOptional(_: [Swift.Int]?) -> [Swift.Int]
        static func buildArray(_: [[Swift.Int]]) -> [Swift.Int]
        static func buildExpression(_: [Swift.Int]) -> [Swift.Int]
        static func buildBlock(_: [Swift.Int]...) -> [Swift.Int]
        static func buildFinalResult(_: [Swift.Int]) -> [Swift.Int]
        static func buildEither(first: [Swift.Int]) -> [Swift.Int]
        static func buildEither(second: [Swift.Int]) -> [Swift.Int]
        static func buildLimitedAvailability(_: [Swift.Int]) -> [Swift.Int]
    }
    @resultBuilder
    struct GenericResultBuilderTest<A> {
        static func buildBlock(_: [A]...) -> [A]
        static func buildExpression(_: A) -> [A]
        static func buildOptional(_: [A]?) -> [A]
    }
}
enum SameTypeRequirements {
    struct SameTypeElementTest<A, B> where A: Swift.Sequence, B: Swift.Sequence, A.Element == B.Element {
        // Field offset: unknown (generic parameter not substituted)
        var first: A
        // Field offset: unknown (preceding field unresolved)
        var second: B

        init(first: A, second: B)
    }
    struct NestedSameTypeTest<A, B> where A: Swift.Collection, B: Swift.Collection, A.Element == B.Element, A.Index == Swift.Int, B.Index == Swift.Int {
        // Field offset: unknown (generic parameter not substituted)
        var first: A
        // Field offset: unknown (preceding field unresolved)
        var second: B

        init(first: A, second: B)
    }
    struct ChainedSameTypeTest<A, B, C> where A: SymbolTestsCore.Protocols.ProtocolTest, B == A.Body, C == B.Body {
        // Field offset: unknown (generic parameter not substituted)
        var first: A
        // Field offset: unknown (preceding field unresolved)
        var second: B
        // Field offset: unknown (preceding field unresolved)
        var third: C

        init(first: A, second: B, third: C)
    }
}
enum StaticMembers {
    struct StaticMemberStructTest {
        static var computedProperty: Swift.Int {
            get
            set
        }
        static var storedConstant: Swift.Int {
            get
        }
        static var storedMutable: Swift.String

        static func staticMethod() -> Swift.Int
        static func staticGenericMethod<A>(_: A) -> A

        static subscript(_: Swift.Int) -> Swift.String {
            get
        }
    }
    class StaticMemberClassTest {
        init()

        class var classComputed: Swift.Int {
            get
        }
        static var storedConstant: Swift.Int {
            get
        }
        static var storedMutable: Swift.String

        class func classMethod() -> Swift.Int
        static func staticMethod() -> Swift.Int

        deinit
    }
    class StaticMemberSubclassTest: SymbolTestsCore.StaticMembers.StaticMemberClassTest {
        override init()

        override class var classComputed: Swift.Int {
            get
        }

        override class func classMethod() -> Swift.Int

        deinit
    }
}
enum StringInterpolations {
    struct CustomStringInterpolationTest {
        struct StringInterpolation {
            // Field offset: 0x0
            // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
            var accumulator: Swift.String

            init(literalCapacity: Swift.Int, interpolationCount: Swift.Int)

            func appendInterpolation(_: Swift.Int)
            func appendInterpolation(_: Swift.String)
            func appendInterpolation<A>(_: A) where A: Swift.CustomStringConvertible
            func appendInterpolation(formatted: Swift.Double, precision: Swift.Int)
            func appendLiteral(_: Swift.String)
        }
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        var storage: Swift.String

        init(stringInterpolation: SymbolTestsCore.StringInterpolations.CustomStringInterpolationTest.StringInterpolation)
        init(stringLiteral: Swift.String)
    }
}
enum Structs {
    struct StructTest {
        var body: some {
            get
        }

        func a()
        func b()
        func c()
        func d()
        func e()

        static var body: some {
            get
        }
    }
    enum PrivateProtocolTest {
        case empty
    }
}
enum Subscripts {
    struct SubscriptGetSetTest {
        subscript(_: Swift.Int) -> Swift.Int {
            get
            set
        }
    }
    struct SubscriptMultiParamTest {
        subscript(_: Swift.Int, _: Swift.Int) -> Swift.Int {
            get
        }
    }
    struct SubscriptStaticTest {
        static subscript(_: Swift.Int) -> Swift.String {
            get
        }
    }
    class ClassSubscriptTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var elements: [Swift.Int]

        subscript(_: Swift.Int) -> Swift.Int {
            get
            set
        }

        deinit
    }
    struct SubscriptGenericTest<A> {
        subscript<A1>(_: A1) -> A? where A1: Swift.Hashable {
            get
        }
    }
    struct SubscriptStringKeyTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var storage: [Swift.String : Swift.Int]

        subscript(_: Swift.String) -> Swift.Int? {
            get
            set
        }
    }
}
enum Tuples {
    struct TupleFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 24, stride: 24, alignment: 8, extraInhabitantCount: 2147483647)
        var namedTuple: (first: Swift.Int, second: Swift.String)
        // Field offset: 0x18
        // Type Layout: (size: 17, stride: 24, alignment: 8, extraInhabitantCount: 254)
        var unnamedTuple: (Swift.Int, Swift.Double, Swift.Bool)
        // Field offset: 0x30
        // Type Layout: (size: 48, stride: 48, alignment: 8, extraInhabitantCount: 2147483647)
        var nestedTuple: ((Swift.Int, Swift.Int), (Swift.String, Swift.String))

        init(namedTuple: (first: Swift.Int, second: Swift.String), unnamedTuple: (Swift.Int, Swift.Double, Swift.Bool), nestedTuple: ((Swift.Int, Swift.Int), (Swift.String, Swift.String)))
    }
    struct TupleFunctionTest {
        func acceptTuple(_: (Swift.Int, Swift.String)) -> (Swift.Bool, Swift.Double)
        func returnLargeTuple() -> (Swift.Int, Swift.Double, Swift.String, Swift.Bool, Swift.Int, Swift.Double)
        func acceptNamedTuple(_: (identifier: Swift.Int, label: Swift.String)) -> (result: Swift.Bool, score: Swift.Double)
    }
    struct GenericTupleTest<A, B> {
        // Field offset: unknown (generic parameter not substituted)
        var pair: (A, B)
        // Field offset: unknown (preceding field unresolved)
        var labeled: (left: A, right: B)

        init(pair: (A, B), labeled: (left: A, right: B))
    }
}
enum UnsafePointers {
    struct UnsafePointerFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        var readPointer: Swift.UnsafePointer<Swift.Int>
        // Field offset: 0x8
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        var mutablePointer: Swift.UnsafeMutablePointer<Swift.Int>
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        var rawPointer: Swift.UnsafeRawPointer
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        var mutableRawPointer: Swift.UnsafeMutableRawPointer
        // Field offset: 0x20
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var bufferPointer: Swift.UnsafeBufferPointer<Swift.Int>
        // Field offset: 0x30
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var mutableBufferPointer: Swift.UnsafeMutableBufferPointer<Swift.Int>
        // Field offset: 0x40
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var rawBufferPointer: Swift.UnsafeRawBufferPointer
        // Field offset: 0x50
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        var opaquePointer: Swift.OpaquePointer

        init(readPointer: Swift.UnsafePointer<Swift.Int>, mutablePointer: Swift.UnsafeMutablePointer<Swift.Int>, rawPointer: Swift.UnsafeRawPointer, mutableRawPointer: Swift.UnsafeMutableRawPointer, bufferPointer: Swift.UnsafeBufferPointer<Swift.Int>, mutableBufferPointer: Swift.UnsafeMutableBufferPointer<Swift.Int>, rawBufferPointer: Swift.UnsafeRawBufferPointer, opaquePointer: Swift.OpaquePointer)
    }
    struct UnmanagedFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var unmanagedReference: Swift.Unmanaged<Swift.AnyObject>

        init(unmanagedReference: Swift.Unmanaged<Swift.AnyObject>)
    }
    struct AutoreleasingPointerFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        var autoreleasing: Swift.AutoreleasingUnsafeMutablePointer<Swift.AnyObject?>

        init(autoreleasing: Swift.AutoreleasingUnsafeMutablePointer<Swift.AnyObject?>)
    }
    enum EnumOverUnsafeRawPointerTest {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        case pointer(Swift.UnsafeRawPointer)
        case first
        case second
    }
    struct EnumOverUnsafeRawPointerFieldTest {
        // Field offset: 0x0
        // Type Layout: (size: 9, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var pointerEnum: SymbolTestsCore.UnsafePointers.EnumOverUnsafeRawPointerTest
        // Field offset: 0x9
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailingMarker: Swift.Int8

        init(pointerEnum: SymbolTestsCore.UnsafePointers.EnumOverUnsafeRawPointerTest, trailingMarker: Swift.Int8)
    }
}
enum VTableEntryVariants {
    class VTableBaseTest {
        init()

        var asyncProperty: Swift.Int {
            get
        }
        var normalProperty: Swift.Int {
            get
            set
        }
        var throwingProperty: Swift.Int {
            get
        }

        func normalMethod()
        func overridableMethod() -> Swift.Int
        func throwingMethod() throws -> Swift.Int
        func asyncMethod() async -> Swift.Int
        func asyncThrowingMethod() async throws -> Swift.Int
        func finalMethod()

        deinit
    }
    class VTableOverrideTest: SymbolTestsCore.VTableEntryVariants.VTableBaseTest {
        override init()

        override func overridableMethod() -> Swift.Int
        override func throwingMethod() throws -> Swift.Int
        func asyncMethod() async -> Swift.Int

        deinit
    }
    class VTableFinalOverrideTest: SymbolTestsCore.VTableEntryVariants.VTableBaseTest {
        override init()

        override func overridableMethod() -> Swift.Int

        deinit
    }
    class VTableDeepOverrideTest: SymbolTestsCore.VTableEntryVariants.VTableOverrideTest {
        override init()

        override func overridableMethod() -> Swift.Int
        func asyncMethod() async -> Swift.Int

        deinit
    }
}
enum WeakUnownedReferences {
    class ReferenceTargetTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var value: Swift.Int

        init()

        deinit
    }
    class WeakReferenceHolderTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        weak var weakReference: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest?
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        weak var weakAnyObject: Swift.AnyObject?

        init()

        deinit
    }
    class UnownedReferenceHolderTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        unowned var unownedReference: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        unowned var unownedSafeReference: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        unowned(unsafe) var unownedUnsafeReference: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest

        init(target: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest)

        deinit
    }
    class MixedReferenceHolderTest {
        // Field offset: 0x10
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        weak var weakReference: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest?
        // Field offset: 0x18
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        unowned var unownedReference: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 2147483647)
        var strongReference: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest

        init(target: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest)

        deinit
    }
    struct WeakReferenceStructTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        weak var object: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest?

        init(object: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest?)
    }
    struct UnownedReferenceStructTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        unowned var object: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest

        init(object: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest)
    }
    enum EnumOverWeakReferenceStructTest {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        case payload(SymbolTestsCore.WeakUnownedReferences.WeakReferenceStructTest)
        case first
        case second
    }
    enum EnumOverUnownedReferenceStructTest {
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        case payload(SymbolTestsCore.WeakUnownedReferences.UnownedReferenceStructTest)
        case first
        case second
    }
    struct WeakExistentialStructTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        weak var delegate: SymbolTestsCore.WeakUnownedReferences.ReferenceDelegateTest?

        init(delegate: SymbolTestsCore.WeakUnownedReferences.ReferenceDelegateTest?)
    }
    struct WeakCompositionExistentialStructTest {
        // Field offset: 0x0
        // Type Layout: (size: 24, stride: 24, alignment: 8, extraInhabitantCount: 2147483647)
        weak var delegate: (SymbolTestsCore.WeakUnownedReferences.ReferenceDelegateTest & SymbolTestsCore.WeakUnownedReferences.SecondaryDelegateTest)?

        init(delegate: (SymbolTestsCore.WeakUnownedReferences.ReferenceDelegateTest & SymbolTestsCore.WeakUnownedReferences.SecondaryDelegateTest)?)
    }
    struct WeakAnyObjectStructTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        weak var object: Swift.AnyObject?

        init(object: Swift.AnyObject?)
    }
    struct WeakObjCExistentialStructTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        weak var delegate: SymbolTestsCore.WeakUnownedObjCDelegateTest?

        init(delegate: SymbolTestsCore.WeakUnownedObjCDelegateTest?)
    }
    struct UnownedObjCExistentialStructTest {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 1)
        unowned var delegate: SymbolTestsCore.WeakUnownedObjCDelegateTest

        init(delegate: SymbolTestsCore.WeakUnownedObjCDelegateTest)
    }
    struct UnownedExistentialStructTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        unowned var delegate: SymbolTestsCore.WeakUnownedReferences.ReferenceDelegateTest

        init(delegate: SymbolTestsCore.WeakUnownedReferences.ReferenceDelegateTest)
    }
    struct UnmanagedExistentialStructTest {
        // Field offset: 0x0
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        unowned(unsafe) var delegate: SymbolTestsCore.WeakUnownedReferences.ReferenceDelegateTest

        init(delegate: SymbolTestsCore.WeakUnownedReferences.ReferenceDelegateTest)
    }
    class WeakExistentialHolderTest {
        // Field offset: 0x10
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 2147483647)
        weak var delegate: SymbolTestsCore.WeakUnownedReferences.ReferenceDelegateTest?
        // Field offset: 0x20
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        weak var parent: SymbolTestsCore.WeakUnownedReferences.ReferenceTargetTest?
        // Field offset: 0x28
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var marker: Swift.Int

        init()

        deinit
    }
    class WeakExistentialSubclassTest: SymbolTestsCore.WeakUnownedReferences.WeakExistentialHolderTest {
        // Field offset: 0x30
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var trailing: Swift.Int

        override init()

        deinit
    }
    protocol ReferenceDelegateTest: AnyObject {
        func notify()
    }
    protocol SecondaryDelegateTest: AnyObject {
        var isReady: Swift.Bool {
            get
        }
    }
}

protocol DescriptorBackedSwiftProtocol {
    func describe() -> Swift.Int
}

extension SymbolTestsCore.GenericFieldLayout.SameTypePinnedOuter where A == Swift.Int64 {
    struct ScalarPinnedInner {
        // Field offset: 0x0
        // Type Layout: (size: 8, stride: 8, alignment: 8, extraInhabitantCount: 0)
        var pinnedValue: Swift.Int64
        // Field offset: 0x8
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailingMarker: Swift.Int8
    }
}
extension SymbolTestsCore.GenericFieldLayout.SameTypePinnedOuter where A == Swift.Range<Swift.Int> {
    struct RangePinnedInner {
        // Field offset: 0x0
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var leadingMarker: Swift.Int8
        // Field offset: 0x8
        // Type Layout: (size: 16, stride: 16, alignment: 8, extraInhabitantCount: 0)
        var pinnedRange: Swift.Range<Swift.Int>
        // Field offset: 0x18
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailingMarker: Swift.Int8
    }
}
extension SymbolTestsCore.GenericFieldLayout.ValueGenericBuffer where A == 5 {
    struct ValuePinnedInner {
        // Field offset: 0x0
        // Type Layout: (size: 10, stride: 10, alignment: 2, extraInhabitantCount: 0)
        var pinnedStorage: Swift.InlineArray<5, Swift.Int16>
        // Field offset: 0xa
        // Type Layout: (size: 1, stride: 1, alignment: 1, extraInhabitantCount: 0)
        var trailingMarker: Swift.Int8
    }
}
extension SymbolTestsCore.Generics.GenericRequirementTest where A: Swift.RawRepresentable, A: SymbolTestsCore.Protocols.ProtocolTest {
    struct RawRepresentableNestedStruct {
        struct NestedStruct {}
    }
}
extension SymbolTestsCore.AccessorFunctionReferences.NoncopyableGenericBoxTest where A: ~Swift.Copyable {}
extension SymbolTestsCore.AccessorFunctionReferences.NoncopyableGenericBoxTest {
    init(wrapped: A) where A: ~Swift.Copyable
}
extension SymbolTestsCore.Generics.GenericRequirementTest where A: Swift.RawRepresentable {
    var rawValue: A {
        get
    }
}
extension SymbolTestsCore.Generics.GenericRequirementTest {
    init?(rawValue: A) where A: Swift.RawRepresentable

    static func == (_: SymbolTestsCore.Generics.GenericRequirementTest<A>, _: SymbolTestsCore.Generics.GenericRequirementTest<A>) -> Swift.Bool where A: Swift.Equatable
}
extension SymbolTestsCore.Noncopyable.NoncopyableGenericTest {
    init(value: A) where A: ~Swift.Copyable
}
extension SymbolTestsCore.GenericRequirementVariants.InvertibleProtocolRequirementTest where A: ~Swift.Copyable {}
extension SymbolTestsCore.GenericRequirementVariants.InvertibleProtocolRequirementTest {
    init(element: A) where A: ~Swift.Copyable
}
extension SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest where A: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }
}
extension SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest {
    func hash(into: inout Swift.Hasher) where A: Swift.Hashable

    static func == (_: SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest<A>, _: SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest<A>) -> Swift.Bool where A: Swift.Equatable
    static func < (_: SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest<A>, _: SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest<A>) -> Swift.Bool where A: Swift.Comparable
}
extension Swift.Never {
    var body: Swift.Never {
        get
    }

    func next() -> Swift.Never?
    func makeIterator() -> Swift.Never
}
extension SymbolTestsCore.Extensions.ExtensionConstrainedStruct where A: Swift.Hashable {
    var item: A {
        get
    }
}
extension SymbolTestsCore.Extensions.ExtensionBaseStruct {
    func isEqualTo(_: SymbolTestsCore.Extensions.ExtensionBaseStruct<A>) -> Swift.Bool where A: Swift.Equatable
    func isLessThan(_: SymbolTestsCore.Extensions.ExtensionBaseStruct<A>) -> Swift.Bool where A: Swift.Comparable
    func computeHash() -> Swift.Int where A: Swift.Hashable, A: Swift.Sendable
}
extension SymbolTestsCore.Protocols.ProtocolTest {
    static var body: Self.Body? {
        get
    }

    static func test(lhs: Self.Body, rhs: Self) -> Swift.Bool
}
extension SymbolTestsCore.DefaultImplementationVariants.ConstrainedDefaultProtocol {
    func isEqualTo(_: Self.Element) -> Swift.Bool where Self.Element: Swift.Equatable
    func isLessThan(_: Self.Element) -> Swift.Bool where Self.Element: Swift.Comparable
    func computeHash() -> Swift.Int where Self.Element: Swift.Hashable, Self.Element: Swift.Sendable
    func identityCheck(_: Self.Element) -> Swift.Bool where Self.Element: AnyObject
}
extension SymbolTestsCore.Extensions.ExtensionProtocol {
    func matches(_: Self.Item) -> Swift.Bool where Self.Item: Swift.Equatable
    func isLessThan(_: Self.Item) -> Swift.Bool where Self.Item: Swift.Comparable
}
extension SymbolTestsCore.DefaultImplementationVariants.BasicDefaultProtocol {
    func withDefaultAndGeneric<A1>(_: A1) -> A1
    func withDefault() -> Swift.String
}
extension SymbolTestsCore.Actors.ActorTest: Swift.Actor {
    var unownedExecutor: Swift.UnownedSerialExecutor {
        get
    }
}
extension SymbolTestsCore.Actors.CustomGlobalActor: Swift.Actor {
    var unownedExecutor: Swift.UnownedSerialExecutor {
        get
    }
}
extension SymbolTestsCore.Actors.CustomGlobalActor: Swift.GlobalActor {
    static var shared: Self.ActorType {
        get
    }
    static var sharedUnownedExecutor: Swift.UnownedSerialExecutor {
        get
    }
}
extension SymbolTestsCore.Actors.GlobalActorIsolatedConformanceTest: @Swift.MainActor SymbolTestsCore.Actors.GlobalActorIsolatedProtocolTest {}
extension SymbolTestsCore.Actors.GlobalActorIsolatedConformanceTest: @SymbolTestsCore.Actors.CustomGlobalActor SymbolTestsCore.Actors.CustomGlobalActorIsolatedProtocolTest {}
extension SymbolTestsCore.AssociatedTypeWitnessPatterns.ConcreteWitnessTest: SymbolTestsCore.AssociatedTypeWitnessPatterns.AssociatedPatternProtocol {}
extension SymbolTestsCore.AssociatedTypeWitnessPatterns.NestedWitnessTest: SymbolTestsCore.AssociatedTypeWitnessPatterns.AssociatedPatternProtocol {}
extension SymbolTestsCore.AssociatedTypeWitnessPatterns.GenericParameterWitnessTest: SymbolTestsCore.AssociatedTypeWitnessPatterns.AssociatedPatternProtocol {}
extension SymbolTestsCore.AssociatedTypeWitnessPatterns.RecursiveWitnessTest: SymbolTestsCore.AssociatedTypeWitnessPatterns.AssociatedPatternProtocol {}
extension SymbolTestsCore.AssociatedTypeWitnessPatterns.DependentWitnessTest: SymbolTestsCore.AssociatedTypeWitnessPatterns.AssociatedPatternProtocol {}
extension SymbolTestsCore.AsyncSequenceTests.AsyncSequenceTest.AsyncIterator: Swift.AsyncIteratorProtocol {
    func next() async throws -> Self.Element?
    func next(isolation: isolated Swift.Actor?) async throws(Self.Failure) -> Self.Element?
}
extension SymbolTestsCore.AsyncSequenceTests.AsyncSequenceTest: Swift.AsyncSequence {
    func makeAsyncIterator() -> Self.AsyncIterator
}
extension SymbolTestsCore.AsyncSequenceTests.ThrowingAsyncSequenceTest.AsyncIterator: Swift.AsyncIteratorProtocol {
    func next() async throws -> Self.Element?
    func next(isolation: isolated Swift.Actor?) async throws(Self.Failure) -> Self.Element?
}
extension SymbolTestsCore.AsyncSequenceTests.ThrowingAsyncSequenceTest: Swift.AsyncSequence {
    func makeAsyncIterator() -> Self.AsyncIterator
}
extension SymbolTestsCore.AsyncSequenceTests.GenericAsyncSequenceTest.AsyncIterator: Swift.AsyncIteratorProtocol {
    func next() async throws -> Self.Element?
    func next(isolation: isolated Swift.Actor?) async throws(Self.Failure) -> Self.Element?
}
extension SymbolTestsCore.AsyncSequenceTests.GenericAsyncSequenceTest: Swift.AsyncSequence {
    func makeAsyncIterator() -> Self.AsyncIterator
}
extension SymbolTestsCore.CodableTests.SynthesizedCodableTest: Swift.Decodable {
    init(from: Swift.Decoder) throws
}
extension SymbolTestsCore.CodableTests.SynthesizedCodableTest: Swift.Encodable {
    func encode(to: Swift.Encoder) throws
}
extension SymbolTestsCore.CodableTests.CustomCodableTest: Swift.Decodable {
    init(from: Swift.Decoder) throws
}
extension SymbolTestsCore.CodableTests.CustomCodableTest: Swift.Encodable {
    func encode(to: Swift.Encoder) throws
}
extension SymbolTestsCore.CodableTests.CodableClassTest: Swift.Decodable {
    init(from: Swift.Decoder) throws
}
extension SymbolTestsCore.CodableTests.CodableClassTest: Swift.Encodable {
    func encode(to: Swift.Encoder) throws
}
extension SymbolTestsCore.CodableTests.CodableEnumTest: Swift.Decodable {
    init(from: Swift.Decoder) throws
}
extension SymbolTestsCore.CodableTests.CodableEnumTest: Swift.Encodable {
    func encode(to: Swift.Encoder) throws
}
extension SymbolTestsCore.CodableTests.GenericCodableTest: Swift.Decodable {
    init(from: Swift.Decoder) throws
}
extension SymbolTestsCore.CodableTests.GenericCodableTest: Swift.Encodable {
    func encode(to: Swift.Encoder) throws
}
extension SymbolTestsCore.CodableTests.SynthesizedCodableTest.CodingKeys: Swift.CustomStringConvertible {
    var description: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.SynthesizedCodableTest.CodingKeys: Swift.CustomDebugStringConvertible {
    var debugDescription: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.SynthesizedCodableTest.CodingKeys: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.CodableTests.SynthesizedCodableTest.CodingKeys: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.CodableTests.SynthesizedCodableTest.CodingKeys: Swift.CodingKey {
    init?(stringValue: Swift.String)
    init?(intValue: Swift.Int)

    var intValue: Swift.Int? {
        get
    }
    var stringValue: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CustomCodableTest.CodingKeys: Swift.CustomStringConvertible {
    var description: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CustomCodableTest.CodingKeys: Swift.CustomDebugStringConvertible {
    var debugDescription: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CustomCodableTest.CodingKeys: Swift.RawRepresentable {
    typealias RawValue = Swift.String

    init?(rawValue: Self.RawValue)

    var rawValue: Self.RawValue {
        get
    }
}
extension SymbolTestsCore.CodableTests.CustomCodableTest.CodingKeys: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.CodableTests.CustomCodableTest.CodingKeys: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.CodableTests.CustomCodableTest.CodingKeys: Swift.CodingKey {
    init?(stringValue: Swift.String)
    init?(intValue: Swift.Int)

    var intValue: Swift.Int? {
        get
    }
    var stringValue: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableClassTest.CodingKeys: Swift.CustomStringConvertible {
    var description: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableClassTest.CodingKeys: Swift.CustomDebugStringConvertible {
    var debugDescription: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableClassTest.CodingKeys: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.CodableTests.CodableClassTest.CodingKeys: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.CodableTests.CodableClassTest.CodingKeys: Swift.CodingKey {
    init?(stringValue: Swift.String)
    init?(intValue: Swift.Int)

    var intValue: Swift.Int? {
        get
    }
    var stringValue: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.WithPairCodingKeys: Swift.CustomStringConvertible {
    var description: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.WithPairCodingKeys: Swift.CustomDebugStringConvertible {
    var debugDescription: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.WithPairCodingKeys: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.WithPairCodingKeys: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.WithPairCodingKeys: Swift.CodingKey {
    init?(stringValue: Swift.String)
    init?(intValue: Swift.Int)

    var intValue: Swift.Int? {
        get
    }
    var stringValue: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.WithValueCodingKeys: Swift.CustomStringConvertible {
    var description: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.WithValueCodingKeys: Swift.CustomDebugStringConvertible {
    var debugDescription: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.WithValueCodingKeys: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.WithValueCodingKeys: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.WithValueCodingKeys: Swift.CodingKey {
    init?(stringValue: Swift.String)
    init?(intValue: Swift.Int)

    var intValue: Swift.Int? {
        get
    }
    var stringValue: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.EmptyCodingKeys: Swift.CustomStringConvertible {
    var description: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.EmptyCodingKeys: Swift.CustomDebugStringConvertible {
    var debugDescription: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.EmptyCodingKeys: Swift.CodingKey {
    init?(stringValue: Swift.String)
    init?(intValue: Swift.Int)

    var intValue: Swift.Int? {
        get
    }
    var stringValue: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.CodingKeys: Swift.CustomStringConvertible {
    var description: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.CodingKeys: Swift.CustomDebugStringConvertible {
    var debugDescription: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.CodingKeys: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.CodingKeys: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.CodableTests.CodableEnumTest.CodingKeys: Swift.CodingKey {
    init?(stringValue: Swift.String)
    init?(intValue: Swift.Int)

    var intValue: Swift.Int? {
        get
    }
    var stringValue: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.GenericCodableTest.CodingKeys: Swift.CustomStringConvertible {
    var description: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.GenericCodableTest.CodingKeys: Swift.CustomDebugStringConvertible {
    var debugDescription: Swift.String {
        get
    }
}
extension SymbolTestsCore.CodableTests.GenericCodableTest.CodingKeys: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.CodableTests.GenericCodableTest.CodingKeys: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.CodableTests.GenericCodableTest.CodingKeys: Swift.CodingKey {
    init?(stringValue: Swift.String)
    init?(intValue: Swift.Int)

    var intValue: Swift.Int? {
        get
    }
    var stringValue: Swift.String {
        get
    }
}
extension SymbolTestsCore.CollectionConformances.CustomSequenceTest.Iterator: Swift.IteratorProtocol {
    func next() -> Self.Element?
}
extension SymbolTestsCore.CollectionConformances.CustomSequenceTest: Swift.Sequence {
    var underestimatedCount: Swift.Int {
        get
    }

    func makeIterator() -> Self.Iterator
    func _customContainsEquatableElement(_: Self.Element) -> Swift.Bool?
    func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Element>
    func _copyContents(initializing: Swift.UnsafeMutableBufferPointer<Self.Element>) -> (Self.Iterator, Swift.Int)
    func withContiguousStorageIfAvailable<A1>(_: (_: Swift.UnsafeBufferPointer<Self.Element>) throws -> A1) throws -> A1?
}
extension SymbolTestsCore.CollectionConformances.CustomCollectionTest: Swift.Collection {
    var count: Swift.Int {
        get
    }
    var indices: Self.Indices {
        get
    }
    var isEmpty: Swift.Bool {
        get
    }
    var startIndex: Self.Index {
        get
    }

    func makeIterator() -> Self.Iterator
    func _customIndexOfEquatableElement(_: Self.Element) -> Self.Index??
    func _customLastIndexOfEquatableElement(_: Self.Element) -> Self.Index??
    func index(_: Self.Index, offsetBy: Swift.Int) -> Self.Index
    func index(_: Self.Index, offsetBy: Swift.Int, limitedBy: Self.Index) -> Self.Index?
    func distance(from: Self.Index, to: Self.Index) -> Swift.Int
    func _failEarlyRangeCheck(_: Self.Index, bounds: Swift.Range<Self.Index>)
    func _failEarlyRangeCheck(_: Self.Index, bounds: Swift.ClosedRange<Self.Index>)
    func _failEarlyRangeCheck(_: Swift.Range<Self.Index>, bounds: Swift.Range<Self.Index>)
    func index(after: Self.Index) -> Self.Index
    func formIndex(after: inout Self.Index)

    subscript(_: Swift.Range<Self.Index>) -> Self.SubSequence {
        get
    }
}
extension SymbolTestsCore.CollectionConformances.CustomCollectionTest: Swift.Sequence {
    var count: Swift.Int {
        get
    }
    var startIndex: Self.Index {
        get
    }

    func _customContainsEquatableElement(_: Self.Element) -> Swift.Bool?
    func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Element>
    func _copyContents(initializing: Swift.UnsafeMutableBufferPointer<Self.Element>) -> (Self.Iterator, Swift.Int)
    func withContiguousStorageIfAvailable<A1>(_: (_: Swift.UnsafeBufferPointer<Self.Element>) throws -> A1) throws -> A1?
}
extension SymbolTestsCore.CollectionConformances.CustomBidirectionalCollectionTest: Swift.BidirectionalCollection {
    func index(before: Self.Index) -> Self.Index
    func formIndex(before: inout Self.Index)
    func index(_: Self.Index, offsetBy: Swift.Int) -> Self.Index
    func index(_: Self.Index, offsetBy: Swift.Int, limitedBy: Self.Index) -> Self.Index?
    func distance(from: Self.Index, to: Self.Index) -> Swift.Int
}
extension SymbolTestsCore.CollectionConformances.CustomBidirectionalCollectionTest: Swift.Collection {
    var count: Swift.Int {
        get
    }
    var endIndex: Self.Index {
        get
    }
    var indices: Self.Indices {
        get
    }
    var isEmpty: Swift.Bool {
        get
    }
    var startIndex: Self.Index {
        get
    }

    func _customLastIndexOfEquatableElement(_: Self.Element) -> Self.Index??
    func _customIndexOfEquatableElement(_: Self.Element) -> Self.Index??
    func index(_: Self.Index, offsetBy: Swift.Int) -> Self.Index
    func index(_: Self.Index, offsetBy: Swift.Int, limitedBy: Self.Index) -> Self.Index?
    func distance(from: Self.Index, to: Self.Index) -> Swift.Int
    func _failEarlyRangeCheck(_: Self.Index, bounds: Swift.Range<Self.Index>)
    func _failEarlyRangeCheck(_: Self.Index, bounds: Swift.ClosedRange<Self.Index>)
    func _failEarlyRangeCheck(_: Swift.Range<Self.Index>, bounds: Swift.Range<Self.Index>)
    func index(after: Self.Index) -> Self.Index
    func formIndex(after: inout Self.Index)

    subscript(_: Swift.Range<Self.Index>) -> Self.SubSequence {
        get
    }
}
extension SymbolTestsCore.CollectionConformances.CustomBidirectionalCollectionTest: Swift.Sequence {
    var count: Swift.Int {
        get
    }
    var startIndex: Self.Index {
        get
    }

    func _customContainsEquatableElement(_: Self.Element) -> Swift.Bool?
    func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Element>
    func _copyContents(initializing: Swift.UnsafeMutableBufferPointer<Self.Element>) -> (Self.Iterator, Swift.Int)
    func withContiguousStorageIfAvailable<A1>(_: (_: Swift.UnsafeBufferPointer<Self.Element>) throws -> A1) throws -> A1?
}
extension SymbolTestsCore.CollectionConformances.CustomRandomAccessCollectionTest: Swift.RandomAccessCollection {
    func index(_: Self.Index, offsetBy: Swift.Int) -> Self.Index
    func index(_: Self.Index, offsetBy: Swift.Int, limitedBy: Self.Index) -> Self.Index?
    func distance(from: Self.Index, to: Self.Index) -> Swift.Int
}
extension SymbolTestsCore.CollectionConformances.CustomRandomAccessCollectionTest: Swift.BidirectionalCollection {
    func index(before: Self.Index) -> Self.Index
    func formIndex(before: inout Self.Index)
    func index(_: Self.Index, offsetBy: Swift.Int) -> Self.Index
    func index(_: Self.Index, offsetBy: Swift.Int, limitedBy: Self.Index) -> Self.Index?
    func distance(from: Self.Index, to: Self.Index) -> Swift.Int
}
extension SymbolTestsCore.CollectionConformances.CustomRandomAccessCollectionTest: Swift.Collection {
    var count: Swift.Int {
        get
    }
    var endIndex: Self.Index {
        get
    }
    var indices: Self.Indices {
        get
    }
    var isEmpty: Swift.Bool {
        get
    }
    var startIndex: Self.Index {
        get
    }

    func _customIndexOfEquatableElement(_: Self.Element) -> Self.Index??
    func _customLastIndexOfEquatableElement(_: Self.Element) -> Self.Index??
    func index(_: Self.Index, offsetBy: Swift.Int) -> Self.Index
    func index(_: Self.Index, offsetBy: Swift.Int, limitedBy: Self.Index) -> Self.Index?
    func distance(from: Self.Index, to: Self.Index) -> Swift.Int
    func _failEarlyRangeCheck(_: Self.Index, bounds: Swift.Range<Self.Index>)
    func _failEarlyRangeCheck(_: Self.Index, bounds: Swift.ClosedRange<Self.Index>)
    func _failEarlyRangeCheck(_: Swift.Range<Self.Index>, bounds: Swift.Range<Self.Index>)
    func index(after: Self.Index) -> Self.Index
    func formIndex(after: inout Self.Index)

    subscript(_: Swift.Range<Self.Index>) -> Self.SubSequence {
        get
    }
}
extension SymbolTestsCore.CollectionConformances.CustomRandomAccessCollectionTest: Swift.Sequence {
    var count: Swift.Int {
        get
    }
    var startIndex: Self.Index {
        get
    }

    func _customContainsEquatableElement(_: Self.Element) -> Swift.Bool?
    func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Element>
    func _copyContents(initializing: Swift.UnsafeMutableBufferPointer<Self.Element>) -> (Self.Iterator, Swift.Int)
    func withContiguousStorageIfAvailable<A1>(_: (_: Swift.UnsafeBufferPointer<Self.Element>) throws -> A1) throws -> A1?
}
extension SymbolTestsCore.Concurrency.TypedThrowsErrorTest: Swift.Error {
    var _code: Swift.Int {
        get
    }
    var _domain: Swift.String {
        get
    }
    var _userInfo: Swift.AnyObject? {
        get
    }

    func _getEmbeddedNSError() -> Swift.AnyObject?
}
extension SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest: Swift.Equatable where A: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest: Swift.Hashable where A: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest: Swift.Comparable where A: Swift.Comparable {
    static func < (_: Self, _: Self) -> Swift.Bool
    static func <= (_: Self, _: Self) -> Swift.Bool
    static func >= (_: Self, _: Self) -> Swift.Bool
    static func > (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest: SymbolTestsCore.ConditionalConformanceVariants.ConditionalFirstProtocol where A: SymbolTestsCore.ConditionalConformanceVariants.ConditionalFirstProtocol {}
extension SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest: SymbolTestsCore.ConditionalConformanceVariants.ConditionalSecondProtocol where A: SymbolTestsCore.ConditionalConformanceVariants.ConditionalFirstProtocol, A: SymbolTestsCore.ConditionalConformanceVariants.ConditionalSecondProtocol {}
extension SymbolTestsCore.ConditionalConformanceVariants.ConditionalContainerTest: SymbolTestsCore.ConditionalConformanceVariants.ConditionalThirdProtocol where A: SymbolTestsCore.ConditionalConformanceVariants.ConditionalFirstProtocol, A: SymbolTestsCore.ConditionalConformanceVariants.ConditionalSecondProtocol, A: SymbolTestsCore.ConditionalConformanceVariants.ConditionalThirdProtocol {}
extension SymbolTestsCore.CustomLiterals.IntegerLiteralTest: Swift.ExpressibleByIntegerLiteral {
    init(integerLiteral: Self.IntegerLiteralType)
}
extension SymbolTestsCore.CustomLiterals.StringLiteralTest: Swift.ExpressibleByStringLiteral {
    init(stringLiteral: Self.StringLiteralType)
}
extension SymbolTestsCore.CustomLiterals.StringLiteralTest: Swift.ExpressibleByUnicodeScalarLiteral {
    init(stringLiteral: Self.StringLiteralType)
}
extension SymbolTestsCore.CustomLiterals.StringLiteralTest: Swift.ExpressibleByExtendedGraphemeClusterLiteral {
    init(stringLiteral: Self.StringLiteralType)
}
extension SymbolTestsCore.CustomLiterals.ArrayLiteralTest: Swift.ExpressibleByArrayLiteral {
    init(arrayLiteral: Self.ArrayLiteralElement...)
}
extension SymbolTestsCore.CustomLiterals.DictionaryLiteralTest: Swift.ExpressibleByDictionaryLiteral {
    init(dictionaryLiteral: (Self.Key, Self.Value)...)
}
extension SymbolTestsCore.CustomLiterals.BooleanLiteralTest: Swift.ExpressibleByBooleanLiteral {
    init(booleanLiteral: Self.BooleanLiteralType)
}
extension SymbolTestsCore.CustomLiterals.FloatLiteralTest: Swift.ExpressibleByFloatLiteral {
    init(floatLiteral: Self.FloatLiteralType)
}
extension SymbolTestsCore.CustomLiterals.NilLiteralTest: Swift.ExpressibleByNilLiteral {
    init(nilLiteral: ())
}
extension SymbolTestsCore.DeinitVariants.ActorDeinitTest: Swift.Actor {
    var unownedExecutor: Swift.UnownedSerialExecutor {
        get
    }
}
extension SymbolTestsCore.DiamondInheritance.DiamondImplementationTest: SymbolTestsCore.DiamondInheritance.DiamondBottomProtocol {}
extension SymbolTestsCore.DiamondInheritance.DiamondImplementationTest: SymbolTestsCore.DiamondInheritance.DiamondLeftProtocol {}
extension SymbolTestsCore.DiamondInheritance.DiamondImplementationTest: SymbolTestsCore.DiamondInheritance.DiamondRightProtocol {}
extension SymbolTestsCore.DiamondInheritance.DiamondImplementationTest: SymbolTestsCore.DiamondInheritance.DiamondBaseProtocol {}
extension SymbolTestsCore.DistributedActors.DistributedActorTest: Distributed.DistributedActor {
    var actorSystem: Self.ActorSystem {
        get
    }
    var unownedExecutor: Swift.UnownedSerialExecutor {
        get
    }

    static func resolve(id: Self.ID, using: Self.ActorSystem) throws -> Self
}
extension SymbolTestsCore.DistributedActors.DistributedActorTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.DistributedActors.DistributedActorTest: Swift.Identifiable {
    var id: Self.ID {
        get
    }
}
extension SymbolTestsCore.DistributedActors.DistributedActorTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.DistributedActors.DistributedActorTest: Swift.Encodable {
    func encode(to: Swift.Encoder) throws
}
extension SymbolTestsCore.DistributedActors.DistributedActorTest: Swift.Decodable {
    init(from: Swift.Decoder) throws
}
extension SymbolTestsCore.DistributedActors.GenericDistributedActorTest: Distributed.DistributedActor {
    var actorSystem: Self.ActorSystem {
        get
    }
    var unownedExecutor: Swift.UnownedSerialExecutor {
        get
    }

    static func resolve(id: Self.ID, using: Self.ActorSystem) throws -> Self
}
extension SymbolTestsCore.DistributedActors.GenericDistributedActorTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.DistributedActors.GenericDistributedActorTest: Swift.Identifiable {
    var id: Self.ID {
        get
    }
}
extension SymbolTestsCore.DistributedActors.GenericDistributedActorTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.DistributedActors.GenericDistributedActorTest: Swift.Encodable {
    func encode(to: Swift.Encoder) throws
}
extension SymbolTestsCore.DistributedActors.GenericDistributedActorTest: Swift.Decodable {
    init(from: Swift.Decoder) throws
}
extension SymbolTestsCore.Enums.NoPayloadEnumTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.Enums.NoPayloadEnumTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.Enums.RawValueEnumTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.Enums.RawValueEnumTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.Enums.RawValueEnumTest: Swift.RawRepresentable {
    typealias RawValue = Swift.Int

    init?(rawValue: Self.RawValue)

    var rawValue: Self.RawValue {
        get
    }
}
extension SymbolTestsCore.Enums.StringRawValueEnumTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.Enums.StringRawValueEnumTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.Enums.StringRawValueEnumTest: Swift.RawRepresentable {
    typealias RawValue = Swift.String

    init?(rawValue: Self.RawValue)

    var rawValue: Self.RawValue {
        get
    }
}
extension SymbolTestsCore.Enums.CaseIterableEnumTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.Enums.CaseIterableEnumTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.Enums.CaseIterableEnumTest: Swift.RawRepresentable {
    typealias RawValue = Swift.String

    init?(rawValue: Self.RawValue)

    var rawValue: Self.RawValue {
        get
    }
}
extension SymbolTestsCore.Enums.CaseIterableEnumTest: Swift.CaseIterable {
    typealias AllCases = [SymbolTestsCore.Enums.CaseIterableEnumTest]

    static var allCases: Self.AllCases {
        get
    }
}
extension SymbolTestsCore.Enums.ObjCEnumTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.Enums.ObjCEnumTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.Enums.ObjCEnumTest: Swift.RawRepresentable {
    typealias RawValue = Swift.Int

    init?(rawValue: Self.RawValue)

    var rawValue: Self.RawValue {
        get
    }
}
extension SymbolTestsCore.Enums.LargeFrozenEnumTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.Enums.LargeFrozenEnumTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.ErrorTypes.SimpleErrorTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.ErrorTypes.SimpleErrorTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.ErrorTypes.SimpleErrorTest: Swift.Error {
    var _code: Swift.Int {
        get
    }
    var _domain: Swift.String {
        get
    }
    var _userInfo: Swift.AnyObject? {
        get
    }

    func _getEmbeddedNSError() -> Swift.AnyObject?
}
extension SymbolTestsCore.ErrorTypes.AssociatedValueErrorTest: Swift.Error {
    var _code: Swift.Int {
        get
    }
    var _domain: Swift.String {
        get
    }
    var _userInfo: Swift.AnyObject? {
        get
    }

    func _getEmbeddedNSError() -> Swift.AnyObject?
}
extension SymbolTestsCore.ErrorTypes.LocalizedErrorTest: Foundation.LocalizedError {
    var errorDescription: Swift.String? {
        get
    }
    var failureReason: Swift.String? {
        get
    }
    var helpAnchor: Swift.String? {
        get
    }
    var recoverySuggestion: Swift.String? {
        get
    }
}
extension SymbolTestsCore.ErrorTypes.LocalizedErrorTest: Swift.Error {
    var _code: Swift.Int {
        get
    }
    var _domain: Swift.String {
        get
    }
    var _userInfo: Swift.AnyObject? {
        get
    }

    func _getEmbeddedNSError() -> Swift.AnyObject?
}
extension SymbolTestsCore.ErrorTypes.CustomNSErrorTest: Foundation.CustomNSError {
    var errorCode: Swift.Int {
        get
    }
    var errorUserInfo: [Swift.String : Any] {
        get
    }

    static var errorDomain: Swift.String {
        get
    }
}
extension SymbolTestsCore.ErrorTypes.CustomNSErrorTest: Swift.Error {
    var _code: Swift.Int {
        get
    }
    var _domain: Swift.String {
        get
    }
    var _userInfo: Swift.AnyObject? {
        get
    }

    func _getEmbeddedNSError() -> Swift.AnyObject?
}
extension SymbolTestsCore.ErrorTypes.SendableErrorTest: Swift.Error {
    var _code: Swift.Int {
        get
    }
    var _domain: Swift.String {
        get
    }
    var _userInfo: Swift.AnyObject? {
        get
    }

    func _getEmbeddedNSError() -> Swift.AnyObject?
}
extension SymbolTestsCore.Extensions.ExtensionConstrainedStruct: SymbolTestsCore.Extensions.ExtensionProtocol where A: Swift.Hashable {}
extension SymbolTestsCore.Generics.GenericRequirementTest: SymbolTestsCore.Protocols.ProtocolTest {}
extension SymbolTestsCore.Generics.GenericRequirementTest: Swift.RawRepresentable where A: Swift.RawRepresentable {
    init?(rawValue: Self.RawValue)

    var body: Self.Body {
        get
    }
}
extension SymbolTestsCore.Generics.GenericRequirementTest: Swift.Equatable where A: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.Generics.GenericPackTest: SymbolTestsCore.Protocols.ProtocolTest {}
extension SymbolTestsCore.Generics.GenericValueTest: SymbolTestsCore.Protocols.ProtocolTest {}
extension SymbolTestsCore.Initializers.CustomInitializerError: Swift.Error {
    var _code: Swift.Int {
        get
    }
    var _domain: Swift.String {
        get
    }
    var _userInfo: Swift.AnyObject? {
        get
    }

    func _getEmbeddedNSError() -> Swift.AnyObject?
}
extension SymbolTestsCore.Initializers.AsyncInitializerActorTest: Swift.Actor {
    var unownedExecutor: Swift.UnownedSerialExecutor {
        get
    }
}
extension SymbolTestsCore.MarkerProtocols.MarkerConformingStructTest: SymbolTestsCore.MarkerProtocols.MarkerProtocolTest {}
extension SymbolTestsCore.MarkerProtocols.MarkerConformingStructTest: SymbolTestsCore.MarkerProtocols.EmptyMarkerProtocolTest {}
extension SymbolTestsCore.MarkerProtocols.MarkerConformingClassTest: SymbolTestsCore.MarkerProtocols.ClassBoundMarkerProtocol {}
extension SymbolTestsCore.MarkerProtocols.MarkerConformingClassTest: SymbolTestsCore.MarkerProtocols.InheritingMarkerProtocol {}
extension SymbolTestsCore.MarkerProtocols.MarkerConformingClassTest: SymbolTestsCore.MarkerProtocols.MarkerProtocolTest {}
extension SymbolTestsCore.MarkerProtocols.MarkerConformingEnumTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.MarkerProtocols.MarkerConformingEnumTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.MarkerProtocols.MarkerConformingEnumTest: SymbolTestsCore.MarkerProtocols.MarkerProtocolTest {}
extension Swift.Never: SymbolTestsCore.Protocols.ProtocolTest {
    typealias Body = Swift.Never
}
extension Swift.Never: @retroactive Swift.IteratorProtocol {
    typealias Element = Swift.Never

    func next() -> Self.Element?
}
extension Swift.Never: @retroactive Swift.Sequence {
    typealias Element = Swift.Never
    typealias Iterator = Swift.Never

    var underestimatedCount: Swift.Int {
        get
    }

    func makeIterator() -> Self.Iterator
    func _customContainsEquatableElement(_: Self.Element) -> Swift.Bool?
    func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Element>
    func _copyContents(initializing: Swift.UnsafeMutableBufferPointer<Self.Element>) -> (Self.Iterator, Swift.Int)
    func withContiguousStorageIfAvailable<A1>(_: (_: Swift.UnsafeBufferPointer<Self.Element>) throws -> A1) throws -> A1?
}
extension SymbolTestsCore.OpaqueReturnTypes.OpaqueReturnTypeTest.AnyProtocolTest: SymbolTestsCore.Protocols.ProtocolTest {}
extension SymbolTestsCore.OpaqueReturnTypes.ProtocolPrimaryAssociatedTypeFirst: SymbolTestsCore.Protocols.ProtocolTest {
    typealias Body = SymbolTestsCore.OpaqueReturnTypes.ProtocolPrimaryAssociatedTypeFirst
}
extension SymbolTestsCore.OpaqueReturnTypes.ProtocolPrimaryAssociatedTypeSecond: SymbolTestsCore.Protocols.ProtocolTest {
    typealias Body = SymbolTestsCore.OpaqueReturnTypes.ProtocolPrimaryAssociatedTypeFirst
}
extension SymbolTestsCore.OpaqueReturnTypes.UnderlyingPrimaryAssociatedTypeTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.OpaqueReturnTypes.UnderlyingPrimaryAssociatedTypeTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.OpaqueReturnTypes.UnderlyingPrimaryAssociatedTypeTest: SymbolTestsCore.OpaqueReturnTypes.ProtocolPrimaryAssociatedTypeTest {
    typealias First = A
    typealias Second = B
}
extension SymbolTestsCore.Operators.OperatorTestType: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest: Swift.OptionSet {
    init(rawValue: Self.RawValue)
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest: Swift.RawRepresentable {
    init?(rawValue: Self.RawValue)

    var rawValue: Self.RawValue {
        get
    }
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest: Swift.SetAlgebra {
    init()
    init<A1>(_: consuming A1) where A1: Swift.Sequence, Self.Element == A1.Element

    var isEmpty: Swift.Bool {
        get
    }

    func isSuperset(of: Self) -> Swift.Bool
    func union(_: consuming Self) -> Self
    func intersection(_: Self) -> Self
    func symmetricDifference(_: consuming Self) -> Self
    func insert(_: consuming Self.Element) -> (inserted: Swift.Bool, memberAfterInsert: Self.Element)
    func remove(_: Self.Element) -> Self.Element?
    func update(with: consuming Self.Element) -> Self.Element?
    func formUnion(_: consuming Self)
    func formIntersection(_: Self)
    func formSymmetricDifference(_: consuming Self)
    func subtracting(_: Self) -> Self
    func isSubset(of: Self) -> Swift.Bool
    func isDisjoint(with: Self) -> Swift.Bool
    func contains(_: Self.Element) -> Swift.Bool
    func subtract(_: Self)
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest: Swift.ExpressibleByArrayLiteral {
    init(arrayLiteral: Self.ArrayLiteralElement...)
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.StringRawRepresentableTest: Swift.RawRepresentable {
    init?(rawValue: Self.RawValue)

    var rawValue: Self.RawValue {
        get
    }
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.IntRawRepresentableTest: Swift.RawRepresentable {
    init?(rawValue: Self.RawValue)

    var rawValue: Self.RawValue {
        get
    }
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.GenericRawRepresentableTest: Swift.RawRepresentable {
    init?(rawValue: Self.RawValue)

    var rawValue: Self.RawValue {
        get
    }
}
extension Swift.Array: SymbolTestsCore.Protocols.TestCollection {
    typealias Element = A
}
extension SymbolTestsCore.StringInterpolations.CustomStringInterpolationTest.StringInterpolation: Swift.StringInterpolationProtocol {
    init(literalCapacity: Swift.Int, interpolationCount: Swift.Int)

    func appendLiteral(_: Self.StringLiteralType)
}
extension SymbolTestsCore.StringInterpolations.CustomStringInterpolationTest: Swift.ExpressibleByStringLiteral {
    init(stringInterpolation: Self.StringInterpolation)
}
extension SymbolTestsCore.StringInterpolations.CustomStringInterpolationTest: Swift.ExpressibleByStringInterpolation {
    init(stringInterpolation: Self.StringInterpolation)
}
extension SymbolTestsCore.StringInterpolations.CustomStringInterpolationTest: Swift.ExpressibleByExtendedGraphemeClusterLiteral {
    init(stringInterpolation: Self.StringInterpolation)
}
extension SymbolTestsCore.StringInterpolations.CustomStringInterpolationTest: Swift.ExpressibleByUnicodeScalarLiteral {
    init(stringInterpolation: Self.StringInterpolation)
}
extension SymbolTestsCore.Structs.StructTest: SymbolTestsCore.Protocols.ProtocolTest {}
extension SymbolTestsCore.Structs.StructTest: SymbolTestsCore.Protocols.ProtocolWitnessTableTest {}
extension SymbolTestsCore.Structs.PrivateProtocolTest: Swift.Hashable {
    var hashValue: Swift.Int {
        get
    }

    func hash(into: inout Swift.Hasher)
    func _rawHashValue(seed: Swift.Int) -> Swift.Int
}
extension SymbolTestsCore.Structs.PrivateProtocolTest: Swift.Equatable {
    static func == (_: Self, _: Self) -> Swift.Bool
}
extension SymbolTestsCore.Structs.PrivateProtocolTest: SymbolTestsCore.Protocols.ProtocolTest {
    typealias Body = Swift.Never
}
extension SymbolTestsCore.Actors.CustomGlobalActor {
    typealias ActorType = SymbolTestsCore.Actors.CustomGlobalActor
}
extension SymbolTestsCore.AssociatedTypeWitnessPatterns.ConcreteWitnessTest {
    typealias First = Swift.Int
    typealias Second = [Swift.String]
    typealias Third = Swift.Double
    typealias Fourth = Swift.Bool
    typealias Fifth = Swift.Character
}
extension SymbolTestsCore.AssociatedTypeWitnessPatterns.NestedWitnessTest {
    typealias First = SymbolTestsCore.AssociatedTypeWitnessPatterns.NestedWitnessTest.NestedFirst
    typealias Second = [SymbolTestsCore.AssociatedTypeWitnessPatterns.NestedWitnessTest.NestedFirst]
    typealias Third = SymbolTestsCore.AssociatedTypeWitnessPatterns.NestedWitnessTest.NestedThird
    typealias Fourth = (SymbolTestsCore.AssociatedTypeWitnessPatterns.NestedWitnessTest.NestedFirst, SymbolTestsCore.AssociatedTypeWitnessPatterns.NestedWitnessTest.NestedThird)
    typealias Fifth = SymbolTestsCore.AssociatedTypeWitnessPatterns.NestedWitnessTest.NestedFirst?
}
extension SymbolTestsCore.AssociatedTypeWitnessPatterns.GenericParameterWitnessTest {
    typealias First = A
    typealias Second = [A]
    typealias Third = A?
    typealias Fourth = (A, A)
    typealias Fifth = [Swift.String : A]
}
extension SymbolTestsCore.AssociatedTypeWitnessPatterns.RecursiveWitnessTest {
    typealias First = SymbolTestsCore.AssociatedTypeWitnessPatterns.RecursiveWitnessTest
    typealias Second = [SymbolTestsCore.AssociatedTypeWitnessPatterns.RecursiveWitnessTest]
    typealias Third = SymbolTestsCore.AssociatedTypeWitnessPatterns.RecursiveWitnessTest?
    typealias Fourth = (SymbolTestsCore.AssociatedTypeWitnessPatterns.RecursiveWitnessTest, SymbolTestsCore.AssociatedTypeWitnessPatterns.RecursiveWitnessTest)
    typealias Fifth = [Swift.String : SymbolTestsCore.AssociatedTypeWitnessPatterns.RecursiveWitnessTest]
}
extension SymbolTestsCore.AssociatedTypeWitnessPatterns.DependentWitnessTest {
    typealias First = A.Element
    typealias Second = A
    typealias Third = A.Iterator
    typealias Fourth = A.Index
    typealias Fifth = A.SubSequence
}
extension SymbolTestsCore.AsyncSequenceTests.AsyncSequenceTest.AsyncIterator {
    typealias Element = Swift.Int
    typealias Failure = Swift.Never
}
extension SymbolTestsCore.AsyncSequenceTests.AsyncSequenceTest {
    typealias AsyncIterator = SymbolTestsCore.AsyncSequenceTests.AsyncSequenceTest.AsyncIterator
    typealias Element = Swift.Int
    typealias Failure = Swift.Never
}
extension SymbolTestsCore.AsyncSequenceTests.ThrowingAsyncSequenceTest.AsyncIterator {
    typealias Element = Swift.String
    typealias Failure = Swift.Error
}
extension SymbolTestsCore.AsyncSequenceTests.ThrowingAsyncSequenceTest {
    typealias AsyncIterator = SymbolTestsCore.AsyncSequenceTests.ThrowingAsyncSequenceTest.AsyncIterator
    typealias Element = Swift.String
    typealias Failure = Swift.Error
}
extension SymbolTestsCore.AsyncSequenceTests.GenericAsyncSequenceTest.AsyncIterator {
    typealias Element = A
    typealias Failure = Swift.Never
}
extension SymbolTestsCore.AsyncSequenceTests.GenericAsyncSequenceTest {
    typealias AsyncIterator = SymbolTestsCore.AsyncSequenceTests.GenericAsyncSequenceTest<A>.AsyncIterator
    typealias Element = A
    typealias Failure = Swift.Never
}
extension SymbolTestsCore.CollectionConformances.CustomSequenceTest.Iterator {
    typealias Element = Swift.Int
}
extension SymbolTestsCore.CollectionConformances.CustomSequenceTest {
    typealias Element = Swift.Int
    typealias Iterator = SymbolTestsCore.CollectionConformances.CustomSequenceTest.Iterator
}
extension SymbolTestsCore.CollectionConformances.CustomCollectionTest {
    typealias Element = Swift.Int
    typealias Index = Swift.Int
    typealias Iterator = Swift.IndexingIterator<SymbolTestsCore.CollectionConformances.CustomCollectionTest>
    typealias SubSequence = Swift.Slice<SymbolTestsCore.CollectionConformances.CustomCollectionTest>
    typealias Indices = Swift.DefaultIndices<SymbolTestsCore.CollectionConformances.CustomCollectionTest>
}
extension SymbolTestsCore.CollectionConformances.CustomBidirectionalCollectionTest {
    typealias Element = Swift.String
    typealias Index = Swift.Int
    typealias SubSequence = Swift.Slice<SymbolTestsCore.CollectionConformances.CustomBidirectionalCollectionTest>
    typealias Indices = Swift.DefaultIndices<SymbolTestsCore.CollectionConformances.CustomBidirectionalCollectionTest>
    typealias Iterator = Swift.IndexingIterator<SymbolTestsCore.CollectionConformances.CustomBidirectionalCollectionTest>
}
extension SymbolTestsCore.CollectionConformances.CustomRandomAccessCollectionTest {
    typealias Element = Swift.Double
    typealias Index = Swift.Int
    typealias SubSequence = Swift.Slice<SymbolTestsCore.CollectionConformances.CustomRandomAccessCollectionTest>
    typealias Indices = Swift.Range<Swift.Int>
    typealias Iterator = Swift.IndexingIterator<SymbolTestsCore.CollectionConformances.CustomRandomAccessCollectionTest>
}
extension SymbolTestsCore.CustomLiterals.IntegerLiteralTest {
    typealias IntegerLiteralType = Swift.Int64
}
extension SymbolTestsCore.CustomLiterals.StringLiteralTest {
    typealias StringLiteralType = Swift.String
    typealias UnicodeScalarLiteralType = Swift.String
    typealias ExtendedGraphemeClusterLiteralType = Swift.String
}
extension SymbolTestsCore.CustomLiterals.ArrayLiteralTest {
    typealias ArrayLiteralElement = Swift.Int
}
extension SymbolTestsCore.CustomLiterals.DictionaryLiteralTest {
    typealias Key = Swift.String
    typealias Value = Swift.Int
}
extension SymbolTestsCore.CustomLiterals.BooleanLiteralTest {
    typealias BooleanLiteralType = Swift.Bool
}
extension SymbolTestsCore.CustomLiterals.FloatLiteralTest {
    typealias FloatLiteralType = Swift.Double
}
extension SymbolTestsCore.DistributedActors.DistributedActorTest {
    typealias ActorSystem = Distributed.LocalTestingDistributedActorSystem
    typealias SerializationRequirement = Swift.Decodable & Swift.Encodable
    typealias ID = Distributed.LocalTestingActorID
}
extension SymbolTestsCore.DistributedActors.GenericDistributedActorTest {
    typealias ActorSystem = Distributed.LocalTestingDistributedActorSystem
    typealias SerializationRequirement = Swift.Decodable & Swift.Encodable
    typealias ID = Distributed.LocalTestingActorID
}
extension SymbolTestsCore.Extensions.ExtensionConstrainedStruct {
    typealias Item = A
}
extension SymbolTestsCore.Generics.GenericRequirementTest {
    typealias Body = A
    typealias RawValue = A
}
extension SymbolTestsCore.Generics.GenericPackTest {
    typealias Body = Swift.Never
}
extension SymbolTestsCore.Generics.GenericValueTest {
    typealias Body = Swift.Never
}
extension SymbolTestsCore.OpaqueReturnTypes.OpaqueReturnTypeTest.AnyProtocolTest {
    typealias Body = A
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest {
    typealias Element = SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest
    typealias RawValue = Swift.UInt
    typealias ArrayLiteralElement = SymbolTestsCore.OptionSetAndRawRepresentable.OptionSetTest
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.StringRawRepresentableTest {
    typealias RawValue = Swift.String
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.IntRawRepresentableTest {
    typealias RawValue = Swift.Int
}
extension SymbolTestsCore.OptionSetAndRawRepresentable.GenericRawRepresentableTest {
    typealias RawValue = A
}
extension SymbolTestsCore.StringInterpolations.CustomStringInterpolationTest.StringInterpolation {
    typealias StringLiteralType = Swift.String
}
extension SymbolTestsCore.StringInterpolations.CustomStringInterpolationTest {
    typealias StringLiteralType = Swift.String
    typealias StringInterpolation = SymbolTestsCore.StringInterpolations.CustomStringInterpolationTest.StringInterpolation
    typealias ExtendedGraphemeClusterLiteralType = Swift.String
    typealias UnicodeScalarLiteralType = Swift.String
}
extension SymbolTestsCore.Structs.StructTest {
    typealias Body = SymbolTestsCore.Structs.PrivateProtocolTest
}
