// This file is generated. Do not modify by hand.
// XML documentation file not found. To check if public methods have XML comments,
// make sure the XML doc file is present and located next to the scraped dll
namespace UnityEngine.Splines
{
    public struct BezierCurve : System.IEquatable<BezierCurve>
    {
        public Unity.Mathematics.float3 P0;
        public Unity.Mathematics.float3 P1;
        public Unity.Mathematics.float3 P2;
        public Unity.Mathematics.float3 P3;
        public Unity.Mathematics.float3 Tangent0 { get; set; }
        public Unity.Mathematics.float3 Tangent1 { get; set; }
        public BezierCurve(Unity.Mathematics.float3 p0, Unity.Mathematics.float3 p1) {}
        public BezierCurve(BezierKnot a, BezierKnot b) {}
        public BezierCurve(Unity.Mathematics.float3 p0, Unity.Mathematics.float3 p1, Unity.Mathematics.float3 p2) {}
        public BezierCurve(Unity.Mathematics.float3 p0, Unity.Mathematics.float3 p1, Unity.Mathematics.float3 p2, Unity.Mathematics.float3 p3) {}
        public override bool Equals(object obj);
        public bool Equals(BezierCurve other);
        public static BezierCurve FromTangent(Unity.Mathematics.float3 pointA, Unity.Mathematics.float3 tangentOutA, Unity.Mathematics.float3 pointB, Unity.Mathematics.float3 tangentInB);
        public override int GetHashCode();
        public BezierCurve GetInvertedCurve();
        public static bool operator ==(BezierCurve left, BezierCurve right);
        public static bool operator !=(BezierCurve left, BezierCurve right);
        public BezierCurve Transform(Unity.Mathematics.float4x4 matrix);
    }

    public struct BezierKnot : ISerializationCallbackReceiver, System.IEquatable<BezierKnot>
    {
        public Unity.Mathematics.float3 Position;
        public Unity.Mathematics.quaternion Rotation;
        public Unity.Mathematics.float3 TangentIn;
        public Unity.Mathematics.float3 TangentOut;
        public BezierKnot(Unity.Mathematics.float3 position) {}
        public BezierKnot(Unity.Mathematics.float3 position, Unity.Mathematics.float3 tangentIn, Unity.Mathematics.float3 tangentOut) {}
        public BezierKnot(Unity.Mathematics.float3 position, Unity.Mathematics.float3 tangentIn, Unity.Mathematics.float3 tangentOut, Unity.Mathematics.quaternion rotation) {}
        public override bool Equals(object obj);
        public bool Equals(BezierKnot other);
        public override int GetHashCode();
        public void OnAfterDeserialize();
        public void OnBeforeSerialize();
        public static BezierKnot operator +(BezierKnot knot, Unity.Mathematics.float3 rhs);
        public static BezierKnot operator -(BezierKnot knot, Unity.Mathematics.float3 rhs);
        public override string ToString();
        public BezierKnot Transform(Unity.Mathematics.float4x4 matrix);
    }

    public enum BezierTangent
    {
        In = 0,
        Out = 1,
    }

    public static class CurveUtility
    {
        public static float ApproximateLength(BezierCurve curve);
        public static void CalculateCurveLengths(BezierCurve curve, DistanceToInterpolation[] lookupTable);
        public static float CalculateLength(BezierCurve curve, int resolution = 30);
        public static Unity.Mathematics.float3 EvaluateAcceleration(BezierCurve curve, float t);
        public static float EvaluateCurvature(BezierCurve curve, float t);
        public static Unity.Mathematics.float3 EvaluatePosition(BezierCurve curve, float t);
        public static Unity.Mathematics.float3 EvaluateTangent(BezierCurve curve, float t);
        public static float GetDistanceToInterpolation<T>(T lut, float distance) where T : System.Collections.Generic.IReadOnlyList<DistanceToInterpolation>;
        public static float GetDistanceToInterpolation(BezierCurve curve, float distance);
        public static Unity.Mathematics.float3 GetNearestPoint(BezierCurve curve, Ray ray, int resolution = 16);
        public static float GetNearestPoint(BezierCurve curve, Ray ray, out Unity.Mathematics.float3 position, out float interpolation, int resolution = 16);
        public static void Split(BezierCurve curve, float t, out BezierCurve left, out BezierCurve right);
    }

    public struct DataPoint<TDataType> : IDataPoint, System.IComparable<float>, System.IComparable<UnityEngine.Splines.DataPoint<TDataType>>
    {
        public float Index { get; set; }
        public TDataType Value { get; set; }
        public DataPoint(float index, TDataType value) {}
        public int CompareTo(float other);
        public int CompareTo(UnityEngine.Splines.DataPoint<TDataType> other);
        public override string ToString();
    }

    public struct DistanceToInterpolation
    {
        public float Distance;
        public float T;
    }

    public class EmbeddedSplineData
    {
        public SplineContainer Container { get; set; }
        public string Key { get; set; }
        public int SplineIndex { get; set; }
        public EmbeddedSplineDataType Type { get; set; }
        public EmbeddedSplineData() {}
        public EmbeddedSplineData(string key, EmbeddedSplineDataType type, SplineContainer container = default(SplineContainer), int splineIndex = 0) {}
        public UnityEngine.Splines.SplineData<Unity.Mathematics.float4> GetOrCreateFloat4Data();
        public UnityEngine.Splines.SplineData<float> GetOrCreateFloatData();
        public UnityEngine.Splines.SplineData<int> GetOrCreateIntData();
        public UnityEngine.Splines.SplineData<UnityEngine.Object> GetOrCreateObjectData();
        public bool TryGetFloat4Data(out UnityEngine.Splines.SplineData<Unity.Mathematics.float4> data);
        public bool TryGetFloatData(out UnityEngine.Splines.SplineData<float> data);
        public bool TryGetIntData(out UnityEngine.Splines.SplineData<int> data);
        public bool TryGetObjectData(out UnityEngine.Splines.SplineData<UnityEngine.Object> data);
        public bool TryGetSpline(out Spline spline);
    }

    [System.Flags] public enum EmbeddedSplineDataField
    {
        All = 255,
        Container = 1,
        Key = 4,
        SplineIndex = 2,
        Type = 8,
    }

    public class EmbeddedSplineDataFieldsAttribute : PropertyAttribute
    {
        public readonly EmbeddedSplineDataField Fields;
        public EmbeddedSplineDataFieldsAttribute(EmbeddedSplineDataField fields) {}
    }

    public enum EmbeddedSplineDataType
    {
        Float = 1,
        Float4 = 2,
        Int = 0,
        Object = 3,
    }

    public struct GetPosition : Unity.Jobs.IJobParallelFor
    {
        [Unity.Collections.WriteOnly] public Unity.Collections.NativeArray<Unity.Mathematics.float3> Positions;
        [Unity.Collections.ReadOnly] public NativeSpline Spline;
        public void Execute(int index);
    }

    public struct GetPositionTangentNormal : Unity.Jobs.IJobParallelFor
    {
        [Unity.Collections.WriteOnly] public Unity.Collections.NativeArray<Unity.Mathematics.float3> Normals;
        [Unity.Collections.WriteOnly] public Unity.Collections.NativeArray<Unity.Mathematics.float3> Positions;
        [Unity.Collections.ReadOnly] public NativeSpline Spline;
        [Unity.Collections.WriteOnly] public Unity.Collections.NativeArray<Unity.Mathematics.float3> Tangents;
        public void Execute(int index);
    }

    public interface IDataPoint
    {
        public float Index { get; set; }
    }

    public interface IHasEmptyCurves
    {
        public System.Collections.Generic.IReadOnlyList<int> EmptyCurves { get; }
    }

    public interface IInterpolator<T>
    {
        public T Interpolate(T from, T to, float t);
    }

    public static class InterpolatorUtility
    {
        public static UnityEngine.Splines.IInterpolator<Color> LerpColor { get; }
        public static UnityEngine.Splines.IInterpolator<float> LerpFloat { get; }
        public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2> LerpFloat2 { get; }
        public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3> LerpFloat3 { get; }
        public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float4> LerpFloat4 { get; }
        public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.quaternion> LerpQuaternion { get; }
        public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2> SlerpFloat2 { get; }
        public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3> SlerpFloat3 { get; }
        public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.quaternion> SlerpQuaternion { get; }
        public static UnityEngine.Splines.IInterpolator<float> SmoothStepFloat { get; }
        public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2> SmoothStepFloat2 { get; }
        public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3> SmoothStepFloat3 { get; }
        public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float4> SmoothStepFloat4 { get; }
    }

    public interface ISpline : System.Collections.Generic.IEnumerable<BezierKnot>, System.Collections.Generic.IReadOnlyCollection<BezierKnot>, System.Collections.Generic.IReadOnlyList<BezierKnot>, System.Collections.IEnumerable
    {
        public bool Closed { get; }
        public BezierCurve GetCurve(int index);
        public float GetCurveInterpolation(int curveIndex, float curveDistance);
        public float GetCurveLength(int index);
        public float GetLength();
    }

    public interface ISplineContainer
    {
        public KnotLinkCollection KnotLinkCollection { get; }
        public System.Collections.Generic.IReadOnlyList<Spline> Splines { get; set; }
    }

    [System.Obsolete(@"Use ISplineContainer instead.")] public interface ISplineProvider
    {
        public System.Collections.Generic.IEnumerable<Spline> Splines { get; }
    }

    public sealed class KnotLinkCollection
    {
        public int Count { get; }
        public KnotLinkCollection() {}
        public void Clear();
        public System.Collections.Generic.IReadOnlyList<SplineKnotIndex> GetKnotLinks(SplineKnotIndex knotIndex);
        public void KnotIndexChanged(SplineKnotIndex previousIndex, SplineKnotIndex newIndex);
        public void KnotIndexChanged(int splineIndex, int previousKnotIndex, int newKnotIndex);
        public void KnotInserted(SplineKnotIndex index);
        public void KnotInserted(int splineIndex, int knotIndex);
        public void KnotRemoved(SplineKnotIndex index);
        public void KnotRemoved(int splineIndex, int knotIndex);
        public void Link(SplineKnotIndex knotA, SplineKnotIndex knotB);
        public void ShiftKnotIndices(SplineKnotIndex index, int offset);
        public void SplineIndexChanged(int previousIndex, int newIndex);
        public void SplineRemoved(int splineIndex);
        public bool TryGetKnotLinks(SplineKnotIndex knotIndex, out System.Collections.Generic.IReadOnlyList<SplineKnotIndex> linkedKnots);
        public void Unlink(SplineKnotIndex knot);
    }

    public struct NativeSpline : ISpline, System.Collections.Generic.IEnumerable<BezierKnot>, System.Collections.Generic.IReadOnlyCollection<BezierKnot>, System.Collections.Generic.IReadOnlyList<BezierKnot>, System.Collections.IEnumerable, System.IDisposable
    {
        public bool Closed { get; }
        public int Count { get; }
        public Unity.Collections.NativeArray<BezierCurve> Curves { get; }
        public BezierKnot this[int index] { get; }
        public Unity.Collections.NativeArray<BezierKnot> Knots { get; }
        public NativeSpline(ISpline spline, Unity.Collections.Allocator allocator = Unity.Collections.Allocator.Temp) {}
        public NativeSpline(ISpline spline, Unity.Mathematics.float4x4 transform, Unity.Collections.Allocator allocator = Unity.Collections.Allocator.Temp) {}
        public NativeSpline(System.Collections.Generic.IReadOnlyList<BezierKnot> knots, bool closed, Unity.Mathematics.float4x4 transform, Unity.Collections.Allocator allocator = Unity.Collections.Allocator.Temp) {}
        public NativeSpline(System.Collections.Generic.IReadOnlyList<BezierKnot> knots, System.Collections.Generic.IReadOnlyList<int> splits, bool closed, Unity.Mathematics.float4x4 transform, Unity.Collections.Allocator allocator = Unity.Collections.Allocator.Temp) {}
        public void Dispose();
        public BezierCurve GetCurve(int index);
        public float GetCurveInterpolation(int curveIndex, float curveDistance);
        public float GetCurveLength(int curveIndex);
        public System.Collections.Generic.IEnumerator<BezierKnot> GetEnumerator();
        public float GetLength();
    }

    public enum PathIndexUnit
    {
        Distance = 0,
        Knot = 2,
        Normalized = 1,
    }

    public enum SliceDirection
    {
        Backward = 1,
        Forward = 0,
    }

    public class Spline : ISpline, System.Collections.Generic.ICollection<BezierKnot>, System.Collections.Generic.IEnumerable<BezierKnot>, System.Collections.Generic.IList<BezierKnot>, System.Collections.Generic.IReadOnlyCollection<BezierKnot>, System.Collections.Generic.IReadOnlyList<BezierKnot>, System.Collections.IEnumerable
    {
        [System.Obsolete(@"Deprecated, use Changed instead.")] public event System.Action changed;
        public static event System.Action<Spline, int, SplineModification> Changed;
        public bool Closed { get; set; }
        public int Count { get; }
        [System.Obsolete(@"Use GetTangentMode and SetTangentMode.")] public SplineType EditType { get; set; }
        public bool IsReadOnly { get; }
        public BezierKnot this[int index] { get; set; }
        public System.Collections.Generic.IEnumerable<BezierKnot> Knots { get; set; }
        public Spline() {}
        public Spline(Spline spline) {}
        public Spline(System.Collections.Generic.IEnumerable<BezierKnot> knots, bool closed = false) {}
        public Spline(int knotCapacity, bool closed = false) {}
        public void Add(BezierKnot item);
        public void Add(BezierKnot item, TangentMode mode);
        public void Add(BezierKnot item, TangentMode mode, float tension);
        public void Clear();
        public bool Contains(BezierKnot item);
        public void Copy(Spline copyFrom);
        public void CopyTo(BezierKnot[] array, int arrayIndex);
        public void EnforceTangentModeNoNotify(int index);
        public void EnforceTangentModeNoNotify(SplineRange range);
        public float GetAutoSmoothTension(int index);
        public BezierCurve GetCurve(int index);
        public float GetCurveInterpolation(int curveIndex, float curveDistance);
        public float GetCurveLength(int index);
        public System.Collections.Generic.IEnumerator<BezierKnot> GetEnumerator();
        public System.Collections.Generic.IEnumerable<string> GetFloat4DataKeys();
        public System.Collections.Generic.IEnumerable<UnityEngine.Splines.SplineData<Unity.Mathematics.float4>> GetFloat4DataValues();
        public System.Collections.Generic.IEnumerable<string> GetFloatDataKeys();
        public System.Collections.Generic.IEnumerable<UnityEngine.Splines.SplineData<float>> GetFloatDataValues();
        public System.Collections.Generic.IEnumerable<string> GetIntDataKeys();
        public System.Collections.Generic.IEnumerable<UnityEngine.Splines.SplineData<int>> GetIntDataValues();
        public float GetLength();
        public System.Collections.Generic.IEnumerable<string> GetObjectDataKeys();
        public System.Collections.Generic.IEnumerable<UnityEngine.Splines.SplineData<UnityEngine.Object>> GetObjectDataValues();
        public UnityEngine.Splines.SplineData<Unity.Mathematics.float4> GetOrCreateFloat4Data(string key);
        public UnityEngine.Splines.SplineData<float> GetOrCreateFloatData(string key);
        public UnityEngine.Splines.SplineData<int> GetOrCreateIntData(string key);
        public UnityEngine.Splines.SplineData<UnityEngine.Object> GetOrCreateObjectData(string key);
        public System.Collections.Generic.IEnumerable<string> GetSplineDataKeys(EmbeddedSplineDataType type);
        public TangentMode GetTangentMode(int index);
        public int IndexOf(BezierKnot item);
        public void Insert(int index, BezierKnot knot);
        public void Insert(int index, BezierKnot knot, TangentMode mode);
        public void Insert(int index, BezierKnot knot, TangentMode mode, float tension);
        protected virtual void OnSplineChanged();
        public bool Remove(BezierKnot item);
        public void RemoveAt(int index);
        public bool RemoveFloat4Data(string key);
        public bool RemoveFloatData(string key);
        public bool RemoveIntData(string key);
        public bool RemoveObjectData(string key);
        public void Resize(int newSize);
        public void SetAutoSmoothTension(int index, float tension);
        public void SetAutoSmoothTension(SplineRange range, float tension);
        public void SetAutoSmoothTensionNoNotify(int index, float tension);
        public void SetAutoSmoothTensionNoNotify(SplineRange range, float tension);
        public void SetFloat4Data(string key, UnityEngine.Splines.SplineData<Unity.Mathematics.float4> value);
        public void SetFloatData(string key, UnityEngine.Splines.SplineData<float> value);
        public void SetIntData(string key, UnityEngine.Splines.SplineData<int> value);
        public void SetKnot(int index, BezierKnot value, BezierTangent main = BezierTangent.Out);
        public void SetKnotNoNotify(int index, BezierKnot value, BezierTangent main = BezierTangent.Out);
        public void SetObjectData(string key, UnityEngine.Splines.SplineData<UnityEngine.Object> value);
        public void SetTangentMode(TangentMode mode);
        public void SetTangentMode(int index, TangentMode mode, BezierTangent main = BezierTangent.Out);
        public void SetTangentMode(SplineRange range, TangentMode mode, BezierTangent main = BezierTangent.Out);
        public void SetTangentModeNoNotify(int index, TangentMode mode, BezierTangent main = BezierTangent.Out);
        public BezierKnot[] ToArray();
        public bool TryGetFloat4Data(string key, out UnityEngine.Splines.SplineData<Unity.Mathematics.float4> data);
        public bool TryGetFloatData(string key, out UnityEngine.Splines.SplineData<float> data);
        public bool TryGetIntData(string key, out UnityEngine.Splines.SplineData<int> data);
        public bool TryGetObjectData(string key, out UnityEngine.Splines.SplineData<UnityEngine.Object> data);
        public void Warmup();
    }

    [AddComponentMenu(@"Splines/Spline Animate")] public class SplineAnimate : SplineComponent
    {
        [System.Obsolete(@"Use Updated instead.", false)] public event System.Action<Vector3, Quaternion> onUpdated;
        public event System.Action<Vector3, Quaternion> Updated;
        public SplineAnimate.AlignmentMode Alignment { get; set; }
        [System.Obsolete(@"Use Alignment instead.", false)] public SplineAnimate.AlignmentMode alignmentMode { get; }
        public SplineAnimate.Method AnimationMethod { get; set; }
        public SplineContainer Container { get; set; }
        [System.Obsolete(@"Use Duration instead.", false)] public float duration { get; }
        public float Duration { get; set; }
        public SplineAnimate.EasingMode Easing { get; set; }
        [System.Obsolete(@"Use Easing instead.", false)] public SplineAnimate.EasingMode easingMode { get; }
        [System.Obsolete(@"Use ElapsedTime instead.", false)] public float elapsedTime { get; }
        public float ElapsedTime { get; set; }
        [System.Obsolete(@"Use IsPlaying instead.", false)] public bool isPlaying { get; }
        public bool IsPlaying { get; }
        public SplineAnimate.LoopMode Loop { get; set; }
        [System.Obsolete(@"Use Loop instead.", false)] public SplineAnimate.LoopMode loopMode { get; }
        [System.Obsolete(@"Use MaxSpeed instead.", false)] public float maxSpeed { get; }
        public float MaxSpeed { get; set; }
        [System.Obsolete(@"Use AnimationMethod instead.", false)] public SplineAnimate.Method method { get; }
        [System.Obsolete(@"Use NormalizedTime instead.", false)] public float normalizedTime { get; }
        public float NormalizedTime { get; set; }
        [System.Obsolete(@"Use ObjectForwardAxis instead.", false)] public SplineComponent.AlignAxis objectForwardAxis { get; }
        public SplineComponent.AlignAxis ObjectForwardAxis { get; set; }
        [System.Obsolete(@"Use ObjectUpAxis instead.", false)] public SplineComponent.AlignAxis objectUpAxis { get; }
        public SplineComponent.AlignAxis ObjectUpAxis { get; set; }
        [System.Obsolete(@"Use PlayOnAwake instead.", false)] public bool playOnAwake { get; }
        public bool PlayOnAwake { get; set; }
        [System.Obsolete(@"Use Container instead.", false)] public SplineContainer splineContainer { get; }
        public float StartOffset { get; set; }
        public SplineAnimate() {}
        public void Pause();
        public void Play();
        public void Restart(bool autoplay);
        public void Update();
        public enum AlignmentMode
        {
            [InspectorName(@"None")] None = 0,
            [InspectorName(@"Spline Element")] SplineElement = 1,
            [InspectorName(@"Spline Object")] SplineObject = 2,
            [InspectorName(@"World Space")] World = 3,
        }
        public enum EasingMode
        {
            [InspectorName(@"Ease In Only")] EaseIn = 1,
            [InspectorName(@"Ease In-Out")] EaseInOut = 3,
            [InspectorName(@"Ease Out Only")] EaseOut = 2,
            [InspectorName(@"None")] None = 0,
        }
        public enum LoopMode
        {
            [InspectorName(@"Loop Continuous")] Loop = 1,
            [InspectorName(@"Ease In Then Continuous")] LoopEaseInOnce = 2,
            [InspectorName(@"Once")] Once = 0,
            [InspectorName(@"Ping Pong")] PingPong = 3,
        }
        public enum Method
        {
            Speed = 1,
            Time = 0,
        }
    }

    public abstract class SplineComponent : MonoBehaviour
    {
        protected SplineComponent() {}
        protected Unity.Mathematics.float3 GetAxis(SplineComponent.AlignAxis axis);
        public enum AlignAxis
        {
            [InspectorName(@"Object X-")] NegativeXAxis = 3,
            [InspectorName(@"Object Y-")] NegativeYAxis = 4,
            [InspectorName(@"Object Z-")] NegativeZAxis = 5,
            [InspectorName(@"Object X+")] XAxis = 0,
            [InspectorName(@"Object Y+")] YAxis = 1,
            [InspectorName(@"Object Z+")] ZAxis = 2,
        }
    }

    public struct SplineComputeBufferScope<T> : System.IDisposable where T : ISpline
    {
        public ComputeBuffer CurveLengths { get; }
        public ComputeBuffer Curves { get; }
        public Vector4 Info { get; }
        public SplineComputeBufferScope(T spline) {}
        public void Bind(ComputeShader shader, int kernel, string info, string curves, string lengths);
        public void Dispose();
        public void Upload();
    }

    [AddComponentMenu(@"Splines/Spline")] [ExecuteInEditMode] [Icon(@"Packages/com.unity.splines/Editor/Resources/Icons/SplineComponent.png")] public sealed class SplineContainer : MonoBehaviour, ISerializationCallbackReceiver, ISplineContainer
    {
        public static event System.Action<SplineContainer, int> SplineAdded;
        public static event System.Action<SplineContainer, int> SplineRemoved;
        public static event System.Action<SplineContainer, int, int> SplineReordered;
        public Spline this[int index] { get; }
        public KnotLinkCollection KnotLinkCollection { get; }
        public Spline Spline { get; set; }
        public System.Collections.Generic.IReadOnlyList<Spline> Splines { get; set; }
        public SplineContainer() {}
        public float CalculateLength();
        public float CalculateLength(int splineIndex);
        public bool Evaluate(float t, out Unity.Mathematics.float3 position, out Unity.Mathematics.float3 tangent, out Unity.Mathematics.float3 upVector);
        public bool Evaluate(int splineIndex, float t, out Unity.Mathematics.float3 position, out Unity.Mathematics.float3 tangent, out Unity.Mathematics.float3 upVector);
        public bool Evaluate<T>(T spline, float t, out Unity.Mathematics.float3 position, out Unity.Mathematics.float3 tangent, out Unity.Mathematics.float3 upVector) where T : ISpline;
        public Unity.Mathematics.float3 EvaluateAcceleration(float t);
        public Unity.Mathematics.float3 EvaluateAcceleration(int splineIndex, float t);
        public Unity.Mathematics.float3 EvaluateAcceleration<T>(T spline, float t) where T : ISpline;
        public Unity.Mathematics.float3 EvaluatePosition(float t);
        public Unity.Mathematics.float3 EvaluatePosition(int splineIndex, float t);
        public Unity.Mathematics.float3 EvaluatePosition<T>(T spline, float t) where T : ISpline;
        public Unity.Mathematics.float3 EvaluateTangent(float t);
        public Unity.Mathematics.float3 EvaluateTangent(int splineIndex, float t);
        public Unity.Mathematics.float3 EvaluateTangent<T>(T spline, float t) where T : ISpline;
        public Unity.Mathematics.float3 EvaluateUpVector(float t);
        public Unity.Mathematics.float3 EvaluateUpVector(int splineIndex, float t);
        public Unity.Mathematics.float3 EvaluateUpVector<T>(T spline, float t) where T : ISpline;
        public void OnAfterDeserialize();
        public void OnBeforeSerialize();
    }

    public class SplineData<T> : System.Collections.Generic.IEnumerable<UnityEngine.Splines.DataPoint<T>>, System.Collections.IEnumerable
    {
        [System.Obsolete(@"Use Changed instead.", false)] public event System.Action changed;
        public event System.Action Changed;
        public int Count { get; }
        public T DefaultValue { get; set; }
        public System.Collections.Generic.IEnumerable<float> Indexes { get; }
        public UnityEngine.Splines.DataPoint<T> this[int index] { get; set; }
        public PathIndexUnit PathIndexUnit { get; set; }
        public SplineData() {}
        public SplineData(System.Collections.Generic.IEnumerable<UnityEngine.Splines.DataPoint<T>> dataPoints) {}
        public SplineData(T init) {}
        public int Add(UnityEngine.Splines.DataPoint<T> dataPoint);
        public void Add(float t, T data);
        public int AddDataPointWithDefaultValue(float t, bool useDefaultValue = false);
        public void Clear();
        public void ConvertPathUnit<TSplineType>(TSplineType spline, PathIndexUnit toUnit) where TSplineType : ISpline;
        public T Evaluate<TSpline, TInterpolator>(TSpline spline, float t, TInterpolator interpolator) where TSpline : ISpline where TInterpolator : UnityEngine.Splines.IInterpolator<T>;
        public T Evaluate<TSpline, TInterpolator>(TSpline spline, float t, PathIndexUnit indexUnit, TInterpolator interpolator) where TSpline : ISpline where TInterpolator : UnityEngine.Splines.IInterpolator<T>;
        public System.Collections.Generic.IEnumerator<UnityEngine.Splines.DataPoint<T>> GetEnumerator();
        public float GetNormalizedInterpolation<TSplineType>(TSplineType spline, float t) where TSplineType : ISpline;
        public int MoveDataPoint(int index, float newIndex);
        public void RemoveAt(int index);
        public bool RemoveDataPoint(float t);
        public void SetDataPoint(int index, UnityEngine.Splines.DataPoint<T> value);
        public void SetDataPointNoSort(int index, UnityEngine.Splines.DataPoint<T> value);
        public void SortIfNecessary();
    }

    [System.AttributeUsage(System.AttributeTargets.Field)] [System.Obsolete(@"Use SplineDataHandles.DataPointHandles instead and EditorTools to interact with SplineData.", false)] public abstract class SplineDataHandleAttribute : System.Attribute
    {
        protected SplineDataHandleAttribute() {}
    }

    [AddComponentMenu(@"Splines/Spline Extrude")] [RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))] public class SplineExtrude : MonoBehaviour
    {
        [System.Obsolete(@"Use Capped instead.", false)] public bool capped { get; }
        public bool Capped { get; set; }
        [System.Obsolete(@"Use Container instead.", false)] public SplineContainer container { get; }
        public SplineContainer Container { get; set; }
        [System.Obsolete(@"Use Radius instead.", false)] public float radius { get; }
        public float Radius { get; set; }
        [System.Obsolete(@"Use Range instead.", false)] public Vector2 range { get; }
        public Vector2 Range { get; set; }
        [System.Obsolete(@"Use RebuildFrequency instead.", false)] public int rebuildFrequency { get; }
        public int RebuildFrequency { get; set; }
        [System.Obsolete(@"Use RebuildOnSplineChange instead.", false)] public bool rebuildOnSplineChange { get; }
        public bool RebuildOnSplineChange { get; set; }
        [System.Obsolete(@"Use SegmentsPerUnit instead.", false)] public float segmentsPerUnit { get; }
        public float SegmentsPerUnit { get; set; }
        [System.Obsolete(@"Use Sides instead.", false)] public int sides { get; }
        public int Sides { get; set; }
        [System.Obsolete(@"Use Spline instead.", false)] public Spline spline { get; }
        public Spline Spline { get; }
        public System.Collections.Generic.IReadOnlyList<Spline> Splines { get; }
        public SplineExtrude() {}
        public void Rebuild();
    }

    public static class SplineFactory
    {
        public static Spline CreateCatmullRom(System.Collections.Generic.IList<Unity.Mathematics.float3> positions, bool closed = false);
        public static Spline CreateCircle(float radius);
        public static Spline CreateHelix(float radius, float height, int revolutions);
        public static Spline CreateLinear(System.Collections.Generic.IList<Unity.Mathematics.float3> positions, bool closed = false);
        public static Spline CreateLinear(System.Collections.Generic.IList<Unity.Mathematics.float3> positions, System.Collections.Generic.IList<Unity.Mathematics.quaternion> rotations, bool closed = false);
        public static Spline CreatePolygon(float edgeSize, int sides);
        public static Spline CreateRoundedCornerSquare(float size, float cornerRadius);
        public static Spline CreateRoundedSquare(float radius, float rounding);
        public static Spline CreateSquare(float size);
        public static Spline CreateStarPolygon(float edgeSize, int corners, float concavity);
    }

    public class SplineIndexAttribute : PropertyAttribute
    {
        public readonly string SplineContainerProperty;
        public SplineIndexAttribute(string splineContainerProperty) {}
    }

    public struct SplineInfo : ISerializationCallbackReceiver, System.IEquatable<SplineInfo>
    {
        public ISplineContainer Container { get; set; }
        public int Index { get; set; }
        public Unity.Mathematics.float4x4 LocalToWorld { get; }
        public UnityEngine.Object Object { get; }
        public Spline Spline { get; }
        public Transform Transform { get; }
        public SplineInfo(ISplineContainer container, int index) {}
        public override bool Equals(object obj);
        public bool Equals(SplineInfo other);
        public override int GetHashCode();
        public void OnAfterDeserialize();
        public void OnBeforeSerialize();
    }

    [AddComponentMenu(@"Splines/Spline Instantiate")] [ExecuteInEditMode] public class SplineInstantiate : SplineComponent
    {
        [System.Obsolete(@"Use Container instead.", false)] public SplineContainer container { get; }
        public SplineContainer Container { get; set; }
        public SplineInstantiate.Space CoordinateSpace { get; set; }
        [System.Obsolete(@"Use ForwardAxis instead.", false)] public SplineComponent.AlignAxis forwardAxis { get; }
        public SplineComponent.AlignAxis ForwardAxis { get; set; }
        public SplineInstantiate.Method InstantiateMethod { get; set; }
        public SplineInstantiate.InstantiableItem[] itemsToInstantiate { get; set; }
        [System.Obsolete(@"Use MaxPositionOffset instead.", false)] public Vector3 maxPositionOffset { get; }
        public Vector3 MaxPositionOffset { get; set; }
        [System.Obsolete(@"Use MaxRotationOffset instead.", false)] public Vector3 maxRotationOffset { get; }
        public Vector3 MaxRotationOffset { get; set; }
        [System.Obsolete(@"Use MaxScaleOffset instead.", false)] public Vector3 maxScaleOffset { get; }
        public Vector3 MaxScaleOffset { get; set; }
        public float MaxSpacing { get; set; }
        [System.Obsolete(@"Use InstantiateMethod instead.", false)] public SplineInstantiate.Method method { get; }
        [System.Obsolete(@"Use MinPositionOffset instead.", false)] public Vector3 minPositionOffset { get; }
        public Vector3 MinPositionOffset { get; set; }
        [System.Obsolete(@"Use MinRotationOffset instead.", false)] public Vector3 minRotationOffset { get; }
        public Vector3 MinRotationOffset { get; set; }
        [System.Obsolete(@"Use MinScaleOffset instead.", false)] public Vector3 minScaleOffset { get; }
        public Vector3 MinScaleOffset { get; set; }
        public float MinSpacing { get; set; }
        [System.Obsolete(@"Use PositionSpace instead.", false)] public SplineInstantiate.OffsetSpace positionSpace { get; }
        public SplineInstantiate.OffsetSpace PositionSpace { get; set; }
        [System.Obsolete(@"Use RotationSpace instead.", false)] public SplineInstantiate.OffsetSpace rotationSpace { get; }
        public SplineInstantiate.OffsetSpace RotationSpace { get; set; }
        [System.Obsolete(@"Use ScaleSpace instead.", false)] public SplineInstantiate.OffsetSpace scaleSpace { get; }
        public SplineInstantiate.OffsetSpace ScaleSpace { get; set; }
        [System.Obsolete(@"Use CoordinateSpace instead.", false)] public SplineInstantiate.Space space { get; }
        [System.Obsolete(@"Use UpAxis instead.", false)] public SplineComponent.AlignAxis upAxis { get; }
        public SplineComponent.AlignAxis UpAxis { get; set; }
        public SplineInstantiate() {}
        public void Clear();
        public void Randomize();
        public void SetDirty();
        public void UpdateInstances();
        public struct InstantiableItem
        {
            [HideInInspector] [System.Obsolete(@"Use Prefab instead.", false)] public GameObject prefab;
            [UnityEngine.Serialization.FormerlySerializedAs(@"prefab")] public GameObject Prefab;
            [HideInInspector] [System.Obsolete(@"Use Probability instead.", false)] public float probability;
            [UnityEngine.Serialization.FormerlySerializedAs(@"probability")] public float Probability;
        }
        public enum Method
        {
            [InspectorName(@"Instance Count")] InstanceCount = 0,
            [InspectorName(@"Linear Distance")] LinearDistance = 2,
            [InspectorName(@"Spline Distance")] SpacingDistance = 1,
        }
        public enum OffsetSpace
        {
            [InspectorName(@"Spline Object")] Local = 1,
            [InspectorName(@"Instantiated Object")] Object = 3,
            [InspectorName(@"Spline Element")] Spline = 0,
            [InspectorName(@"World Space")] World = 2,
        }
        public enum Space
        {
            [InspectorName(@"Spline Object")] Local = 1,
            [InspectorName(@"Spline Element")] Spline = 0,
            [InspectorName(@"World Space")] World = 2,
        }
    }

    public static class SplineJobs
    {
        public static void EvaluatePosition<T>(T spline, Unity.Collections.NativeArray<Unity.Mathematics.float3> positions) where T : ISpline;
        public static void EvaluatePosition(NativeSpline spline, Unity.Collections.NativeArray<Unity.Mathematics.float3> positions);
        public static void EvaluatePositionTangentNormal<T>(T spline, Unity.Collections.NativeArray<Unity.Mathematics.float3> positions, Unity.Collections.NativeArray<Unity.Mathematics.float3> tangents, Unity.Collections.NativeArray<Unity.Mathematics.float3> normals) where T : ISpline;
        public static void EvaluatePositionTangentNormal(NativeSpline spline, Unity.Collections.NativeArray<Unity.Mathematics.float3> positions, Unity.Collections.NativeArray<Unity.Mathematics.float3> tangents, Unity.Collections.NativeArray<Unity.Mathematics.float3> normals);
    }

    public struct SplineKnotIndex : System.IEquatable<SplineKnotIndex>
    {
        public int Knot;
        public int Spline;
        public SplineKnotIndex(int spline, int knot) {}
        public override bool Equals(object obj);
        public bool Equals(SplineKnotIndex otherIndex);
        public override int GetHashCode();
        public static bool operator ==(SplineKnotIndex indexA, SplineKnotIndex indexB);
        public static bool operator !=(SplineKnotIndex indexA, SplineKnotIndex indexB);
        public override string ToString();
    }

    public static class SplineMath
    {
        public static float DistancePointLine(Unity.Mathematics.float3 p, Unity.Mathematics.float3 a, Unity.Mathematics.float3 b);
        public static Unity.Mathematics.float3 PointLineNearestPoint(Unity.Mathematics.float3 p, Unity.Mathematics.float3 a, Unity.Mathematics.float3 b, out float lineParam);
        public static Unity.Mathematics.float3 RayLineDistance(Unity.Mathematics.float3 ro, Unity.Mathematics.float3 rd, Unity.Mathematics.float3 a, Unity.Mathematics.float3 b);
        public static System.ValueTuple<Unity.Mathematics.float3, Unity.Mathematics.float3> RayLineNearestPoint(Unity.Mathematics.float3 ro, Unity.Mathematics.float3 rd, Unity.Mathematics.float3 a, Unity.Mathematics.float3 b);
        public static System.ValueTuple<Unity.Mathematics.float3, Unity.Mathematics.float3> RayLineNearestPoint(Unity.Mathematics.float3 ro, Unity.Mathematics.float3 rd, Unity.Mathematics.float3 a, Unity.Mathematics.float3 b, out float rayParam, out float lineParam);
        public static float RayLineParameter(Unity.Mathematics.float3 ro, Unity.Mathematics.float3 rd, Unity.Mathematics.float3 lineOrigin, Unity.Mathematics.float3 lineDir);
    }

    public static class SplineMesh
    {
        public static void Extrude<T>(T spline, Mesh mesh, float radius, int sides, int segments, bool capped = true) where T : ISpline;
        public static void Extrude<T>(System.Collections.Generic.IReadOnlyList<T> splines, Mesh mesh, float radius, int sides, float segmentsPerUnit, bool capped, Unity.Mathematics.float2 range) where T : ISpline;
        public static void Extrude<T>(T spline, Mesh mesh, float radius, int sides, int segments, bool capped, Unity.Mathematics.float2 range) where T : ISpline;
        public static void Extrude<TSplineType, TVertexType, TIndexType>(TSplineType spline, Unity.Collections.NativeArray<TVertexType> vertices, Unity.Collections.NativeArray<TIndexType> indices, float radius, int sides, int segments, bool capped, Unity.Mathematics.float2 range) where TSplineType : ISpline where TVertexType : struct, SplineMesh.ISplineVertexData, new() where TIndexType : struct, new();
        public static void GetVertexAndIndexCount(int sides, int segments, bool capped, bool closed, Vector2 range, out int vertexCount, out int indexCount);
        public interface ISplineVertexData
        {
            public Vector3 normal { get; set; }
            public Vector3 position { get; set; }
            public Vector2 texture { get; set; }
        }
    }

    public enum SplineModification
    {
        ClosedModified = 1,
        Default = 0,
        KnotInserted = 3,
        KnotModified = 2,
        KnotRemoved = 4,
        KnotReordered = 5,
    }

    public class SplinePath : UnityEngine.Splines.SplinePath<UnityEngine.Splines.SplineSlice<Spline>>
    {
        public SplinePath(System.Collections.Generic.IEnumerable<UnityEngine.Splines.SplineSlice<Spline>> slices) {}
    }

    public class SplinePath<T> : IHasEmptyCurves, ISpline, System.Collections.Generic.IEnumerable<BezierKnot>, System.Collections.Generic.IReadOnlyCollection<BezierKnot>, System.Collections.Generic.IReadOnlyList<BezierKnot>, System.Collections.IEnumerable where T : ISpline
    {
        public bool Closed { get; }
        public int Count { get; }
        public System.Collections.Generic.IReadOnlyList<int> EmptyCurves { get; }
        public BezierKnot this[int index] { get; }
        public BezierKnot this[SplineKnotIndex index] { get; }
        public System.Collections.Generic.IReadOnlyList<T> Slices { get; set; }
        public SplinePath(System.Collections.Generic.IEnumerable<T> slices) {}
        public BezierCurve GetCurve(int knot);
        public float GetCurveInterpolation(int curveIndex, float curveDistance);
        public float GetCurveLength(int index);
        public System.Collections.Generic.IEnumerator<BezierKnot> GetEnumerator();
        public float GetLength();
    }

    public struct SplineRange : System.Collections.Generic.IEnumerable<int>, System.Collections.IEnumerable
    {
        public int Count { get; set; }
        public SliceDirection Direction { get; set; }
        public int End { get; }
        public int this[int index] { get; }
        public int Start { get; set; }
        public SplineRange(int start, int count) {}
        public SplineRange(int start, int count, SliceDirection direction) {}
        public System.Collections.Generic.IEnumerator<int> GetEnumerator();
        public override string ToString();
        public struct SplineRangeEnumerator : System.Collections.Generic.IEnumerator<int>, System.Collections.IEnumerator, System.IDisposable
        {
            public int Current { get; }
            public SplineRangeEnumerator(SplineRange range) {}
            public void Dispose();
            public bool MoveNext();
            public void Reset();
        }
    }

    public struct SplineSlice<T> : ISpline, System.Collections.Generic.IEnumerable<BezierKnot>, System.Collections.Generic.IReadOnlyCollection<BezierKnot>, System.Collections.Generic.IReadOnlyList<BezierKnot>, System.Collections.IEnumerable where T : ISpline
    {
        public SplineRange Range;
        public T Spline;
        public Unity.Mathematics.float4x4 Transform;
        public bool Closed { get; }
        public int Count { get; }
        public BezierKnot this[int index] { get; }
        public SplineSlice(T spline, SplineRange range) {}
        public SplineSlice(T spline, SplineRange range, Unity.Mathematics.float4x4 transform) {}
        public BezierCurve GetCurve(int index);
        public float GetCurveInterpolation(int curveIndex, float curveDistance);
        public float GetCurveLength(int index);
        public System.Collections.Generic.IEnumerator<BezierKnot> GetEnumerator();
        public float GetLength();
    }

    [System.Obsolete(@"Replaced by GetTangentMode and SetTangentMode.")] public enum SplineType
    {
        Bezier = 1,
        CatmullRom = 0,
        Linear = 2,
    }

    public static class SplineUtility
    {
        public const float CatmullRomTension = 0.5f;
        public const float DefaultTension = 0.5f;
        public const int DrawResolutionDefault = 10;
        public const int PickResolutionDefault = 4;
        public const int PickResolutionMax = 64;
        public const int PickResolutionMin = 2;
        public static Spline AddSpline<T>(this T container) where T : ISplineContainer;
        public static void AddSpline<T>(this T container, Spline spline) where T : ISplineContainer;
        public static float CalculateLength<T>(this T spline, Unity.Mathematics.float4x4 transform) where T : ISpline;
        public static float ConvertIndexUnit<T>(this T spline, float t, PathIndexUnit targetPathUnit) where T : ISpline;
        public static float ConvertIndexUnit<T>(this T spline, float t, PathIndexUnit fromPathUnit, PathIndexUnit targetPathUnit) where T : ISpline;
        public static void CopyKnotLinks<T>(this T container, int srcSplineIndex, int destSplineIndex) where T : ISplineContainer;
        public static float CurveToSplineT<T>(this T spline, float curve) where T : ISpline;
        public static bool Evaluate<T>(this T spline, float t, out Unity.Mathematics.float3 position, out Unity.Mathematics.float3 tangent, out Unity.Mathematics.float3 upVector) where T : ISpline;
        public static Unity.Mathematics.float3 EvaluateAcceleration<T>(this T spline, float t) where T : ISpline;
        public static float EvaluateCurvature<T>(this T spline, float t) where T : ISpline;
        public static Unity.Mathematics.float3 EvaluateCurvatureCenter<T>(this T spline, float t) where T : ISpline;
        public static bool EvaluateNurbs(float t, System.Collections.Generic.List<Unity.Mathematics.float3> controlPoints, System.Collections.Generic.List<double> knotVector, int order, out Unity.Mathematics.float3 position);
        public static Unity.Mathematics.float3 EvaluatePosition<T>(this T spline, float t) where T : ISpline;
        public static Unity.Mathematics.float3 EvaluateTangent<T>(this T spline, float t) where T : ISpline;
        public static Unity.Mathematics.float3 EvaluateUpVector<T>(this T spline, float t) where T : ISpline;
        public static bool FitSplineToPoints(System.Collections.Generic.List<Unity.Mathematics.float3> points, float errorThreshold, bool closed, out Spline spline);
        public static BezierKnot GetAutoSmoothKnot(Unity.Mathematics.float3 position, Unity.Mathematics.float3 previous, Unity.Mathematics.float3 next);
        public static BezierKnot GetAutoSmoothKnot(Unity.Mathematics.float3 position, Unity.Mathematics.float3 previous, Unity.Mathematics.float3 next, Unity.Mathematics.float3 normal);
        public static BezierKnot GetAutoSmoothKnot(Unity.Mathematics.float3 position, Unity.Mathematics.float3 previous, Unity.Mathematics.float3 next, Unity.Mathematics.float3 normal, float tension = 0.5f);
        public static Unity.Mathematics.float3 GetAutoSmoothTangent(Unity.Mathematics.float3 previous, Unity.Mathematics.float3 next, float tension = 0.5f);
        public static Unity.Mathematics.float3 GetAutoSmoothTangent(Unity.Mathematics.float3 previous, Unity.Mathematics.float3 current, Unity.Mathematics.float3 next, float tension = 0.5f);
        public static Bounds GetBounds<T>(this T spline) where T : ISpline;
        public static Bounds GetBounds<T>(this T spline, Unity.Mathematics.float4x4 transform) where T : ISpline;
        public static Unity.Mathematics.float3 GetCatmullRomTangent(Unity.Mathematics.float3 previous, Unity.Mathematics.float3 next);
        public static int GetCurveCount<T>(this T spline) where T : ISpline;
        public static float GetNearestPoint<T>(T spline, Unity.Mathematics.float3 point, out Unity.Mathematics.float3 nearest, out float t, int resolution = 4, int iterations = 2) where T : ISpline;
        public static float GetNearestPoint<T>(T spline, Ray ray, out Unity.Mathematics.float3 nearest, out float t, int resolution = 4, int iterations = 2) where T : ISpline;
        public static float GetNormalizedInterpolation<T>(T spline, float t, PathIndexUnit originalPathUnit) where T : ISpline;
        public static Unity.Mathematics.float3 GetPointAtLinearDistance<T>(this T spline, float fromT, float relativeDistance, out float resultPointT) where T : ISpline;
        [System.Obsolete(@"Use GetSubdivisionCount instead.", false)] public static int GetSegmentCount(float length, int resolution);
        public static int GetSubdivisionCount(float length, int resolution);
        public static void LinkKnots<T>(this T container, SplineKnotIndex knotA, SplineKnotIndex knotB) where T : ISplineContainer;
        public static BezierKnot Next<T>(this T spline, int index) where T : ISpline;
        public static int NextIndex<T>(this T spline, int index) where T : ISpline;
        public static BezierKnot Previous<T>(this T spline, int index) where T : ISpline;
        public static int PreviousIndex<T>(this T spline, int index) where T : ISpline;
        public static System.Collections.Generic.List<Unity.Mathematics.float3> ReducePoints<T>(T line, float epsilon = 0.15f) where T : System.Collections.Generic.IList<Unity.Mathematics.float3>;
        public static void ReducePoints<T>(T line, System.Collections.Generic.List<Unity.Mathematics.float3> results, float epsilon = 0.15f) where T : System.Collections.Generic.IList<Unity.Mathematics.float3>;
        public static bool RemoveSpline<T>(this T container, Spline spline) where T : ISplineContainer;
        public static bool RemoveSplineAt<T>(this T container, int splineIndex) where T : ISplineContainer;
        public static bool ReorderSpline<T>(this T container, int previousSplineIndex, int newSplineIndex) where T : ISplineContainer;
        public static void SetLinkedKnotPosition<T>(this T container, SplineKnotIndex index) where T : ISplineContainer;
        public static void SetPivot(SplineContainer container, Vector3 position);
        public static int SplineToCurveT<T>(this T spline, float splineT, out float curveT) where T : ISpline;
        public static void UnlinkKnots<T>(this T container, System.Collections.Generic.IReadOnlyList<SplineKnotIndex> knots) where T : ISplineContainer;
    }

    public enum TangentMode
    {
        AutoSmooth = 0,
        Broken = 4,
        Continuous = 3,
        Linear = 1,
        Mirrored = 2,
    }
}

namespace UnityEngine.Splines.Interpolators
{
    public struct LerpColor : UnityEngine.Splines.IInterpolator<Color>
    {
        public Color Interpolate(Color a, Color b, float t);
    }

    public struct LerpFloat : UnityEngine.Splines.IInterpolator<float>
    {
        public float Interpolate(float a, float b, float t);
    }

    public struct LerpFloat2 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2>
    {
        public Unity.Mathematics.float2 Interpolate(Unity.Mathematics.float2 a, Unity.Mathematics.float2 b, float t);
    }

    public struct LerpFloat3 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3>
    {
        public Unity.Mathematics.float3 Interpolate(Unity.Mathematics.float3 a, Unity.Mathematics.float3 b, float t);
    }

    public struct LerpFloat4 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float4>
    {
        public Unity.Mathematics.float4 Interpolate(Unity.Mathematics.float4 a, Unity.Mathematics.float4 b, float t);
    }

    public struct LerpQuaternion : UnityEngine.Splines.IInterpolator<Unity.Mathematics.quaternion>
    {
        public Unity.Mathematics.quaternion Interpolate(Unity.Mathematics.quaternion a, Unity.Mathematics.quaternion b, float t);
    }

    public struct SlerpFloat2 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2>
    {
        public Unity.Mathematics.float2 Interpolate(Unity.Mathematics.float2 a, Unity.Mathematics.float2 b, float t);
    }

    public struct SlerpFloat3 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3>
    {
        public Unity.Mathematics.float3 Interpolate(Unity.Mathematics.float3 a, Unity.Mathematics.float3 b, float t);
    }

    public struct SlerpQuaternion : UnityEngine.Splines.IInterpolator<Unity.Mathematics.quaternion>
    {
        public Unity.Mathematics.quaternion Interpolate(Unity.Mathematics.quaternion a, Unity.Mathematics.quaternion b, float t);
    }

    public struct SmoothStepFloat : UnityEngine.Splines.IInterpolator<float>
    {
        public float Interpolate(float a, float b, float t);
    }

    public struct SmoothStepFloat2 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2>
    {
        public Unity.Mathematics.float2 Interpolate(Unity.Mathematics.float2 a, Unity.Mathematics.float2 b, float t);
    }

    public struct SmoothStepFloat3 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3>
    {
        public Unity.Mathematics.float3 Interpolate(Unity.Mathematics.float3 a, Unity.Mathematics.float3 b, float t);
    }

    public struct SmoothStepFloat4 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float4>
    {
        public Unity.Mathematics.float4 Interpolate(Unity.Mathematics.float4 a, Unity.Mathematics.float4 b, float t);
    }
}