ARK-OS/arkos/arkrt/ark.ui.basic/Sources/Views/TupleView.swift

// This file was generated using gyb. Do not edit it directly. Edit
// TupleView.swift.gyb instead.

// swiftformat:options --allow-partial-wrapping true

@MainActor
private func layoutableChild<V: View>(
    node: AnyViewGraphNode<V>,
    view: V
) -> LayoutSystem.LayoutableChild {
    LayoutSystem.LayoutableChild(
        computeLayout: { proposedSize, environment in
            node.computeLayout(
                with: view,
                proposedSize: proposedSize,
                environment: environment
            )
        },
        commit: {
            node.commit()
        },
        tag: "\(type(of: view))"
    )
}

/// Just a vessel for some default implementations to compress this generated code.
@MainActor
protocol TupleView: TypeSafeView {}

extension TupleView {
    @MainActor
    func asWidget<Backend: BaseAppBackend>(
        _ children: Children,
        backend: Backend
    ) -> Backend.Widget {
        let group = Group(content: self)
        return group.asWidget(children, backend: backend)
    }

    @MainActor
    func computeLayout<Backend: BaseAppBackend>(
        _ widget: Backend.Widget,
        children: Children,
        proposedSize: ProposedViewSize,
        environment: EnvironmentValues,
        backend: Backend
    ) -> ViewLayoutResult {
        let group = Group(content: self)
        return group.computeLayout(
            widget,
            children: children,
            proposedSize: proposedSize,
            environment: environment,
            backend: backend
        )
    }

    @MainActor
    func commit<Backend: BaseAppBackend>(
        _ widget: Backend.Widget,
        children: Children,
        layout: ViewLayoutResult,
        environment: EnvironmentValues,
        backend: Backend
    ) {
        let group = Group(content: self)
        group.commit(
            widget,
            children: children,
            layout: layout,
            environment: environment,
            backend: backend
        )
    }
}

/// A view with exactly 1 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView1<
    View0: View
> {
    public var view0: View0

    public var body = EmptyView()

    /// Wraps 1 child views in a single container view.
    public init(
        _ view0: View0
    ) {
        self.view0 = view0
    }
}

extension TupleView1: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        return result
    }
}

extension TupleView1: TupleView {
    typealias Children = TupleViewChildren1<View0>

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
        ]
    }
}

/// A view with exactly 2 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView2<
    View0: View, View1: View
> {
    public var view0: View0
    public var view1: View1

    public var body = EmptyView()

    /// Wraps 2 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1
    ) {
        self.view0 = view0
        self.view1 = view1
    }
}

extension TupleView2: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        return result
    }
}

extension TupleView2: TupleView {
    typealias Children = TupleViewChildren2<View0, View1>

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
        ]
    }
}

/// A view with exactly 3 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView3<
    View0: View, View1: View, View2: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2

    public var body = EmptyView()

    /// Wraps 3 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
    }
}

extension TupleView3: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        return result
    }
}

extension TupleView3: TupleView {
    typealias Children = TupleViewChildren3<View0, View1, View2>

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
        ]
    }
}

/// A view with exactly 4 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView4<
    View0: View, View1: View, View2: View, View3: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3

    public var body = EmptyView()

    /// Wraps 4 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
    }
}

extension TupleView4: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        return result
    }
}

extension TupleView4: TupleView {
    typealias Children = TupleViewChildren4<View0, View1, View2, View3>

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
        ]
    }
}

/// A view with exactly 5 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView5<
    View0: View, View1: View, View2: View, View3: View, View4: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4

    public var body = EmptyView()

    /// Wraps 5 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
    }
}

extension TupleView5: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        return result
    }
}

extension TupleView5: TupleView {
    typealias Children = TupleViewChildren5<View0, View1, View2, View3, View4>

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
        ]
    }
}

/// A view with exactly 6 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView6<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5

    public var body = EmptyView()

    /// Wraps 6 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
    }
}

extension TupleView6: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        return result
    }
}

extension TupleView6: TupleView {
    typealias Children = TupleViewChildren6<View0, View1, View2, View3, View4, View5>

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
        ]
    }
}

/// A view with exactly 7 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView7<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6

    public var body = EmptyView()

    /// Wraps 7 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
    }
}

extension TupleView7: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        return result
    }
}

extension TupleView7: TupleView {
    typealias Children = TupleViewChildren7<View0, View1, View2, View3, View4, View5, View6>

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
        ]
    }
}

/// A view with exactly 8 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView8<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7

    public var body = EmptyView()

    /// Wraps 8 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
    }
}

extension TupleView8: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        return result
    }
}

extension TupleView8: TupleView {
    typealias Children = TupleViewChildren8<View0, View1, View2, View3, View4, View5, View6, View7>

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
        ]
    }
}

/// A view with exactly 9 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView9<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8

    public var body = EmptyView()

    /// Wraps 9 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
    }
}

extension TupleView9: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        return result
    }
}

extension TupleView9: TupleView {
    typealias Children = TupleViewChildren9<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
        ]
    }
}

/// A view with exactly 10 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView10<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9

    public var body = EmptyView()

    /// Wraps 10 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
    }
}

extension TupleView10: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        return result
    }
}

extension TupleView10: TupleView {
    typealias Children = TupleViewChildren10<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
        ]
    }
}

/// A view with exactly 11 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView11<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View, View10: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9
    public var view10: View10

    public var body = EmptyView()

    /// Wraps 11 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9,
        _ view10: View10
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
        self.view10 = view10
    }
}

extension TupleView11: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        result += view10._asMenuItems
        return result
    }
}

extension TupleView11: TupleView {
    typealias Children = TupleViewChildren11<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9,
        View10
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9, view10,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
            layoutableChild(node: children.child10, view: view10),
        ]
    }
}

/// A view with exactly 12 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView12<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View, View10: View, View11: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9
    public var view10: View10
    public var view11: View11

    public var body = EmptyView()

    /// Wraps 12 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9,
        _ view10: View10, _ view11: View11
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
        self.view10 = view10
        self.view11 = view11
    }
}

extension TupleView12: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        result += view10._asMenuItems
        result += view11._asMenuItems
        return result
    }
}

extension TupleView12: TupleView {
    typealias Children = TupleViewChildren12<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9,
        View10,
        View11
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9, view10, view11,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
            layoutableChild(node: children.child10, view: view10),
            layoutableChild(node: children.child11, view: view11),
        ]
    }
}

/// A view with exactly 13 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView13<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View, View10: View, View11: View, View12: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9
    public var view10: View10
    public var view11: View11
    public var view12: View12

    public var body = EmptyView()

    /// Wraps 13 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9,
        _ view10: View10, _ view11: View11, _ view12: View12
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
        self.view10 = view10
        self.view11 = view11
        self.view12 = view12
    }
}

extension TupleView13: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        result += view10._asMenuItems
        result += view11._asMenuItems
        result += view12._asMenuItems
        return result
    }
}

extension TupleView13: TupleView {
    typealias Children = TupleViewChildren13<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9,
        View10,
        View11,
        View12
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9, view10, view11,
            view12,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
            layoutableChild(node: children.child10, view: view10),
            layoutableChild(node: children.child11, view: view11),
            layoutableChild(node: children.child12, view: view12),
        ]
    }
}

/// A view with exactly 14 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView14<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View, View10: View, View11: View, View12: View,
    View13: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9
    public var view10: View10
    public var view11: View11
    public var view12: View12
    public var view13: View13

    public var body = EmptyView()

    /// Wraps 14 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9,
        _ view10: View10, _ view11: View11, _ view12: View12, _ view13: View13
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
        self.view10 = view10
        self.view11 = view11
        self.view12 = view12
        self.view13 = view13
    }
}

extension TupleView14: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        result += view10._asMenuItems
        result += view11._asMenuItems
        result += view12._asMenuItems
        result += view13._asMenuItems
        return result
    }
}

extension TupleView14: TupleView {
    typealias Children = TupleViewChildren14<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9,
        View10,
        View11,
        View12,
        View13
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9, view10, view11,
            view12, view13,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
            layoutableChild(node: children.child10, view: view10),
            layoutableChild(node: children.child11, view: view11),
            layoutableChild(node: children.child12, view: view12),
            layoutableChild(node: children.child13, view: view13),
        ]
    }
}

/// A view with exactly 15 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView15<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View, View10: View, View11: View, View12: View,
    View13: View, View14: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9
    public var view10: View10
    public var view11: View11
    public var view12: View12
    public var view13: View13
    public var view14: View14

    public var body = EmptyView()

    /// Wraps 15 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9,
        _ view10: View10, _ view11: View11, _ view12: View12, _ view13: View13, _ view14: View14
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
        self.view10 = view10
        self.view11 = view11
        self.view12 = view12
        self.view13 = view13
        self.view14 = view14
    }
}

extension TupleView15: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        result += view10._asMenuItems
        result += view11._asMenuItems
        result += view12._asMenuItems
        result += view13._asMenuItems
        result += view14._asMenuItems
        return result
    }
}

extension TupleView15: TupleView {
    typealias Children = TupleViewChildren15<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9,
        View10,
        View11,
        View12,
        View13,
        View14
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9, view10, view11,
            view12, view13, view14,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
            layoutableChild(node: children.child10, view: view10),
            layoutableChild(node: children.child11, view: view11),
            layoutableChild(node: children.child12, view: view12),
            layoutableChild(node: children.child13, view: view13),
            layoutableChild(node: children.child14, view: view14),
        ]
    }
}

/// A view with exactly 16 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView16<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View, View10: View, View11: View, View12: View,
    View13: View, View14: View, View15: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9
    public var view10: View10
    public var view11: View11
    public var view12: View12
    public var view13: View13
    public var view14: View14
    public var view15: View15

    public var body = EmptyView()

    /// Wraps 16 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9,
        _ view10: View10, _ view11: View11, _ view12: View12, _ view13: View13,
        _ view14: View14,
        _ view15: View15
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
        self.view10 = view10
        self.view11 = view11
        self.view12 = view12
        self.view13 = view13
        self.view14 = view14
        self.view15 = view15
    }
}

extension TupleView16: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        result += view10._asMenuItems
        result += view11._asMenuItems
        result += view12._asMenuItems
        result += view13._asMenuItems
        result += view14._asMenuItems
        result += view15._asMenuItems
        return result
    }
}

extension TupleView16: TupleView {
    typealias Children = TupleViewChildren16<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9,
        View10,
        View11,
        View12,
        View13,
        View14,
        View15
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9, view10, view11,
            view12, view13, view14, view15,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
            layoutableChild(node: children.child10, view: view10),
            layoutableChild(node: children.child11, view: view11),
            layoutableChild(node: children.child12, view: view12),
            layoutableChild(node: children.child13, view: view13),
            layoutableChild(node: children.child14, view: view14),
            layoutableChild(node: children.child15, view: view15),
        ]
    }
}

/// A view with exactly 17 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView17<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View, View10: View, View11: View, View12: View,
    View13: View, View14: View, View15: View, View16: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9
    public var view10: View10
    public var view11: View11
    public var view12: View12
    public var view13: View13
    public var view14: View14
    public var view15: View15
    public var view16: View16

    public var body = EmptyView()

    /// Wraps 17 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9,
        _ view10: View10, _ view11: View11, _ view12: View12, _ view13: View13,
        _ view14: View14,
        _ view15: View15, _ view16: View16
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
        self.view10 = view10
        self.view11 = view11
        self.view12 = view12
        self.view13 = view13
        self.view14 = view14
        self.view15 = view15
        self.view16 = view16
    }
}

extension TupleView17: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        result += view10._asMenuItems
        result += view11._asMenuItems
        result += view12._asMenuItems
        result += view13._asMenuItems
        result += view14._asMenuItems
        result += view15._asMenuItems
        result += view16._asMenuItems
        return result
    }
}

extension TupleView17: TupleView {
    typealias Children = TupleViewChildren17<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9,
        View10,
        View11,
        View12,
        View13,
        View14,
        View15,
        View16
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9, view10, view11,
            view12, view13, view14, view15, view16,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
            layoutableChild(node: children.child10, view: view10),
            layoutableChild(node: children.child11, view: view11),
            layoutableChild(node: children.child12, view: view12),
            layoutableChild(node: children.child13, view: view13),
            layoutableChild(node: children.child14, view: view14),
            layoutableChild(node: children.child15, view: view15),
            layoutableChild(node: children.child16, view: view16),
        ]
    }
}

/// A view with exactly 18 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView18<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View, View10: View, View11: View, View12: View,
    View13: View, View14: View, View15: View, View16: View, View17: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9
    public var view10: View10
    public var view11: View11
    public var view12: View12
    public var view13: View13
    public var view14: View14
    public var view15: View15
    public var view16: View16
    public var view17: View17

    public var body = EmptyView()

    /// Wraps 18 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9,
        _ view10: View10, _ view11: View11, _ view12: View12, _ view13: View13,
        _ view14: View14,
        _ view15: View15, _ view16: View16, _ view17: View17
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
        self.view10 = view10
        self.view11 = view11
        self.view12 = view12
        self.view13 = view13
        self.view14 = view14
        self.view15 = view15
        self.view16 = view16
        self.view17 = view17
    }
}

extension TupleView18: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        result += view10._asMenuItems
        result += view11._asMenuItems
        result += view12._asMenuItems
        result += view13._asMenuItems
        result += view14._asMenuItems
        result += view15._asMenuItems
        result += view16._asMenuItems
        result += view17._asMenuItems
        return result
    }
}

extension TupleView18: TupleView {
    typealias Children = TupleViewChildren18<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9,
        View10,
        View11,
        View12,
        View13,
        View14,
        View15,
        View16,
        View17
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9, view10, view11,
            view12, view13, view14, view15, view16, view17,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
            layoutableChild(node: children.child10, view: view10),
            layoutableChild(node: children.child11, view: view11),
            layoutableChild(node: children.child12, view: view12),
            layoutableChild(node: children.child13, view: view13),
            layoutableChild(node: children.child14, view: view14),
            layoutableChild(node: children.child15, view: view15),
            layoutableChild(node: children.child16, view: view16),
            layoutableChild(node: children.child17, view: view17),
        ]
    }
}

/// A view with exactly 19 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView19<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View, View10: View, View11: View, View12: View,
    View13: View, View14: View, View15: View, View16: View, View17: View, View18: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9
    public var view10: View10
    public var view11: View11
    public var view12: View12
    public var view13: View13
    public var view14: View14
    public var view15: View15
    public var view16: View16
    public var view17: View17
    public var view18: View18

    public var body = EmptyView()

    /// Wraps 19 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9,
        _ view10: View10, _ view11: View11, _ view12: View12, _ view13: View13,
        _ view14: View14,
        _ view15: View15, _ view16: View16, _ view17: View17, _ view18: View18
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
        self.view10 = view10
        self.view11 = view11
        self.view12 = view12
        self.view13 = view13
        self.view14 = view14
        self.view15 = view15
        self.view16 = view16
        self.view17 = view17
        self.view18 = view18
    }
}

extension TupleView19: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        result += view10._asMenuItems
        result += view11._asMenuItems
        result += view12._asMenuItems
        result += view13._asMenuItems
        result += view14._asMenuItems
        result += view15._asMenuItems
        result += view16._asMenuItems
        result += view17._asMenuItems
        result += view18._asMenuItems
        return result
    }
}

extension TupleView19: TupleView {
    typealias Children = TupleViewChildren19<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9,
        View10,
        View11,
        View12,
        View13,
        View14,
        View15,
        View16,
        View17,
        View18
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9, view10, view11,
            view12, view13, view14, view15, view16, view17, view18,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
            layoutableChild(node: children.child10, view: view10),
            layoutableChild(node: children.child11, view: view11),
            layoutableChild(node: children.child12, view: view12),
            layoutableChild(node: children.child13, view: view13),
            layoutableChild(node: children.child14, view: view14),
            layoutableChild(node: children.child15, view: view15),
            layoutableChild(node: children.child16, view: view16),
            layoutableChild(node: children.child17, view: view17),
            layoutableChild(node: children.child18, view: view18),
        ]
    }
}

/// A view with exactly 20 children. Autogenerated as an alternative to Swift's not yet
/// production ready variadic generics.
///
/// Has the same behaviour as ``Group`` when rendered directly.
public struct TupleView20<
    View0: View, View1: View, View2: View, View3: View, View4: View, View5: View, View6: View,
    View7: View, View8: View, View9: View, View10: View, View11: View, View12: View,
    View13: View, View14: View, View15: View, View16: View, View17: View, View18: View,
    View19: View
> {
    public var view0: View0
    public var view1: View1
    public var view2: View2
    public var view3: View3
    public var view4: View4
    public var view5: View5
    public var view6: View6
    public var view7: View7
    public var view8: View8
    public var view9: View9
    public var view10: View10
    public var view11: View11
    public var view12: View12
    public var view13: View13
    public var view14: View14
    public var view15: View15
    public var view16: View16
    public var view17: View17
    public var view18: View18
    public var view19: View19

    public var body = EmptyView()

    /// Wraps 20 child views in a single container view.
    public init(
        _ view0: View0, _ view1: View1, _ view2: View2, _ view3: View3, _ view4: View4,
        _ view5: View5, _ view6: View6, _ view7: View7, _ view8: View8, _ view9: View9,
        _ view10: View10, _ view11: View11, _ view12: View12, _ view13: View13,
        _ view14: View14,
        _ view15: View15, _ view16: View16, _ view17: View17, _ view18: View18, _ view19: View19
    ) {
        self.view0 = view0
        self.view1 = view1
        self.view2 = view2
        self.view3 = view3
        self.view4 = view4
        self.view5 = view5
        self.view6 = view6
        self.view7 = view7
        self.view8 = view8
        self.view9 = view9
        self.view10 = view10
        self.view11 = view11
        self.view12 = view12
        self.view13 = view13
        self.view14 = view14
        self.view15 = view15
        self.view16 = view16
        self.view17 = view17
        self.view18 = view18
        self.view19 = view19
    }
}

extension TupleView20: View {
    public typealias Content = EmptyView
    public var _asMenuItems: [MenuItem] {
        var result: [MenuItem] = []
        result += view0._asMenuItems
        result += view1._asMenuItems
        result += view2._asMenuItems
        result += view3._asMenuItems
        result += view4._asMenuItems
        result += view5._asMenuItems
        result += view6._asMenuItems
        result += view7._asMenuItems
        result += view8._asMenuItems
        result += view9._asMenuItems
        result += view10._asMenuItems
        result += view11._asMenuItems
        result += view12._asMenuItems
        result += view13._asMenuItems
        result += view14._asMenuItems
        result += view15._asMenuItems
        result += view16._asMenuItems
        result += view17._asMenuItems
        result += view18._asMenuItems
        result += view19._asMenuItems
        return result
    }
}

extension TupleView20: TupleView {
    typealias Children = TupleViewChildren20<
        View0,
        View1,
        View2,
        View3,
        View4,
        View5,
        View6,
        View7,
        View8,
        View9,
        View10,
        View11,
        View12,
        View13,
        View14,
        View15,
        View16,
        View17,
        View18,
        View19
    >

    func children<Backend: BaseAppBackend>(
        backend: Backend,
        snapshots: [ViewGraphSnapshotter.NodeSnapshot]?,
        environment: EnvironmentValues
    ) -> Children {
        return Children(
            view0, view1, view2, view3, view4, view5, view6, view7, view8, view9, view10, view11,
            view12, view13, view14, view15, view16, view17, view18, view19,
            backend: backend, snapshots: snapshots, environment: environment
        )
    }

    func layoutableChildren<Backend: BaseAppBackend>(
        backend: Backend,
        children: Children
    ) -> [LayoutSystem.LayoutableChild] {
        [
            layoutableChild(node: children.child0, view: view0),
            layoutableChild(node: children.child1, view: view1),
            layoutableChild(node: children.child2, view: view2),
            layoutableChild(node: children.child3, view: view3),
            layoutableChild(node: children.child4, view: view4),
            layoutableChild(node: children.child5, view: view5),
            layoutableChild(node: children.child6, view: view6),
            layoutableChild(node: children.child7, view: view7),
            layoutableChild(node: children.child8, view: view8),
            layoutableChild(node: children.child9, view: view9),
            layoutableChild(node: children.child10, view: view10),
            layoutableChild(node: children.child11, view: view11),
            layoutableChild(node: children.child12, view: view12),
            layoutableChild(node: children.child13, view: view13),
            layoutableChild(node: children.child14, view: view14),
            layoutableChild(node: children.child15, view: view15),
            layoutableChild(node: children.child16, view: view16),
            layoutableChild(node: children.child17, view: view17),
            layoutableChild(node: children.child18, view: view18),
            layoutableChild(node: children.child19, view: view19),
        ]
    }
}