fix sliver_persistent_header error

com.unity.uiwidgets/Runtime/rendering/sliver_persistent_header.cs

             }
         }
 
-        FloatingHeaderSnapConfiguration _snapConfiguration;
+        public FloatingHeaderSnapConfiguration _snapConfiguration;
 
         protected virtual float updateGeometry() {
             float stretchOffset = 0.0f;

com.unity.uiwidgets/Runtime/widgets/DiagnosticableTree.mixin.gen.cs

-using System;
-using Unity.UIWidgets.ui;
-using UnityEngine;
+
 namespace Unity.UIWidgets.foundation {
     public class DiagnosticableTreeMixinChangeNotifier : ChangeNotifier, DiagnosticableTreeMixin {
         protected DiagnosticableTreeMixinChangeNotifier() {
         }
 
         public virtual void debugFillProperties(DiagnosticPropertiesBuilder properties) { }
-
-
-        
     }
 
 }

com.unity.uiwidgets/Runtime/widgets/DiagnosticableTree.mixin.njk

+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
 namespace Unity.UIWidgets.foundation {
 {% macro DiagnosticableTreeMixin(with) %}
     {% set className = 'DiagnosticableTreeMixin' + with %}

com.unity.uiwidgets/Runtime/widgets/DirectionalFocusTraversalPolicy.mixin.gen.cs

-using System;
-using Unity.UIWidgets.widgets;
+
 namespace Unity.UIWidgets.widgets {
     public class DirectionalFocusTraversalPolicyMixinFocusTraversalPolicy : FocusTraversalPolicy, DirectionalFocusTraversalPolicyMixin {
         protected DirectionalFocusTraversalPolicyMixinFocusTraversalPolicy() {

com.unity.uiwidgets/Runtime/widgets/DirectionalFocusTraversalPolicy.mixin.njk

+using System.Collections.Generic;
+using System.Linq;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.ui;
+
 namespace Unity.UIWidgets.widgets {
 {% macro DirectionalFocusTraversalPolicyMixin(with) %}
     {% set className = 'DirectionalFocusTraversalPolicyMixin' + with %}

com.unity.uiwidgets/Runtime/widgets/sliver_persistent_header.cs

         }
     }
 
-    class _SliverPersistentHeaderElement : RenderObjectElement {
+    public class _SliverPersistentHeaderElement : RenderObjectElement {
         public _SliverPersistentHeaderElement(_SliverPersistentHeaderRenderObjectWidget widget) : base(widget) {
         }
 
         }
     }
 
-    abstract class _SliverPersistentHeaderRenderObjectWidget : RenderObjectWidget {
+    public abstract class _SliverPersistentHeaderRenderObjectWidget : RenderObjectWidget {
         public _SliverPersistentHeaderRenderObjectWidget(
             Key key = null,
             SliverPersistentHeaderDelegate layoutDelegate = null
         }
     }
 
-    interface _RenderSliverPersistentHeaderForWidgetsMixin {
-        // on RenderSliverPersistentHeader  ???? todo 
+    public interface _RenderSliverPersistentHeaderForWidgetsMixin {
         _SliverPersistentHeaderElement _element { get; set; }
 
         float? minExtent {
         void updateChild(float shrinkOffset, bool overlapsContent);
         void triggerRebuild();
     }
+    
+    public class _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeader : RenderSliverPersistentHeader {
+        _SliverPersistentHeaderElement _element;
+
+        float? minExtent {
+            get {
+                return _element.widget.layoutDelegate.minExtent;
+            }
+        }
+
+        float? maxExtent {
+            get {
+                return _element.widget.layoutDelegate.minExtent;
+            }
+        }
+
+        void updateChild(float shrinkOffset, bool overlapsContent) {
+            D.assert(_element != null);
+            _element._build(shrinkOffset, overlapsContent);
+        }
+
+        void triggerRebuild() {
+            markNeedsLayout();
+        }
+        protected override void performLayout() {
+        }
+    }
 
     class _SliverScrollingPersistentHeader : _SliverPersistentHeaderRenderObjectWidget {
         public _SliverScrollingPersistentHeader(
     abstract class _RenderSliverPinnedPersistentHeader : RenderSliverPinnedPersistentHeader {
     }
 
-    class _RenderSliverPinnedPersistentHeaderForWidgets : RenderSliverPinnedPersistentHeader,
-        _RenderSliverPersistentHeaderForWidgetsMixin {
+    class _RenderSliverPinnedPersistentHeaderForWidgets : _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeaderRenderSliverPinnedPersistentHeader {
 
         public _RenderSliverPinnedPersistentHeaderForWidgets(
             RenderBox child = null,
     abstract class _RenderSliverFloatingPinnedPersistentHeader : RenderSliverFloatingPinnedPersistentHeader {
     }
 
-    class _RenderSliverFloatingPinnedPersistentHeaderForWidgets : RenderSliverFloatingPinnedPersistentHeader,
-        _RenderSliverPersistentHeaderForWidgetsMixin {
+    class _RenderSliverFloatingPinnedPersistentHeaderForWidgets : _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeaderRenderSliverFloatingPinnedPersistentHeader {
         public _RenderSliverFloatingPinnedPersistentHeaderForWidgets(
             RenderBox child = null,
             FloatingHeaderSnapConfiguration snapConfiguration = null,
     abstract class _RenderSliverFloatingPersistentHeader : RenderSliverFloatingPersistentHeader {
     }
 
-    class _RenderSliverFloatingPersistentHeaderForWidgets : RenderSliverFloatingPersistentHeader,
-        _RenderSliverPersistentHeaderForWidgetsMixin {
+    class _RenderSliverFloatingPersistentHeaderForWidgets : _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeaderRenderSliverFloatingPersistentHeader {
 
         public _RenderSliverFloatingPersistentHeaderForWidgets(
             RenderBox child = null,

com.unity.uiwidgets/Runtime/widgets/sliver_persistent_header.mixin.gen.cs

+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.rendering;
+
+namespace Unity.UIWidgets.widgets {
+
+    public abstract class _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeaderRenderSliverFloatingPersistentHeader : RenderSliverFloatingPersistentHeader, _RenderSliverPersistentHeaderForWidgetsMixin {
+         
+        public _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeaderRenderSliverFloatingPersistentHeader(
+            RenderBox child = null,
+            FloatingHeaderSnapConfiguration snapConfiguration = null,
+            OverScrollHeaderStretchConfiguration stretchConfiguration = null
+        ) : base(
+            child: child,
+            stretchConfiguration: stretchConfiguration) {
+            _snapConfiguration = snapConfiguration;
+        }
+
+         public _SliverPersistentHeaderElement _element { get; set; }
+         
+         float? minExtent {
+             get {
+                 return _element.widget.layoutDelegate.minExtent;
+             }
+         }
+ 
+         float? maxExtent {
+             get {
+                 return _element.widget.layoutDelegate.minExtent;
+             }
+         }
+ 
+         void updateChild(float shrinkOffset, bool overlapsContent) {
+             D.assert(_element != null);
+             _element._build(shrinkOffset, overlapsContent);
+         }
+ 
+        void _RenderSliverPersistentHeaderForWidgetsMixin.triggerRebuild() {
+            triggerRebuild();
+        }
+
+        void _RenderSliverPersistentHeaderForWidgetsMixin.updateChild(float shrinkOffset, bool overlapsContent) {
+            updateChild(shrinkOffset, overlapsContent);
+        }
+        
+        void triggerRebuild() {
+            markNeedsLayout();
+        }
+        
+        protected override void performLayout() {
+        }
+    }
+
+    public abstract class _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeaderRenderSliverFloatingPinnedPersistentHeader : RenderSliverFloatingPinnedPersistentHeader, _RenderSliverPersistentHeaderForWidgetsMixin {
+         
+        public _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeaderRenderSliverFloatingPinnedPersistentHeader(
+            RenderBox child = null,
+            FloatingHeaderSnapConfiguration snapConfiguration = null,
+            OverScrollHeaderStretchConfiguration stretchConfiguration = null
+        ) : base(child: child,
+            snapConfiguration: snapConfiguration,
+            stretchConfiguration: stretchConfiguration) {
+        }
+         public _SliverPersistentHeaderElement _element { get; set; }
+         
+         float? minExtent {
+             get {
+                 return _element.widget.layoutDelegate.minExtent;
+             }
+         }
+ 
+         float? maxExtent {
+             get {
+                 return _element.widget.layoutDelegate.minExtent;
+             }
+         }
+ 
+         void updateChild(float shrinkOffset, bool overlapsContent) {
+             D.assert(_element != null);
+             _element._build(shrinkOffset, overlapsContent);
+         }
+ 
+        void _RenderSliverPersistentHeaderForWidgetsMixin.triggerRebuild() {
+            triggerRebuild();
+        }
+
+        void _RenderSliverPersistentHeaderForWidgetsMixin.updateChild(float shrinkOffset, bool overlapsContent) {
+            updateChild(shrinkOffset, overlapsContent);
+        }
+        
+        void triggerRebuild() {
+            markNeedsLayout();
+        }
+        
+        protected override void performLayout() {
+        }
+    }
+
+    public abstract class _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeaderRenderSliverPinnedPersistentHeader : RenderSliverPinnedPersistentHeader, _RenderSliverPersistentHeaderForWidgetsMixin {
+         
+        
+        public _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeaderRenderSliverPinnedPersistentHeader(
+            RenderBox child = null,
+            OverScrollHeaderStretchConfiguration stretchConfiguration = null
+        ) : base(child: child,
+            stretchConfiguration: stretchConfiguration) {
+        }
+         public _SliverPersistentHeaderElement _element { get; set; }
+         
+         float? minExtent {
+             get {
+                 return _element.widget.layoutDelegate.minExtent;
+             }
+         }
+ 
+         float? maxExtent {
+             get {
+                 return _element.widget.layoutDelegate.minExtent;
+             }
+         }
+ 
+         void updateChild(float shrinkOffset, bool overlapsContent) {
+             D.assert(_element != null);
+             _element._build(shrinkOffset, overlapsContent);
+         }
+ 
+        void _RenderSliverPersistentHeaderForWidgetsMixin.triggerRebuild() {
+            triggerRebuild();
+        }
+
+        void _RenderSliverPersistentHeaderForWidgetsMixin.updateChild(float shrinkOffset, bool overlapsContent) {
+            updateChild(shrinkOffset, overlapsContent);
+        }
+        
+        void triggerRebuild() {
+            markNeedsLayout();
+        }
+        
+        protected override void performLayout() {
+        }
+    }
+
+    public abstract class _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeaderRenderSliverScrollingPersistentHeader : RenderSliverScrollingPersistentHeader, _RenderSliverPersistentHeaderForWidgetsMixin {
+         
+         public _SliverPersistentHeaderElement _element { get; set; }
+         
+         float? minExtent {
+             get {
+                 return _element.widget.layoutDelegate.minExtent;
+             }
+         }
+ 
+         float? maxExtent {
+             get {
+                 return _element.widget.layoutDelegate.minExtent;
+             }
+         }
+ 
+         void updateChild(float shrinkOffset, bool overlapsContent) {
+             D.assert(_element != null);
+             _element._build(shrinkOffset, overlapsContent);
+         }
+ 
+        void _RenderSliverPersistentHeaderForWidgetsMixin.triggerRebuild() {
+            triggerRebuild();
+        }
+
+        void _RenderSliverPersistentHeaderForWidgetsMixin.updateChild(float shrinkOffset, bool overlapsContent) {
+            updateChild(shrinkOffset, overlapsContent);
+        }
+        
+        void triggerRebuild() {
+            markNeedsLayout();
+        }
+        
+        protected override void performLayout() {
+        }
+    }
+
+
+}

com.unity.uiwidgets/Runtime/widgets/sliver_persistent_header.mixin.njk

+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.rendering;
+
+namespace Unity.UIWidgets.widgets {
+{% macro _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeader(with) %}
+    public abstract class _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeader{{with}} : {{with}}, _RenderSliverPersistentHeaderForWidgetsMixin {
+         
+         public _SliverPersistentHeaderElement _element { get; set; }
+         
+         float? minExtent {
+             get {
+                 return _element.widget.layoutDelegate.minExtent;
+             }
+         }
+ 
+         float? maxExtent {
+             get {
+                 return _element.widget.layoutDelegate.minExtent;
+             }
+         }
+ 
+         void updateChild(float shrinkOffset, bool overlapsContent) {
+             D.assert(_element != null);
+             _element._build(shrinkOffset, overlapsContent);
+         }
+ 
+        void _RenderSliverPersistentHeaderForWidgetsMixin.triggerRebuild() {
+            triggerRebuild();
+        }
+
+        void _RenderSliverPersistentHeaderForWidgetsMixin.updateChild(float shrinkOffset, bool overlapsContent) {
+            updateChild(shrinkOffset, overlapsContent);
+        }
+        
+        void triggerRebuild() {
+            markNeedsLayout();
+        }
+        
+        protected override void performLayout() {
+        }
+    }
+{% endmacro %}
+
+{{ _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeader('RenderSliverFloatingPersistentHeader') }}
+{{ _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeader('RenderSliverFloatingPinnedPersistentHeader') }}
+{{ _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeader('RenderSliverPinnedPersistentHeader') }}
+{{ _RenderSliverPersistentHeaderForWidgetsMixinOnRenderSliverPersistentHeader('RenderSliverScrollingPersistentHeader') }}
+
+}