Zemax OpticStudio ZOS-API 2026 R1

File InterfacesLDE.cs

Last update: 13.03.2026

Classes

Namespaces

Source

using System;
using System.Runtime.InteropServices;
using ZOSAPI.Analysis;
using ZOSAPI.Common;
using ZOSAPI.SystemData;

namespace ZOSAPI.Editors.LDE
{
    [ComVisible(true)]
    [Guid("CEA86773-3392-4A5A-9E30-3D81C31E079A")]
    public enum SurfaceType
    {
        ABCD,
        AlternateEven,
        AlternateOdd,
        AnnularZernikeSag,
        Atmospheric,

        Biconic,
        BiconicZernike,
        Binary1,
        Binary2,
        Binary3,
        Binary4,
        BirefringentIn,
        BirefringentOut,
        BlackBoxLens,

        ChebyShv,
        Conjugate,
        CoordinateBreak,
        CubicSpline,
        CylinderFrensel,
        CylinderFresnel = CylinderFrensel,

        Data,
        DiffractionGrating,

        EllipticalGrating1,
        EllipticalGrating2,
        EvenAspheric,
        ExtendedToroidalGrating,
        ExtendedAsphere,
        ExtendedCubicSpline,
        ExtendedFresnel,
        ExtendedOddAsphere,
        ExtendedPolynomial,

        Fresnel,

        GeneralizedFresnel,
        Gradient1,
        Gradient2,
        Gradient3,
        Gradient4,
        Gradient5,
        Gradient6,
        Gradient7,
        // Gradient8,
        Gradient9,
        Gradient10,
        Gradient12,
        Gradium,
        GridGradient,
        GridPhase,
        GridSag,

        Hologram1,
        Hologram2,

        Irregular,

        JonesMatrix,

        NonSequential,

        OddAsphere,
        OddCosine,
        OffAxisConicFreeform,
        OpticallyFabricatedHologram,

        Paraxial,
        ParaxialXY,
        Periodic,
        Polynomial,

        QTypeAsphere,
        QTypeFreeform,

        RadialGrating,
        RadialNurbs,
        RetroReflect,

        SlideSurface,
        Standard,
        Superconic,

        Tilted,
        Toroidal,
        ToroidalGrat,
        ToroidalHologram,
        ToroidalNurbs,

        UserDefined,

        VariableLineSpaceGrating,

        ZernikeAnnularPhase,
        ZernikeFringePhase,
        ZernikeFringeSag,
        ZernikeStandardPhase,
        ZernikeStandardSag,
        ZonePlate,

        Freeform,

        MuellerMatrix,
    }

    [ComVisible(true)]
    [Guid("B85D7667-1422-4122-9C35-7C3EC76C11FF")]
    public enum SurfaceColumn
    {
        Comment = 1,
        Radius,
        Thickness,
        Material,
        Coating,
        SemiDiameter,
        ChipZone,
        MechanicalSemiDiameter,
        Conic,
        TCE,
        Par0,
        Par1, Par2, Par3, Par4, Par5, Par6, Par7, Par8, Par9, Par10,
        Par11, Par12, Par13, Par14, Par15, Par16, Par17, Par18, Par19, Par20,
        Par21, Par22, Par23, Par24, Par25, Par26, Par27, Par28, Par29, Par30,
        Par31, Par32, Par33, Par34, Par35, Par36, Par37, Par38, Par39, Par40,
        Par41, Par42, Par43, Par44, Par45, Par46, Par47, Par48, Par49, Par50,
        Par51, Par52, Par53, Par54, Par55, Par56, Par57, Par58, Par59, Par60,
        Par61, Par62, Par63, Par64, Par65, Par66, Par67, Par68, Par69, Par70,
        Par71, Par72, Par73, Par74, Par75, Par76, Par77, Par78, Par79, Par80,
        Par81, Par82, Par83, Par84, Par85, Par86, Par87, Par88, Par89, Par90,
        Par91, Par92, Par93, Par94, Par95, Par96, Par97, Par98, Par99, Par100,
        Par101, Par102, Par103, Par104, Par105, Par106, Par107, Par108, Par109, Par110,
        Par111, Par112, Par113, Par114, Par115, Par116, Par117, Par118, Par119, Par120,
        Par121, Par122, Par123, Par124, Par125, Par126, Par127, Par128, Par129, Par130,
        Par131, Par132, Par133, Par134, Par135, Par136, Par137, Par138, Par139, Par140,
        Par141, Par142, Par143, Par144, Par145, Par146, Par147, Par148, Par149, Par150,
        Par151, Par152, Par153, Par154, Par155, Par156, Par157, Par158, Par159, Par160,
        Par161, Par162, Par163, Par164, Par165, Par166, Par167, Par168, Par169, Par170,
        Par171, Par172, Par173, Par174, Par175, Par176, Par177, Par178, Par179, Par180,
        Par181, Par182, Par183, Par184, Par185, Par186, Par187, Par188, Par189, Par190,
        Par191, Par192, Par193, Par194, Par195, Par196, Par197, Par198, Par199, Par200,
        Par201, Par202, Par203, Par204, Par205, Par206, Par207, Par208, Par209, Par210,
        Par211, Par212, Par213, Par214, Par215, Par216, Par217, Par218, Par219, Par220,
        Par221, Par222, Par223, Par224, Par225, Par226, Par227, Par228, Par229, Par230,
        Par231, Par232, Par233, Par234, Par235, Par236, Par237, Par238, Par239, Par240,
        Par241, Par242, Par243, Par244, Par245, Par246, Par247, Par248, Par249, Par250,
        Par251, Par252, Par253, Par254
    }

    [ComVisible(true)]
    [Guid("75A23D3D-CC56-430F-B3FA-84073D4E3822")]
    public enum ConversionOrder
    {
        Forward = 0,
        Reverse
    }

    [ComVisible(true)]
    [Guid("2651D8D5-CD53-4EEE-B03C-A2051A20B778")]
    public enum InterpolationMethod
    {
        BicubicSpline = 0,
        Linear
    }

    [ComVisible(true)]
    [Guid("FAA54FDE-F41F-4C4B-99CA-2FF43D778CCE")]
    public enum QTypes
    {
        Qbfs = 0,
        Qcon
    }

    [ComVisible(true)]
    [Guid("E1D4FA0D-9D36-4C02-BB95-A72E8A6D5B58")]
    public enum CoordinateConversionResult
    {
        Success = 0,
        Error_InvalidRange = -1,
        Error_CoordianteBreak = -2,
        Error_IgnoredSurface = -3,
        Error_TiltDecenter = -4,
        Error_MultiConfig = -5
    }

    [ComVisible(true)]
    [Guid("7C31B4A2-6DDE-426B-ACD1-6CA9D9403CD4")]
    public enum PupilApodizationType
    {
        None = 0,
        Gaussian,
        Tangential,
    }

    [ComVisible(true)]
    [Guid("8CCCA417-229F-4355-B055-445CB4B86D72")]
    public enum TiltType
    {
        XTilt = 0,
        YTilt = 1,
    }

    [ComVisible(true)]
    [Guid("1460198A-3CBE-462E-BB78-5B57FDB94502")]
    public enum PointCloudFileFormat
    {
        ASCII, Binary, CompressedBinary,
    }

    [ComVisible(true)]
    [Guid("074b4e15-8567-4416-b0c2-43353f62770d")]
    public enum NodesDataType
    {
        SurfaceDeformationNoRBM = 1,
        RefractiveIndex,
        TemperatureAndRefractiveIndex,
        SurfaceDeformation
    }

    [ComVisible(true)]
    [Guid("2850046C-592F-4D0F-BCE4-186B95BA2D7F")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILensDataEditor : IEditor
    {
        int RowToSurfaceOffset { get; }

        int NumberOfSurfaces { get; }
        int NumberOfNonSequentialSurfaces { get; }
        SurfaceColumn FirstColumn { get; }
        SurfaceColumn LastColumn { get; }
        int StopSurface { get; }

        ILDERow GetSurfaceAt(int SurfaceNumber);
        ILDERow InsertNewSurfaceAt(int SurfaceNumber);
        ILDERow AddSurface();
        bool RemoveSurfaceAt(int SurfaceNumber);
        int RemoveSurfacesAt(int SurfaceNumber, int numSurfaces);

        bool ShowLDE();
        void HideLDE();

        ILDETool_AddCoatingsToAllSurfaces GetTool_AddCoatingsToAllSurfaces();
        void RunTool_AddCoatingsToAllSurfaces(ILDETool_AddCoatingsToAllSurfaces settings);
        void RunTool_RemoveAllApertures();
        void RunTool_ConvertSemiDiametersToCircularApertures();
        void RunTool_ConvertSemiDiametersToFloatingApertures();
        void RunTool_ConvertSemiDiametersToMaximumApertures();
        void RunTool_ReplaceVignettingWithApertures();

        CoordinateConversionResult RunTool_ConvertGlobalToLocalCoordinates(int FirstSurface, int LastSurface, ConversionOrder order);
        CoordinateConversionResult RunTool_ConvertLocalToGlobalCoordinates(int FirstSurface, int LastSurface, int referenceSurface);

        double GetApodization(double px, double py);

        void GetFirstOrderData(
            out double EFL,
            out double paraxialWorkingFNumber,
            out double realWorkingFNumber,
            out double paraxialImageHeight,
            out double paraxialMagnification);

        bool GetGlass(
            int Surface,
            out string glassName,
            out double nd,
            out double vd,
            out double dpgf);

        bool GetGlobalMatrix(
            int Surface,
            out double R11, out double R12, out double R13,
            out double R21, out double R22, out double R23,
            out double R31, out double R32, out double R33,
            out double Xo, out double Yo, out double Zo);

        int GetIndex(
            int Surface,
            int NumberOfWavelengths,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)][In, Out]double[] indexAtWavelength);

        bool SetLabel(int Surface, int label);

        bool GetLabel(int Surface, out int label);

        bool FindLabel(int label, out int Surface);

        void GetPupil(
            out ZemaxApertureType type,
            out double ApertureValue,
            out double entrancePupilDiameter,
            out double entrancePupilPosition,
            out double exitPupilDiameter,
            out double exitPupilPosition,
            out PupilApodizationType ApodizationType,
            out double ApodizationFactor);

        bool GetSag(
            int Surface,
            double X, double Y,
            out double sag,
            out double alternateSag);

        int CopySurfaces(int fromSurfaceNumber, int NumberOfSurfaces, int toSurfaceNumber);
        int CopySurfacesFrom(ILensDataEditor fromEditor, int fromSurfaceNumber, int NumberOfSurfaces, int toSurfaceNumber);

        IMessage RunTool_ReverseElements(int firstSurface, int lastSurface);

        IMessage RunTool_AddFoldMirror(int Surface, TiltType tilt, double reflectAngle);

        IMessage RunTool_DeleteFoldMirror(int foldSurface);

        IMessage RunTool_MakeDoublePass(int reflectAtSurface);

        IMessage RunTool_MakeFocal(double focalLength);

        bool CanConvertSurfaceToFreeform(int fromSurface);

        IMessage RunTool_ConvertSurfaceToFreeform(int fromSurface, int freeformSurface, int gridNx, int gridNy, bool limitToClearAperture);

        IMessage RunTool_ConvertSurfaceInPlaceToFreeform(int fromSurface, int gridNx, int gridNy, bool limitToClearAperture);

        bool CanExportPointCloud(int Surface);

        IMessage RunTool_ExportPointCloudFile(int Surface, string filename, int gridNx, int gridNy, bool includeSurfaceNormals, PointCloudFileFormat format);

        string GetClosestGlass(int Surface);

        long GetId(int surface);

        ILDETool_TiltDecenterElements GetTool_TiltDecenterElements();

        IMessage RunTool_TiltDecenterElements(ILDETool_TiltDecenterElements settings);

        void SetJonesMatrixData(int surface, bool isRetarder, double delta, double angle, double transmission);//, double dop);
        void SetMuellerMatrixData(int surface, bool isRetarder, double delta, double angle, double transmission, double dop);

    }

    [ComVisible(true)]
    [Guid("FD772D17-CA89-417D-A292-51F448BDE81F")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceTypeSettings
    {
        bool IsValid { get; }

        SurfaceType Type { get; }

        bool RequiresFile { get; }
        string Filename { get; set; }
        string[] GetFileNames();
    }

    [ComVisible(true)]
    [Guid("774C8955-B4D3-4232-95CE-3B4CD460E8B3")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDERow : IEditorRow
    {
        bool IsActive { get; }
        int SurfaceNumber { get; }

        IEditorCell GetSurfaceCell(SurfaceColumn Col);

        string TypeName { get; }
        SurfaceType Type { get; }

        SurfaceType[] AvailableSurfaceTypes();
        ISurfaceTypeSettings CurrentTypeSettings { get; }
        ISurfaceTypeSettings GetSurfaceTypeSettings(SurfaceType type);
        bool ChangeType(ISurfaceTypeSettings settings);

        bool IsObject { get; }
        bool IsImage { get; }
        bool IsStop { get; set; }

        ISurface SurfaceData { get; }

        ILDETypeData TypeData { get; }
        ILDEDrawData DrawData { get; }
        ILDEApertureData ApertureData { get; }
        ILDEScatteringData ScatteringData { get; }
        ILDETiltDecenterData TiltDecenterData { get; }
        ILDEPhysicalOpticsData PhysicalOpticsData { get; }
        ILDECoatingData CoatingData { get; }
        ILDEImportData ImportData { get; }
        ILDECompositeData CompositeData { get; }

        string Comment { get; set; }
        IEditorCell CommentCell { get; }
        double Radius { get; set; }
        IEditorCell RadiusCell { get; }
        double Thickness { get; set; }
        IEditorCell ThicknessCell { get; }
        string Material { get; set; }
        IEditorCell MaterialCell { get; }
        string Coating { get; set; }
        IEditorCell CoatingCell { get; }
        double SemiDiameter { get; set; }
        IEditorCell SemiDiameterCell { get; }
        double ChipZone { get; set; }
        IEditorCell ChipZoneCell { get; }
        double MechanicalSemiDiameter { get; set; }
        IEditorCell MechanicalSemiDiameterCell { get; }
        double Conic { get; set; }
        IEditorCell ConicCell { get; }
        double TCE { get; set; }
        IEditorCell TCECell { get; }
        
        long SurfaceId { get; }
        ISTAR_Data STARData { get; }
        string MaterialCatalog { get; }

        IMetadata GetMetadata();
        ICoatingPerformanceData GetCoatingPerformanceData();        //SINGLE_VALUE_RTA_API_COMMANDS
    }

    [ComVisible(true)]
    [Guid("81B03584-B021-4D05-955B-A50AF52B2DB3")]
    public enum IndexDataType
    {
        Unknown = -1,
        None = 0,
        PhysicsBasedIndex,
        DirectRefractiveIndex,
    }

    [ComVisible(true)]
    [Guid("b596f961-3eca-43b4-8685-12c24095ffdb")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ICoatingPerformanceData        //SINGLE_VALUE_RTA_API_COMMANDS
    {
        int SurfaceNumber { get; }
        void GetCoatingPerformance(double AOI, double wavelen, DirectionOfRayTravel direction);
        // TODO - make a COM-friendly interface for this
        ICoatingPerformanceData[] GetCoatingPerformancesSafe(double[] aoiVals, double[] wavelengthVals, DirectionOfRayTravel direction);
        

        ICoatingParameter Reflection { get; }
        ICoatingParameter Transmission { get; }
        ICoatingParameter Absorption { get; }
        ICoatingParameter Diattenuation { get; }
        ICoatingParameter Phase { get; }
        ICoatingParameter Retardation { get; }
    }

    [ComVisible(true)]
    [Guid("D9957762-58D1-4524-958A-C0A0A420E4B0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_Data
    {
        int SurfaceNumber { get; }
        //Higher-level structure for current commands
        ISTAR_Deformations Deformations { get; }
        ISTAR_Temperatures Temperatures { get; }
        ISTAR_DirectIndex DirectIndex { get; }
        // What type of mechanism is represented by the refractive index / GRIN
        IndexDataType IndexDataType { get; }
        ISTAR_ComponentRBMs ComponentRBMs { get; }
        ISTAR_Stress Stress { get; }
    }

    [ComVisible(true)]
    [Guid("E255B917-6C02-4748-99CE-6CA69C302490")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_ComponentRBMs
    {
        void SetSurfacesInComponent(int firstSurface, int lastSurface);
        void RemoveComponent(int firstSurface);
        bool IsPartOfAComponent();

        int[] ListOfSurfacesInComponent { get; }
        int FirstSurfaceInComponent { get; }
        int LastSurfaceInComponent { get; }
        int NumberOfSurfacesInComponent { get; }
        ICoordinateTransform Transform { get; }
        void RemoveComponentRBMsFromFEADataSets();
        void AddComponentRBMsAsCoordinateBreaks();
        bool AdjustIndexDataWithComponentRBM { get; set; }
        bool ComponentRBMsAreRemoved { get; }
        bool CRBMsAreInCoordinateBreaks { get; }
    }

    [ComVisible(true)]
    [Guid("506DAE79-E659-4E53-86C0-15AB643DB5DF")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_Deformations
    {
        int SurfaceNumber { get; }
        ISTAR_DeformationsFEAData FEAData { get; }
        ISTAR_RBMs RBMs { get; }
        ISTAR_CoordinateTransform CoordinateTransform { get; }
        ISTAR_DeformationFits Fits { get; }
        void SetDataIsGlobal();
        void SetDataIsLocal();
        bool IsDataLocalCS();
    }

    [ComVisible(true)]
    [Guid("7C7A9282-E94C-4615-803D-805B0D67FE47")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_Temperatures
    {
        int SurfaceNumber { get; }
        double PrimaryWavelengthValue { get; }
        ISTAR_TemperaturesFEAData FEAData { get; }
        ISTAR_CoordinateTransform CoordinateTransform { get; }
        ISTAR_TemperaturesFits Fits { get; }
        double GRINStep { get; set; }
        void SetDataIsGlobal();
        void SetDataIsLocal();
        bool IsDataLocalCS();

        // STAR_MULTIWAVELENGTH
        int GetThermalFEAFitType();
        void SetThermalFEAFitType(int FitType);
        int GetWorkingWavelength();
        void SetWorkingWavelength(int wavelength_number);
    }

    [ComVisible(true)]
    [Guid("6E1C9FB1-B65E-499D-812C-76974C9E26CC")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_DirectIndex
    {
        int SurfaceNumber { get; }
        ISTAR_DirectIndexFEAData FEAData { get; }
        ISTAR_CoordinateTransform CoordinateTransform { get; }
        ISTAR_DirectIndexFits Fits { get; }
        double GRINStep { get; set; }
        void SetDataIsGlobal();
        void SetDataIsLocal();
        bool IsDataLocalCS();
    }

    [ComVisible(true)]
    [Guid("50771398-7248-4B8A-A660-20287D9325F4")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_Stress
    {
        int SurfaceNumber { get; }
        double GRINStep { get; set; }
        void SetDataIsGlobal();
        void SetDataIsLocal();
        bool IsDataLocalCS();
        ISTAR_StressFEAData FEAData { get; }
        ISTAR_StressFits Fits { get; }
        ISTAR_CoordinateTransform CoordinateTransform { get; }
        int GetWorkingWavelength();
        void SetWorkingWavelength(int wavelength_number);
        void SetPropagationLinear(bool linear);
        bool IsPropagationLinear();
    }

    [ComVisible(true)]
    [Guid("F0A629B2-ECCD-4FEF-B0C5-09E7B936FEA1")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_CoordinateTransform
    {
        int SurfaceNumber { get; }
        //  Similar to RBMs.Three decenters, three angles, and combined Rjk values.
        //If CoordinateTransform.Enable()= True, the values reported above in the “Handling deformation FEA data: (X Y Z dX dY dZ)” section are altered by the coordinate transform.
        void Enable();
        void Disable();
        bool IsEnabled { get; } //True if enabled, false otherwise (?)

        ICoordinateTransform Transform { get; }
        ISTAR_Decenters Decenters { get; }
        ISTAR_Rotations Rotations { get; }
        void ResetToDefaultFrameOfReference();
        bool IsInDefaultFrameOfReference();
        void SetRotationMatrix(double R11, double R12, double R13, double R21, double R22, double R23, double R31, double R32, double R33);
        void SetDecenter(double DX, double DY, double DZ);
        void SetTransformValues(double R11, double R12, double R13, double R21, double R22, double R23, double R31, double R32, double R33,
                                double DX, double DY, double DZ);
        void SetTransformValuesWithAngles(double ThetaX, double ThetaY, double ThetaZ, double DX, double DY, double DZ);
        double[,] ConvertAnglesToRotationMatrix(double thetaX, double thetaY, double thetaZ);
    }

    [ComVisible(true)]
    [Guid("084E3F10-67C6-41EE-89F9-3BFFAA8FA08D")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_TemperaturesFEAData
    {
        int SurfaceNumber { get; }
        //This section proposes functions for handling temperature FEA data of the form: (X Y Z T)
        [Obsolete("The method is no longer implemented. Use ImportTemperatures_1 instead.")]
        void ImportTemperatures(string filename);
        int ImportTemperatures_1(string filename);
        bool AreTemperaturesImported { get; }
        int NumberOfDataPoints { get; }
        string Filename { get; }
        string Name { get; set; }
        ISTAR_PointWithTemperatureAndIndex[] GetFEAPointsSafeOld();
        ISTAR_PointWithTemperatureAndIndex[] GetFEAPointsSafe();
        bool AreTemperaturesApplied();
        void UnloadData();
        void UnloadDataAndKeepFiles();
        ICoordinateTransform GetTransformValues(int transformType);
        ISTAR_PointWithTemperatureAndIndex[] GetTransformedFEAPointsSafe(int coordinateOption);


        ISTAR_PointWithTemperatureAndIndex[] GetTransformedFEAPointsNoImportRequired(String filename, int adaptCase, double[,] adapterR, double[] adapterO, int coordinateOption);
    }

    [ComVisible(true)]
    [Guid("5B9E6E5A-07F6-4132-AF17-E4D8507D04AE")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_PointWithTemperatureAndIndex
    {
        double X { get; set; }
        double Y { get; set; }
        double Z { get; set; }
        double T { get; set; }
        double Index { get; set; }
    }

    [ComVisible(true)]
    [Guid("B77F78AE-2D1D-4C9B-9F91-D120137CAA45")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_PointWithTemperature
    {
        double X { get; set; }
        double Y { get; set; }
        double Z { get; set; }
        double T { get; set; }
    }

    [ComVisible(true)]
    [Guid("E2DFA017-7AC4-4693-AB88-E212565A88BC")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_DirectIndexFEAData
    {
        int SurfaceNumber { get; }
        bool IsDirectIndexImported { get; }
        int NumberOfDataPoints { get; }
        string Filename { get; }
        string Name { get; set; }
        [Obsolete("The method is no longer implemented. Use ImportDirectIndex_1 instead.")]
        void ImportDirectIndex(string filename);
        int ImportDirectIndex_1(string filename);
        ISTAR_PointWithIndex[] GetFEAPointsSafe();
        bool IsDirectIndexApplied();
        void UnloadData();
        void UnloadDataAndKeepFiles();
        ICoordinateTransform GetTransformValues(int transformType);
        ISTAR_PointWithIndex[] GetTransformedFEAPointsSafe(int coordinateOption);

        ISTAR_PointWithIndex[] GetTransformedFEAPointsNoImportRequired(String filename, int adaptCase, double[,] adapterR, double[] adapterO, int coordinateOption);
    }

    [ComVisible(true)]
    [Guid("A8A85403-AB7C-4499-8867-AB1156DA1272")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_PointWithIndex
    {
        double X { get; set; }
        double Y { get; set; }
        double Z { get; set; }
        double Index { get; set; }
    }

    [ComVisible(true)]
    [Guid("FB4585D8-03E8-4A43-94AE-1493F9A090FF")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_StressFEAData
    {
        int SurfaceNumber { get; }
        int NumberOfDataPoints { get; }
        string Filename { get; }
        string Name { get; set; }
        [Obsolete("The method is no longer implemented. Use ImportStress_1 instead.")]
        void ImportStress(string filename);
        int ImportStress_1(string filename);
        bool IsStressImported { get; }
        void UnloadData();
        void UnloadDataAndKeepFiles();
        ISTAR_PointWithStress[] GetFEAPointsSafe();
        ICoordinateTransform GetTransformValues(int transformType);
        ISTAR_PointWithStress[] GetTransformedFEAPointsSafe(int coordinateOption);
        ISTAR_PointWithStress[] GetTransformedFEAPointsNoImportRequired(String filename, int adaptCase, double[,] adapterR, double[] adapterO, int coordinateOption);
        bool IsStressTensorApplied();
    }

    [ComVisible(true)]
    [Guid("0B92E545-ACED-4412-B084-5B50353FA10E")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_PointWithStress
    {
        double X { get; set; }
        double Y { get; set; }
        double Z { get; set; }
        double Sxx { get; set; }
        double Syy { get; set; }
        double Szz { get; set; }
        double Sxy { get; set; }
        double Syz { get; set; }
        double Sxz { get; set; }
    }

    // This section proposes functions for handling deformation FEA data of the form: (X Y Z dX dY dZ)
    [ComVisible(true)]
    [Guid("5FE63390-2B40-432A-B3FB-2216757E2F63")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_DeformationsFEAData
    {
        int SurfaceNumber { get; }
        [Obsolete("The method is no longer implemented. Use ImportDeformations_1 instead.")]
        void ImportDeformations(string filename);
        int ImportDeformations_1(string filename);
        bool AreDeformationsImported { get; }
        int NumberOfDataPoints { get; }
        string Filename { get; }        
        string Name { get; set; }
        ISTAR_PointWithDeformation[] GetFEAPointsSafeOld();
        ISTAR_PointWithDeformation[] GetFEAPointsSafe();
        ISTAR_PointWithDeformationAndWeight[] GetFEAPointsWithAutoWeightsSafe(int weightVariation);
        [Obsolete("The method is no longer implemented. Use STARData.Deformations.Fits.Options instead.", true)]
        bool AreDeformationsApplied();
        void UnloadData();
        void UnloadDataAndKeepFiles();
        ICoordinateTransform GetTransformValues(int transformType);
        ISTAR_PointWithDeformation[] GetTransformedFEAPointsSafe(int coordinateOption);

        ISTAR_PointWithDeformation[] GetTransformedFEAPointsNoImportRequired(String filename, int adaptCase, double[,] adapterR, double[] adapterO, int coordinateOption);
    }

    [ComVisible(true)]
    [Guid("162C0782-74F4-4F7B-8160-F2BD1DA5CDD5")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_PointWithDeformation
    {
        double X { get; set; }
        double Y { get; set; }
        double Z { get; set; }
        double DX { get; set; }
        double DY { get; set; }
        double DZ { get; set; }
    }

    [ComVisible(true)]
    [Guid("A5F1BBF4-7350-4210-87D6-4794D061BF28")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_PointWithDeformationAndWeight
    {
        double X { get; set; }
        double Y { get; set; }
        double Z { get; set; }
        double DX { get; set; }
        double DY { get; set; }
        double DZ { get; set; }
        double Weight { get; set; }
    }

    [ComVisible(true)]
    [Guid("DD70D2B6-1E62-47BB-96F2-D4D945EEEEFB")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_RBMs
    {
        int SurfaceNumber { get; }
        //RBMs are removed from the(dX dY dZ) deformations before fitting.And then put back in after fitting.
        //RBM values we might need to report:
        //  If RBMs.Enable() = True, the (dX, dY, dZ) values reported above in the “Handling deformation FEA data: (X Y Z dX dY dZ)” section are altered by the RBM removal.
        void Enable();
        void SetReferencePoint(double refX, double refY, double refZ);

        void Disable();
        bool IsEnabled { get; } //True if enabled, false otherwise (?)

        ICoordinateTransform Transform { get; }
        ISTAR_Decenters Decenters { get; }
        ISTAR_Rotations Rotations { get; }
        ISTAR_RBM_Centroid Centroid { get; }
        ISTAR_RBM_ReferencePoint GetReferencePoint();

        void GetTransformValues();
        bool UsedWeights { get; } //True if calculation of RBMs used weights, false otherwise
    }

    [ComVisible(true)]
    [Guid("1F0DDB33-7356-4EB9-BC2B-C773EDAC93CE")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    // Returns three decenter values:  X, Y, Z
    public interface ISTAR_Decenters
    {
        double X { get; }
        double Y { get; }
        double Z { get; }
        double[] GetVector();
    }

    [ComVisible(true)]
    [Guid("2A3691AB-086A-4D90-BCAC-4BB793FCD757")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_RBM_Centroid
    {
        double X { get; }
        double Y { get; }
        double Z { get; }
    }

    [ComVisible(true)]
    [Guid("68261367-1361-416A-BAD9-A0298E24DBD0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_RBM_ReferencePoint
    {
        double X { get; }
        double Y { get; }
        double Z { get; }
    }

    [ComVisible(true)]
    [Guid("C5169C6B-83B5-4803-ABEF-5C037B2D04C1")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_Rotations
    {
        // Returns the 9 rotation matrix components
        ISTAR_RotationValues Values { get; }

        //Returns the 3 rotation angles
        ISTAR_RotationAngles Angles { get; }
    }

    [ComVisible(true)]
    [Guid("498DE320-1D9B-4815-8A50-E8430DF8F8B0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_RotationValues
    {
        double R11 { get; }
        double R12 { get; }
        double R13 { get; }
        double R21 { get; }
        double R22 { get; }
        double R23 { get; }
        double R31 { get; }
        double R32 { get; }
        double R33 { get; }
    }

    [ComVisible(true)]
    [Guid("C8A57B75-3C26-4AD3-BE64-74B8A218F6CC")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_RotationAngles
    {
        //Rotation about Z in degrees -- TODO: Make this field obsolete
        double Alpha { get; }
        //Rotation about Y in degrees -- TODO: Make this field obsolete
        double Beta { get; }
        //Rotation about X in degrees -- TODO: Make this field obsolete
        double Gamma { get; }
        //Rotation about X in degrees
        double ThetaX { get; }
        //Rotation about Y in degrees
        double ThetaY { get; }
        //Rotation about Z in degrees
        double ThetaZ { get; }
    }

    [ComVisible(true)]
    [Guid("9C7BEBA7-BCDA-41C0-9539-36EB1C11AA8E")]
    public enum STARDeformationOption
    {
        DeformationWithRBMs = 0,
        DeformationWithoutRBMs = 1,
        OnlyRBMs = 2,
        NoDeformation = 3
    }

    [ComVisible(true)]
    [Guid("E09634E6-D6BE-483B-B630-DF0E5519199D")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_DeformationFits
    {
        int SurfaceNumber { get; }
        [Obsolete("The method is no longer implemented. Use STARData.Deformations.Fits.Options instead.", false)]
        void ApplyDeformations();
        [Obsolete("The method is no longer implemented. Use STARData.Deformations.Fits.Options instead.", false)]
        void RemoveDeformations();
        bool IsSurfaceDeformationEnabled { get; }
        ISTAR_FEAFitSettings Settings { get; }
        ISTAR_FEAFitResults FitResultsDX { get; }
        ISTAR_FEAFitResults FitResultsDY { get; }
        ISTAR_FEAFitResults FitResultsDZ { get; }
        ISTAR_FEAFitResults FitResultsAverage { get; }

        [Obsolete("The method is no longer implemented. Use GetFittedDeformation_1 instead.", true)]
        ISTAR_Deformation GetFittedDeformationRBMremoved(double X, double Y);
        [Obsolete("The method is no longer implemented. Use GetFittedDeformation_1 instead.", true)]
        ISTAR_Deformation GetFittedDeformation(double X, double Y);
        [Obsolete("The method is no longer implemented. Use MeshFittedDeformationSafe_1 instead.", true)]
        ISTAR_PointWithDeformation[] MeshFittedDeformationSafe(int num_X_pts, int num_Y_pts,
            double X1_edge, double Y1_edge, double X2_edge, double Y2_edge);
        [Obsolete("The method is no longer implemented. Use ListFittedDeformationSafe_1 instead.", true)]
        ISTAR_PointWithDeformation[] ListFittedDeformationSafe(double[] xCoor, double[] yCoor);        
        
        void Refit();

        STARDeformationOption Options { get; set; }
        ISTAR_PointWithDeformation GetFittedDeformation_1(double X, double Y, STARDeformationOption option);
        ISTAR_PointWithDeformation[] MeshFittedDeformationSafe_1(int num_X_pts, int num_Y_pts,
            double X1_edge, double Y1_edge, double X2_edge, double Y2_edge, STARDeformationOption option);
        ISTAR_PointWithDeformation[] ListFittedDeformationSafe_1(double[] xCoor, double[] yCoor, STARDeformationOption option);
    }

    [ComVisible(true)]
    [Guid("8B596882-B315-46F9-9D25-C885C8C526D6")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_FEAFitSettings
    {
        int SurfaceNumber { get; }

        int Type { get; }

        int Grid1 { get; set; }
        int Grid2 { get; set; }
        int Grid3 { get; set; }
        int MBAMaxLevel { get; set; }
        double MBATol { get; set; }
        double MBAMinFill { get; set; }
        void SetAllValues(int grid1, int grid2, int grid3, int mbaMaxLevel, double mbaTol, double mbaMinFill);
    }

    [ComVisible(true)]
    [Guid("13D54468-97F7-43E4-8344-A8F1A9131712")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_FEAFitResults
    {
        double Points { get; }
        double FitLevels { get; }
        double FitAccuracy { get; }
        double FitFill { get; }
        double FitNorm { get; }
        double FitAverage { get; }
        double FitRMS { get; }
        double FitPV { get; }
    }

    [ComVisible(true)]
    [Guid("7933FB80-7FC3-422A-8B8B-2A946919B4AA")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_Deformation
    {
        double DX { get; set; }
        double DY { get; set; }
        double DZ { get; set; }
    }

    [ComVisible(true)]
    [Guid("65E19621-298B-4EBA-B7BA-F899D78AB7E0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_TemperaturesFits
    {
        int SurfaceNumber { get; }
        void ApplyTemperatures();
        void RemoveTemperatures();
        bool IsTemperatureProfileEnabled { get; }
        ISTAR_FEAFitSettings Settings { get; }
        ISTAR_FEAFitResults FitResultsIndex { get; }
        double GetFittedIndex(double X, double Y, double Z);
        double GetFittedTemperature(double X, double Y, double Z);

        ISTAR_PointWithTemperatureAndIndex[] MeshFittedIndexSafe(int num_X_pts, int num_Y_pts, int num_Z_pts,
           double X1_edge, double Y1_edge, double Z1_edge, double X2_edge, double Y2_edge, double Z2_edge);
        ISTAR_PointWithTemperatureAndIndex[] ListFittedIndexSafe(double[] xCoor, double[] yCoor, double[] zCoor);
        double GRINStep { get; set; }
        void Refit();
    }

    [ComVisible(true)]
    [Guid("40F3CDD6-08AF-47C2-9935-E72E0563A400")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_DirectIndexFits
    {
        int SurfaceNumber { get; }
        void ApplyIndex();
        void RemoveIndex();
        ISTAR_FEAFitSettings Settings { get; }
        ISTAR_FEAFitResults FitResultsIndex { get; }
        double GetFittedIndex(double X, double Y, double Z);

        ISTAR_PointWithIndex[] MeshFittedIndexSafe(int num_X_pts, int num_Y_pts, int num_Z_pts,
           double X1_edge, double Y1_edge, double Z1_edge, double X2_edge, double Y2_edge, double Z2_edge);
        ISTAR_PointWithIndex[] ListFittedIndexSafe(double[] xCoor, double[] yCoor, double[] zCoor);
        double GRINStep { get; set; }
        void Refit();
    }

    [ComVisible(true)]
    [Guid("B814B172-55DA-4A70-993D-9E5E645C288A")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_PointWithRetardance
    {
        double X { get; set; }
        double Y { get; set; }
        double Z { get; set; }
        double Retardance { get; set; }
    }

    [ComVisible(true)]
    [Guid("3F828A8B-D3F1-404C-B8DB-10AB661D4BB0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_PointWithIndexAndRetardance
    {
        double X { get; set; }
        double Y { get; set; }
        double Z { get; set; }
        double Index { get; set; }
        double Retardance { get; set; }
    }

    [ComVisible(true)]
    [Guid("5947BDA3-EC65-4A70-AF91-5FF881395B95")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISTAR_StressFits
    {
        int SurfaceNumber { get; }
        double GRINStep { get; set; }
        ISTAR_FEAFitSettings Settings { get; }
        ISTAR_FEAFitResults FitResultsStressXX { get; }
        ISTAR_FEAFitResults FitResultsStressYY { get; }
        ISTAR_FEAFitResults FitResultsStressZZ { get; }
        ISTAR_FEAFitResults FitResultsStressXY { get; }
        ISTAR_FEAFitResults FitResultsStressYZ { get; }
        ISTAR_FEAFitResults FitResultsStressXZ { get; }
        double[] GetFittedStressTensor(double X, double Y, double Z);
        ISTAR_PointWithStress[] ListFittedStressTensor(double[] xs, double[] ys, double[] zs);
        double[] GetFittedRotatedStressTensor(double X, double Y, double Z, double L, double M, double N);
        double GetFittedIndex(double X, double Y, double Z, double L, double M, double N);
        void ApplyStress();
        void RemoveStress();
        void Refit();
        ISTAR_PointWithRetardance[] GetRetardanceMap(int density, int coordinateOption, int field, double Jx, double Jy, double phix, double phiy);
        ISTAR_PointWithIndexAndRetardance[] GetPointRetardanceList(int density, int coordinateOption, int field);
        double GetRetardance(double X, double Y, double Z, double L, double M, double N, double Step);
    }
        #region Surface Parameter Naming

        #region Surface Parameter Nameing Completed

    [ComVisible(true)]
    [Guid("33C05440-FBEF-4EFB-8E0D-D1123F200D4F")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurface
    {
        SurfaceType Type { get; }
        ILDERow Row { get; }
        bool IsValid { get; } // reference is not valid once row is deleted, type changed, etc.
        long Id { get; }
    }

    [ComVisible(true)]
    [Guid("3716860F-4817-4480-B79E-A16EBDFA6E6F")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceXYPolynomial : ISurface
    {
        IEditorCell NumberOfTermsCell { get; }

        int NumberOfTerms { get; set; }

        #region "XYPolyCells"
        IEditorCell X1Y0Cell { get; }
        IEditorCell X0Y1Cell { get; }
        IEditorCell X2Y0Cell { get; }
        IEditorCell X1Y1Cell { get; }
        IEditorCell X0Y2Cell { get; }
        IEditorCell X3Y0Cell { get; }
        IEditorCell X2Y1Cell { get; }
        IEditorCell X1Y2Cell { get; }
        IEditorCell X0Y3Cell { get; }
        IEditorCell X4Y0Cell { get; }
        IEditorCell X3Y1Cell { get; }
        IEditorCell X2Y2Cell { get; }
        IEditorCell X1Y3Cell { get; }
        IEditorCell X0Y4Cell { get; }
        IEditorCell X5Y0Cell { get; }
        IEditorCell X4Y1Cell { get; }
        IEditorCell X3Y2Cell { get; }
        IEditorCell X2Y3Cell { get; }
        IEditorCell X1Y4Cell { get; }
        IEditorCell X0Y5Cell { get; }
        IEditorCell X6Y0Cell { get; }
        IEditorCell X5Y1Cell { get; }
        IEditorCell X4Y2Cell { get; }
        IEditorCell X3Y3Cell { get; }
        IEditorCell X2Y4Cell { get; }
        IEditorCell X1Y5Cell { get; }
        IEditorCell X0Y6Cell { get; }
        IEditorCell X7Y0Cell { get; }
        IEditorCell X6Y1Cell { get; }
        IEditorCell X5Y2Cell { get; }
        IEditorCell X4Y3Cell { get; }
        IEditorCell X3Y4Cell { get; }
        IEditorCell X2Y5Cell { get; }
        IEditorCell X1Y6Cell { get; }
        IEditorCell X0Y7Cell { get; }
        IEditorCell X8Y0Cell { get; }
        IEditorCell X7Y1Cell { get; }
        IEditorCell X6Y2Cell { get; }
        IEditorCell X5Y3Cell { get; }
        IEditorCell X4Y4Cell { get; }
        IEditorCell X3Y5Cell { get; }
        IEditorCell X2Y6Cell { get; }
        IEditorCell X1Y7Cell { get; }
        IEditorCell X0Y8Cell { get; }
        IEditorCell X9Y0Cell { get; }
        IEditorCell X8Y1Cell { get; }
        IEditorCell X7Y2Cell { get; }
        IEditorCell X6Y3Cell { get; }
        IEditorCell X5Y4Cell { get; }
        IEditorCell X4Y5Cell { get; }
        IEditorCell X3Y6Cell { get; }
        IEditorCell X2Y7Cell { get; }
        IEditorCell X1Y8Cell { get; }
        IEditorCell X0Y9Cell { get; }
        IEditorCell X10Y0Cell { get; }
        IEditorCell X9Y1Cell { get; }
        IEditorCell X8Y2Cell { get; }
        IEditorCell X7Y3Cell { get; }
        IEditorCell X6Y4Cell { get; }
        IEditorCell X5Y5Cell { get; }
        IEditorCell X4Y6Cell { get; }
        IEditorCell X3Y7Cell { get; }
        IEditorCell X2Y8Cell { get; }
        IEditorCell X1Y9Cell { get; }
        IEditorCell X0Y10Cell { get; }
        IEditorCell X11Y0Cell { get; }
        IEditorCell X10Y1Cell { get; }
        IEditorCell X9Y2Cell { get; }
        IEditorCell X8Y3Cell { get; }
        IEditorCell X7Y4Cell { get; }
        IEditorCell X6Y5Cell { get; }
        IEditorCell X5Y6Cell { get; }
        IEditorCell X4Y7Cell { get; }
        IEditorCell X3Y8Cell { get; }
        IEditorCell X2Y9Cell { get; }
        IEditorCell X1Y10Cell { get; }
        IEditorCell X0Y11Cell { get; }
        IEditorCell X12Y0Cell { get; }
        IEditorCell X11Y1Cell { get; }
        IEditorCell X10Y2Cell { get; }
        IEditorCell X9Y3Cell { get; }
        IEditorCell X8Y4Cell { get; }
        IEditorCell X7Y5Cell { get; }
        IEditorCell X6Y6Cell { get; }
        IEditorCell X5Y7Cell { get; }
        IEditorCell X4Y8Cell { get; }
        IEditorCell X3Y9Cell { get; }
        IEditorCell X2Y10Cell { get; }
        IEditorCell X1Y11Cell { get; }
        IEditorCell X0Y12Cell { get; }
        IEditorCell X13Y0Cell { get; }
        IEditorCell X12Y1Cell { get; }
        IEditorCell X11Y2Cell { get; }
        IEditorCell X10Y3Cell { get; }
        IEditorCell X9Y4Cell { get; }
        IEditorCell X8Y5Cell { get; }
        IEditorCell X7Y6Cell { get; }
        IEditorCell X6Y7Cell { get; }
        IEditorCell X5Y8Cell { get; }
        IEditorCell X4Y9Cell { get; }
        IEditorCell X3Y10Cell { get; }
        IEditorCell X2Y11Cell { get; }
        IEditorCell X1Y12Cell { get; }
        IEditorCell X0Y13Cell { get; }
        IEditorCell X14Y0Cell { get; }
        IEditorCell X13Y1Cell { get; }
        IEditorCell X12Y2Cell { get; }
        IEditorCell X11Y3Cell { get; }
        IEditorCell X10Y4Cell { get; }
        IEditorCell X9Y5Cell { get; }
        IEditorCell X8Y6Cell { get; }
        IEditorCell X7Y7Cell { get; }
        IEditorCell X6Y8Cell { get; }
        IEditorCell X5Y9Cell { get; }
        IEditorCell X4Y10Cell { get; }
        IEditorCell X3Y11Cell { get; }
        IEditorCell X2Y12Cell { get; }
        IEditorCell X1Y13Cell { get; }
        IEditorCell X0Y14Cell { get; }
        IEditorCell X15Y0Cell { get; }
        IEditorCell X14Y1Cell { get; }
        IEditorCell X13Y2Cell { get; }
        IEditorCell X12Y3Cell { get; }
        IEditorCell X11Y4Cell { get; }
        IEditorCell X10Y5Cell { get; }
        IEditorCell X9Y6Cell { get; }
        IEditorCell X8Y7Cell { get; }
        IEditorCell X7Y8Cell { get; }
        IEditorCell X6Y9Cell { get; }
        IEditorCell X5Y10Cell { get; }
        IEditorCell X4Y11Cell { get; }
        IEditorCell X3Y12Cell { get; }
        IEditorCell X2Y13Cell { get; }
        IEditorCell X1Y14Cell { get; }
        IEditorCell X0Y15Cell { get; }
        IEditorCell X16Y0Cell { get; }
        IEditorCell X15Y1Cell { get; }
        IEditorCell X14Y2Cell { get; }
        IEditorCell X13Y3Cell { get; }
        IEditorCell X12Y4Cell { get; }
        IEditorCell X11Y5Cell { get; }
        IEditorCell X10Y6Cell { get; }
        IEditorCell X9Y7Cell { get; }
        IEditorCell X8Y8Cell { get; }
        IEditorCell X7Y9Cell { get; }
        IEditorCell X6Y10Cell { get; }
        IEditorCell X5Y11Cell { get; }
        IEditorCell X4Y12Cell { get; }
        IEditorCell X3Y13Cell { get; }
        IEditorCell X2Y14Cell { get; }
        IEditorCell X1Y15Cell { get; }
        IEditorCell X0Y16Cell { get; }
        IEditorCell X17Y0Cell { get; }
        IEditorCell X16Y1Cell { get; }
        IEditorCell X15Y2Cell { get; }
        IEditorCell X14Y3Cell { get; }
        IEditorCell X13Y4Cell { get; }
        IEditorCell X12Y5Cell { get; }
        IEditorCell X11Y6Cell { get; }
        IEditorCell X10Y7Cell { get; }
        IEditorCell X9Y8Cell { get; }
        IEditorCell X8Y9Cell { get; }
        IEditorCell X7Y10Cell { get; }
        IEditorCell X6Y11Cell { get; }
        IEditorCell X5Y12Cell { get; }
        IEditorCell X4Y13Cell { get; }
        IEditorCell X3Y14Cell { get; }
        IEditorCell X2Y15Cell { get; }
        IEditorCell X1Y16Cell { get; }
        IEditorCell X0Y17Cell { get; }
        IEditorCell X18Y0Cell { get; }
        IEditorCell X17Y1Cell { get; }
        IEditorCell X16Y2Cell { get; }
        IEditorCell X15Y3Cell { get; }
        IEditorCell X14Y4Cell { get; }
        IEditorCell X13Y5Cell { get; }
        IEditorCell X12Y6Cell { get; }
        IEditorCell X11Y7Cell { get; }
        IEditorCell X10Y8Cell { get; }
        IEditorCell X9Y9Cell { get; }
        IEditorCell X8Y10Cell { get; }
        IEditorCell X7Y11Cell { get; }
        IEditorCell X6Y12Cell { get; }
        IEditorCell X5Y13Cell { get; }
        IEditorCell X4Y14Cell { get; }
        IEditorCell X3Y15Cell { get; }
        IEditorCell X2Y16Cell { get; }
        IEditorCell X1Y17Cell { get; }
        IEditorCell X0Y18Cell { get; }
        IEditorCell X19Y0Cell { get; }
        IEditorCell X18Y1Cell { get; }
        IEditorCell X17Y2Cell { get; }
        IEditorCell X16Y3Cell { get; }
        IEditorCell X15Y4Cell { get; }
        IEditorCell X14Y5Cell { get; }
        IEditorCell X13Y6Cell { get; }
        IEditorCell X12Y7Cell { get; }
        IEditorCell X11Y8Cell { get; }
        IEditorCell X10Y9Cell { get; }
        IEditorCell X9Y10Cell { get; }
        IEditorCell X8Y11Cell { get; }
        IEditorCell X7Y12Cell { get; }
        IEditorCell X6Y13Cell { get; }
        IEditorCell X5Y14Cell { get; }
        IEditorCell X4Y15Cell { get; }
        IEditorCell X3Y16Cell { get; }
        IEditorCell X2Y17Cell { get; }
        IEditorCell X1Y18Cell { get; }
        IEditorCell X0Y19Cell { get; }
        IEditorCell X20Y0Cell { get; }
        IEditorCell X19Y1Cell { get; }
        IEditorCell X18Y2Cell { get; }
        IEditorCell X17Y3Cell { get; }
        IEditorCell X16Y4Cell { get; }
        IEditorCell X15Y5Cell { get; }
        IEditorCell X14Y6Cell { get; }
        IEditorCell X13Y7Cell { get; }
        IEditorCell X12Y8Cell { get; }
        IEditorCell X11Y9Cell { get; }
        IEditorCell X10Y10Cell { get; }
        IEditorCell X9Y11Cell { get; }
        IEditorCell X8Y12Cell { get; }
        IEditorCell X7Y13Cell { get; }
        IEditorCell X6Y14Cell { get; }
        IEditorCell X5Y15Cell { get; }
        IEditorCell X4Y16Cell { get; }
        IEditorCell X3Y17Cell { get; }
        IEditorCell X2Y18Cell { get; }
        IEditorCell X1Y19Cell { get; }
        IEditorCell X0Y20Cell { get; }
        IEditorCell X21Y0Cell { get; }
        IEditorCell X20Y1Cell { get; }
        IEditorCell X19Y2Cell { get; }
        IEditorCell X18Y3Cell { get; }
        IEditorCell X17Y4Cell { get; }
        IEditorCell X16Y5Cell { get; }
        IEditorCell X15Y6Cell { get; }
        IEditorCell X14Y7Cell { get; }
        IEditorCell X13Y8Cell { get; }
        IEditorCell X12Y9Cell { get; }
        IEditorCell X11Y10Cell { get; }
        IEditorCell X10Y11Cell { get; }
        IEditorCell X9Y12Cell { get; }
        IEditorCell X8Y13Cell { get; }
        IEditorCell X7Y14Cell { get; }
        IEditorCell X6Y15Cell { get; }
        IEditorCell X5Y16Cell { get; }
        IEditorCell X4Y17Cell { get; }
        IEditorCell X3Y18Cell { get; }
        IEditorCell X2Y19Cell { get; }

        double X1Y0 { get; set; }
        double X0Y1 { get; set; }
        double X2Y0 { get; set; }
        double X1Y1 { get; set; }
        double X0Y2 { get; set; }
        double X3Y0 { get; set; }
        double X2Y1 { get; set; }
        double X1Y2 { get; set; }
        double X0Y3 { get; set; }
        double X4Y0 { get; set; }
        double X3Y1 { get; set; }
        double X2Y2 { get; set; }
        double X1Y3 { get; set; }
        double X0Y4 { get; set; }
        double X5Y0 { get; set; }
        double X4Y1 { get; set; }
        double X3Y2 { get; set; }
        double X2Y3 { get; set; }
        double X1Y4 { get; set; }
        double X0Y5 { get; set; }
        double X6Y0 { get; set; }
        double X5Y1 { get; set; }
        double X4Y2 { get; set; }
        double X3Y3 { get; set; }
        double X2Y4 { get; set; }
        double X1Y5 { get; set; }
        double X0Y6 { get; set; }
        double X7Y0 { get; set; }
        double X6Y1 { get; set; }
        double X5Y2 { get; set; }
        double X4Y3 { get; set; }
        double X3Y4 { get; set; }
        double X2Y5 { get; set; }
        double X1Y6 { get; set; }
        double X0Y7 { get; set; }
        double X8Y0 { get; set; }
        double X7Y1 { get; set; }
        double X6Y2 { get; set; }
        double X5Y3 { get; set; }
        double X4Y4 { get; set; }
        double X3Y5 { get; set; }
        double X2Y6 { get; set; }
        double X1Y7 { get; set; }
        double X0Y8 { get; set; }
        double X9Y0 { get; set; }
        double X8Y1 { get; set; }
        double X7Y2 { get; set; }
        double X6Y3 { get; set; }
        double X5Y4 { get; set; }
        double X4Y5 { get; set; }
        double X3Y6 { get; set; }
        double X2Y7 { get; set; }
        double X1Y8 { get; set; }
        double X0Y9 { get; set; }
        double X10Y0 { get; set; }
        double X9Y1 { get; set; }
        double X8Y2 { get; set; }
        double X7Y3 { get; set; }
        double X6Y4 { get; set; }
        double X5Y5 { get; set; }
        double X4Y6 { get; set; }
        double X3Y7 { get; set; }
        double X2Y8 { get; set; }
        double X1Y9 { get; set; }
        double X0Y10 { get; set; }
        double X11Y0 { get; set; }
        double X10Y1 { get; set; }
        double X9Y2 { get; set; }
        double X8Y3 { get; set; }
        double X7Y4 { get; set; }
        double X6Y5 { get; set; }
        double X5Y6 { get; set; }
        double X4Y7 { get; set; }
        double X3Y8 { get; set; }
        double X2Y9 { get; set; }
        double X1Y10 { get; set; }
        double X0Y11 { get; set; }
        double X12Y0 { get; set; }
        double X11Y1 { get; set; }
        double X10Y2 { get; set; }
        double X9Y3 { get; set; }
        double X8Y4 { get; set; }
        double X7Y5 { get; set; }
        double X6Y6 { get; set; }
        double X5Y7 { get; set; }
        double X4Y8 { get; set; }
        double X3Y9 { get; set; }
        double X2Y10 { get; set; }
        double X1Y11 { get; set; }
        double X0Y12 { get; set; }
        double X13Y0 { get; set; }
        double X12Y1 { get; set; }
        double X11Y2 { get; set; }
        double X10Y3 { get; set; }
        double X9Y4 { get; set; }
        double X8Y5 { get; set; }
        double X7Y6 { get; set; }
        double X6Y7 { get; set; }
        double X5Y8 { get; set; }
        double X4Y9 { get; set; }
        double X3Y10 { get; set; }
        double X2Y11 { get; set; }
        double X1Y12 { get; set; }
        double X0Y13 { get; set; }
        double X14Y0 { get; set; }
        double X13Y1 { get; set; }
        double X12Y2 { get; set; }
        double X11Y3 { get; set; }
        double X10Y4 { get; set; }
        double X9Y5 { get; set; }
        double X8Y6 { get; set; }
        double X7Y7 { get; set; }
        double X6Y8 { get; set; }
        double X5Y9 { get; set; }
        double X4Y10 { get; set; }
        double X3Y11 { get; set; }
        double X2Y12 { get; set; }
        double X1Y13 { get; set; }
        double X0Y14 { get; set; }
        double X15Y0 { get; set; }
        double X14Y1 { get; set; }
        double X13Y2 { get; set; }
        double X12Y3 { get; set; }
        double X11Y4 { get; set; }
        double X10Y5 { get; set; }
        double X9Y6 { get; set; }
        double X8Y7 { get; set; }
        double X7Y8 { get; set; }
        double X6Y9 { get; set; }
        double X5Y10 { get; set; }
        double X4Y11 { get; set; }
        double X3Y12 { get; set; }
        double X2Y13 { get; set; }
        double X1Y14 { get; set; }
        double X0Y15 { get; set; }
        double X16Y0 { get; set; }
        double X15Y1 { get; set; }
        double X14Y2 { get; set; }
        double X13Y3 { get; set; }
        double X12Y4 { get; set; }
        double X11Y5 { get; set; }
        double X10Y6 { get; set; }
        double X9Y7 { get; set; }
        double X8Y8 { get; set; }
        double X7Y9 { get; set; }
        double X6Y10 { get; set; }
        double X5Y11 { get; set; }
        double X4Y12 { get; set; }
        double X3Y13 { get; set; }
        double X2Y14 { get; set; }
        double X1Y15 { get; set; }
        double X0Y16 { get; set; }
        double X17Y0 { get; set; }
        double X16Y1 { get; set; }
        double X15Y2 { get; set; }
        double X14Y3 { get; set; }
        double X13Y4 { get; set; }
        double X12Y5 { get; set; }
        double X11Y6 { get; set; }
        double X10Y7 { get; set; }
        double X9Y8 { get; set; }
        double X8Y9 { get; set; }
        double X7Y10 { get; set; }
        double X6Y11 { get; set; }
        double X5Y12 { get; set; }
        double X4Y13 { get; set; }
        double X3Y14 { get; set; }
        double X2Y15 { get; set; }
        double X1Y16 { get; set; }
        double X0Y17 { get; set; }
        double X18Y0 { get; set; }
        double X17Y1 { get; set; }
        double X16Y2 { get; set; }
        double X15Y3 { get; set; }
        double X14Y4 { get; set; }
        double X13Y5 { get; set; }
        double X12Y6 { get; set; }
        double X11Y7 { get; set; }
        double X10Y8 { get; set; }
        double X9Y9 { get; set; }
        double X8Y10 { get; set; }
        double X7Y11 { get; set; }
        double X6Y12 { get; set; }
        double X5Y13 { get; set; }
        double X4Y14 { get; set; }
        double X3Y15 { get; set; }
        double X2Y16 { get; set; }
        double X1Y17 { get; set; }
        double X0Y18 { get; set; }
        double X19Y0 { get; set; }
        double X18Y1 { get; set; }
        double X17Y2 { get; set; }
        double X16Y3 { get; set; }
        double X15Y4 { get; set; }
        double X14Y5 { get; set; }
        double X13Y6 { get; set; }
        double X12Y7 { get; set; }
        double X11Y8 { get; set; }
        double X10Y9 { get; set; }
        double X9Y10 { get; set; }
        double X8Y11 { get; set; }
        double X7Y12 { get; set; }
        double X6Y13 { get; set; }
        double X5Y14 { get; set; }
        double X4Y15 { get; set; }
        double X3Y16 { get; set; }
        double X2Y17 { get; set; }
        double X1Y18 { get; set; }
        double X0Y19 { get; set; }
        double X20Y0 { get; set; }
        double X19Y1 { get; set; }
        double X18Y2 { get; set; }
        double X17Y3 { get; set; }
        double X16Y4 { get; set; }
        double X15Y5 { get; set; }
        double X14Y6 { get; set; }
        double X13Y7 { get; set; }
        double X12Y8 { get; set; }
        double X11Y9 { get; set; }
        double X10Y10 { get; set; }
        double X9Y11 { get; set; }
        double X8Y12 { get; set; }
        double X7Y13 { get; set; }
        double X6Y14 { get; set; }
        double X5Y15 { get; set; }
        double X4Y16 { get; set; }
        double X3Y17 { get; set; }
        double X2Y18 { get; set; }
        double X1Y19 { get; set; }
        double X0Y20 { get; set; }
        double X21Y0 { get; set; }
        double X20Y1 { get; set; }
        double X19Y2 { get; set; }
        double X18Y3 { get; set; }
        double X17Y4 { get; set; }
        double X16Y5 { get; set; }
        double X15Y6 { get; set; }
        double X14Y7 { get; set; }
        double X13Y8 { get; set; }
        double X12Y9 { get; set; }
        double X11Y10 { get; set; }
        double X10Y11 { get; set; }
        double X9Y12 { get; set; }
        double X8Y13 { get; set; }
        double X7Y14 { get; set; }
        double X6Y15 { get; set; }
        double X5Y16 { get; set; }
        double X4Y17 { get; set; }
        double X3Y18 { get; set; }
        double X2Y19 { get; set; }
        #endregion
    }

    [ComVisible(true)]
    [Guid("13D3C283-9686-4AB2-9621-100CAE42F3A4")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceFreeformXYPolynomial : ISurface
    {
        IEditorCell NumberOfPolynomialTermsCell { get; }

        int NumberOfPolynomialTerms { get; set; }

        #region "XYPolyCells"
        IEditorCell X1Y0Cell { get; }
        IEditorCell X0Y1Cell { get; }
        IEditorCell X2Y0Cell { get; }
        IEditorCell X1Y1Cell { get; }
        IEditorCell X0Y2Cell { get; }
        IEditorCell X3Y0Cell { get; }
        IEditorCell X2Y1Cell { get; }
        IEditorCell X1Y2Cell { get; }
        IEditorCell X0Y3Cell { get; }
        IEditorCell X4Y0Cell { get; }
        IEditorCell X3Y1Cell { get; }
        IEditorCell X2Y2Cell { get; }
        IEditorCell X1Y3Cell { get; }
        IEditorCell X0Y4Cell { get; }
        IEditorCell X5Y0Cell { get; }
        IEditorCell X4Y1Cell { get; }
        IEditorCell X3Y2Cell { get; }
        IEditorCell X2Y3Cell { get; }
        IEditorCell X1Y4Cell { get; }
        IEditorCell X0Y5Cell { get; }
        IEditorCell X6Y0Cell { get; }
        IEditorCell X5Y1Cell { get; }
        IEditorCell X4Y2Cell { get; }
        IEditorCell X3Y3Cell { get; }
        IEditorCell X2Y4Cell { get; }
        IEditorCell X1Y5Cell { get; }
        IEditorCell X0Y6Cell { get; }
        IEditorCell X7Y0Cell { get; }
        IEditorCell X6Y1Cell { get; }
        IEditorCell X5Y2Cell { get; }
        IEditorCell X4Y3Cell { get; }
        IEditorCell X3Y4Cell { get; }
        IEditorCell X2Y5Cell { get; }
        IEditorCell X1Y6Cell { get; }
        IEditorCell X0Y7Cell { get; }
        IEditorCell X8Y0Cell { get; }
        IEditorCell X7Y1Cell { get; }
        IEditorCell X6Y2Cell { get; }
        IEditorCell X5Y3Cell { get; }
        IEditorCell X4Y4Cell { get; }
        IEditorCell X3Y5Cell { get; }
        IEditorCell X2Y6Cell { get; }
        IEditorCell X1Y7Cell { get; }
        IEditorCell X0Y8Cell { get; }
        IEditorCell X9Y0Cell { get; }
        IEditorCell X8Y1Cell { get; }
        IEditorCell X7Y2Cell { get; }
        IEditorCell X6Y3Cell { get; }
        IEditorCell X5Y4Cell { get; }
        IEditorCell X4Y5Cell { get; }
        IEditorCell X3Y6Cell { get; }
        IEditorCell X2Y7Cell { get; }
        IEditorCell X1Y8Cell { get; }
        IEditorCell X0Y9Cell { get; }
        IEditorCell X10Y0Cell { get; }
        IEditorCell X9Y1Cell { get; }
        IEditorCell X8Y2Cell { get; }
        IEditorCell X7Y3Cell { get; }
        IEditorCell X6Y4Cell { get; }
        IEditorCell X5Y5Cell { get; }
        IEditorCell X4Y6Cell { get; }
        IEditorCell X3Y7Cell { get; }
        IEditorCell X2Y8Cell { get; }
        IEditorCell X1Y9Cell { get; }
        IEditorCell X0Y10Cell { get; }
        IEditorCell X11Y0Cell { get; }
        IEditorCell X10Y1Cell { get; }
        IEditorCell X9Y2Cell { get; }
        IEditorCell X8Y3Cell { get; }
        IEditorCell X7Y4Cell { get; }
        IEditorCell X6Y5Cell { get; }
        IEditorCell X5Y6Cell { get; }
        IEditorCell X4Y7Cell { get; }
        IEditorCell X3Y8Cell { get; }
        IEditorCell X2Y9Cell { get; }
        IEditorCell X1Y10Cell { get; }
        IEditorCell X0Y11Cell { get; }
        IEditorCell X12Y0Cell { get; }
        IEditorCell X11Y1Cell { get; }
        IEditorCell X10Y2Cell { get; }
        IEditorCell X9Y3Cell { get; }
        IEditorCell X8Y4Cell { get; }
        IEditorCell X7Y5Cell { get; }
        IEditorCell X6Y6Cell { get; }
        IEditorCell X5Y7Cell { get; }
        IEditorCell X4Y8Cell { get; }
        IEditorCell X3Y9Cell { get; }
        IEditorCell X2Y10Cell { get; }
        IEditorCell X1Y11Cell { get; }
        IEditorCell X0Y12Cell { get; }
        IEditorCell X13Y0Cell { get; }
        IEditorCell X12Y1Cell { get; }
        IEditorCell X11Y2Cell { get; }
        IEditorCell X10Y3Cell { get; }
        IEditorCell X9Y4Cell { get; }
        IEditorCell X8Y5Cell { get; }
        IEditorCell X7Y6Cell { get; }
        IEditorCell X6Y7Cell { get; }
        IEditorCell X5Y8Cell { get; }
        IEditorCell X4Y9Cell { get; }
        IEditorCell X3Y10Cell { get; }
        IEditorCell X2Y11Cell { get; }
        IEditorCell X1Y12Cell { get; }
        IEditorCell X0Y13Cell { get; }
        IEditorCell X14Y0Cell { get; }
        IEditorCell X13Y1Cell { get; }
        IEditorCell X12Y2Cell { get; }
        IEditorCell X11Y3Cell { get; }
        IEditorCell X10Y4Cell { get; }
        IEditorCell X9Y5Cell { get; }
        IEditorCell X8Y6Cell { get; }
        IEditorCell X7Y7Cell { get; }
        IEditorCell X6Y8Cell { get; }
        IEditorCell X5Y9Cell { get; }
        IEditorCell X4Y10Cell { get; }
        IEditorCell X3Y11Cell { get; }
        IEditorCell X2Y12Cell { get; }
        IEditorCell X1Y13Cell { get; }
        IEditorCell X0Y14Cell { get; }
        IEditorCell X15Y0Cell { get; }
        IEditorCell X14Y1Cell { get; }
        IEditorCell X13Y2Cell { get; }
        IEditorCell X12Y3Cell { get; }
        IEditorCell X11Y4Cell { get; }
        IEditorCell X10Y5Cell { get; }
        IEditorCell X9Y6Cell { get; }
        IEditorCell X8Y7Cell { get; }
        IEditorCell X7Y8Cell { get; }
        IEditorCell X6Y9Cell { get; }
        IEditorCell X5Y10Cell { get; }
        IEditorCell X4Y11Cell { get; }
        IEditorCell X3Y12Cell { get; }
        IEditorCell X2Y13Cell { get; }
        IEditorCell X1Y14Cell { get; }
        IEditorCell X0Y15Cell { get; }
        IEditorCell X16Y0Cell { get; }
        IEditorCell X15Y1Cell { get; }
        IEditorCell X14Y2Cell { get; }
        IEditorCell X13Y3Cell { get; }
        IEditorCell X12Y4Cell { get; }
        IEditorCell X11Y5Cell { get; }
        IEditorCell X10Y6Cell { get; }
        IEditorCell X9Y7Cell { get; }
        IEditorCell X8Y8Cell { get; }
        IEditorCell X7Y9Cell { get; }
        IEditorCell X6Y10Cell { get; }
        IEditorCell X5Y11Cell { get; }
        IEditorCell X4Y12Cell { get; }
        IEditorCell X3Y13Cell { get; }
        IEditorCell X2Y14Cell { get; }
        IEditorCell X1Y15Cell { get; }
        IEditorCell X0Y16Cell { get; }
        IEditorCell X17Y0Cell { get; }
        IEditorCell X16Y1Cell { get; }
        IEditorCell X15Y2Cell { get; }
        IEditorCell X14Y3Cell { get; }
        IEditorCell X13Y4Cell { get; }
        IEditorCell X12Y5Cell { get; }
        IEditorCell X11Y6Cell { get; }
        IEditorCell X10Y7Cell { get; }
        IEditorCell X9Y8Cell { get; }
        IEditorCell X8Y9Cell { get; }
        IEditorCell X7Y10Cell { get; }
        IEditorCell X6Y11Cell { get; }
        IEditorCell X5Y12Cell { get; }
        IEditorCell X4Y13Cell { get; }
        IEditorCell X3Y14Cell { get; }
        IEditorCell X2Y15Cell { get; }
        IEditorCell X1Y16Cell { get; }
        IEditorCell X0Y17Cell { get; }
        IEditorCell X18Y0Cell { get; }
        IEditorCell X17Y1Cell { get; }
        IEditorCell X16Y2Cell { get; }
        IEditorCell X15Y3Cell { get; }
        IEditorCell X14Y4Cell { get; }
        IEditorCell X13Y5Cell { get; }
        IEditorCell X12Y6Cell { get; }
        IEditorCell X11Y7Cell { get; }
        IEditorCell X10Y8Cell { get; }
        IEditorCell X9Y9Cell { get; }
        IEditorCell X8Y10Cell { get; }
        IEditorCell X7Y11Cell { get; }
        IEditorCell X6Y12Cell { get; }
        IEditorCell X5Y13Cell { get; }
        IEditorCell X4Y14Cell { get; }
        IEditorCell X3Y15Cell { get; }
        IEditorCell X2Y16Cell { get; }
        IEditorCell X1Y17Cell { get; }
        IEditorCell X0Y18Cell { get; }
        IEditorCell X19Y0Cell { get; }
        IEditorCell X18Y1Cell { get; }
        IEditorCell X17Y2Cell { get; }
        IEditorCell X16Y3Cell { get; }
        IEditorCell X15Y4Cell { get; }
        IEditorCell X14Y5Cell { get; }
        IEditorCell X13Y6Cell { get; }
        IEditorCell X12Y7Cell { get; }
        IEditorCell X11Y8Cell { get; }
        IEditorCell X10Y9Cell { get; }
        IEditorCell X9Y10Cell { get; }
        IEditorCell X8Y11Cell { get; }
        IEditorCell X7Y12Cell { get; }
        IEditorCell X6Y13Cell { get; }
        IEditorCell X5Y14Cell { get; }
        IEditorCell X4Y15Cell { get; }
        IEditorCell X3Y16Cell { get; }
        IEditorCell X2Y17Cell { get; }
        IEditorCell X1Y18Cell { get; }
        IEditorCell X0Y19Cell { get; }
        IEditorCell X20Y0Cell { get; }
        IEditorCell X19Y1Cell { get; }
        IEditorCell X18Y2Cell { get; }
        IEditorCell X17Y3Cell { get; }
        IEditorCell X16Y4Cell { get; }
        IEditorCell X15Y5Cell { get; }
        IEditorCell X14Y6Cell { get; }
        IEditorCell X13Y7Cell { get; }
        IEditorCell X12Y8Cell { get; }
        IEditorCell X11Y9Cell { get; }
        IEditorCell X10Y10Cell { get; }
        IEditorCell X9Y11Cell { get; }
        IEditorCell X8Y12Cell { get; }
        IEditorCell X7Y13Cell { get; }
        IEditorCell X6Y14Cell { get; }
        IEditorCell X5Y15Cell { get; }
        IEditorCell X4Y16Cell { get; }
        IEditorCell X3Y17Cell { get; }
        IEditorCell X2Y18Cell { get; }
        IEditorCell X1Y19Cell { get; }
        IEditorCell X0Y20Cell { get; }
        IEditorCell X21Y0Cell { get; }
        IEditorCell X20Y1Cell { get; }
        IEditorCell X19Y2Cell { get; }
        IEditorCell X18Y3Cell { get; }
        IEditorCell X17Y4Cell { get; }
        IEditorCell X16Y5Cell { get; }
        IEditorCell X15Y6Cell { get; }
        IEditorCell X14Y7Cell { get; }
        IEditorCell X13Y8Cell { get; }
        IEditorCell X12Y9Cell { get; }
        IEditorCell X11Y10Cell { get; }
        IEditorCell X10Y11Cell { get; }
        IEditorCell X9Y12Cell { get; }
        IEditorCell X8Y13Cell { get; }
        IEditorCell X7Y14Cell { get; }
        IEditorCell X6Y15Cell { get; }
        IEditorCell X5Y16Cell { get; }
        IEditorCell X4Y17Cell { get; }
        IEditorCell X3Y18Cell { get; }
        IEditorCell X2Y19Cell { get; }

        double X1Y0 { get; set; }
        double X0Y1 { get; set; }
        double X2Y0 { get; set; }
        double X1Y1 { get; set; }
        double X0Y2 { get; set; }
        double X3Y0 { get; set; }
        double X2Y1 { get; set; }
        double X1Y2 { get; set; }
        double X0Y3 { get; set; }
        double X4Y0 { get; set; }
        double X3Y1 { get; set; }
        double X2Y2 { get; set; }
        double X1Y3 { get; set; }
        double X0Y4 { get; set; }
        double X5Y0 { get; set; }
        double X4Y1 { get; set; }
        double X3Y2 { get; set; }
        double X2Y3 { get; set; }
        double X1Y4 { get; set; }
        double X0Y5 { get; set; }
        double X6Y0 { get; set; }
        double X5Y1 { get; set; }
        double X4Y2 { get; set; }
        double X3Y3 { get; set; }
        double X2Y4 { get; set; }
        double X1Y5 { get; set; }
        double X0Y6 { get; set; }
        double X7Y0 { get; set; }
        double X6Y1 { get; set; }
        double X5Y2 { get; set; }
        double X4Y3 { get; set; }
        double X3Y4 { get; set; }
        double X2Y5 { get; set; }
        double X1Y6 { get; set; }
        double X0Y7 { get; set; }
        double X8Y0 { get; set; }
        double X7Y1 { get; set; }
        double X6Y2 { get; set; }
        double X5Y3 { get; set; }
        double X4Y4 { get; set; }
        double X3Y5 { get; set; }
        double X2Y6 { get; set; }
        double X1Y7 { get; set; }
        double X0Y8 { get; set; }
        double X9Y0 { get; set; }
        double X8Y1 { get; set; }
        double X7Y2 { get; set; }
        double X6Y3 { get; set; }
        double X5Y4 { get; set; }
        double X4Y5 { get; set; }
        double X3Y6 { get; set; }
        double X2Y7 { get; set; }
        double X1Y8 { get; set; }
        double X0Y9 { get; set; }
        double X10Y0 { get; set; }
        double X9Y1 { get; set; }
        double X8Y2 { get; set; }
        double X7Y3 { get; set; }
        double X6Y4 { get; set; }
        double X5Y5 { get; set; }
        double X4Y6 { get; set; }
        double X3Y7 { get; set; }
        double X2Y8 { get; set; }
        double X1Y9 { get; set; }
        double X0Y10 { get; set; }
        double X11Y0 { get; set; }
        double X10Y1 { get; set; }
        double X9Y2 { get; set; }
        double X8Y3 { get; set; }
        double X7Y4 { get; set; }
        double X6Y5 { get; set; }
        double X5Y6 { get; set; }
        double X4Y7 { get; set; }
        double X3Y8 { get; set; }
        double X2Y9 { get; set; }
        double X1Y10 { get; set; }
        double X0Y11 { get; set; }
        double X12Y0 { get; set; }
        double X11Y1 { get; set; }
        double X10Y2 { get; set; }
        double X9Y3 { get; set; }
        double X8Y4 { get; set; }
        double X7Y5 { get; set; }
        double X6Y6 { get; set; }
        double X5Y7 { get; set; }
        double X4Y8 { get; set; }
        double X3Y9 { get; set; }
        double X2Y10 { get; set; }
        double X1Y11 { get; set; }
        double X0Y12 { get; set; }
        double X13Y0 { get; set; }
        double X12Y1 { get; set; }
        double X11Y2 { get; set; }
        double X10Y3 { get; set; }
        double X9Y4 { get; set; }
        double X8Y5 { get; set; }
        double X7Y6 { get; set; }
        double X6Y7 { get; set; }
        double X5Y8 { get; set; }
        double X4Y9 { get; set; }
        double X3Y10 { get; set; }
        double X2Y11 { get; set; }
        double X1Y12 { get; set; }
        double X0Y13 { get; set; }
        double X14Y0 { get; set; }
        double X13Y1 { get; set; }
        double X12Y2 { get; set; }
        double X11Y3 { get; set; }
        double X10Y4 { get; set; }
        double X9Y5 { get; set; }
        double X8Y6 { get; set; }
        double X7Y7 { get; set; }
        double X6Y8 { get; set; }
        double X5Y9 { get; set; }
        double X4Y10 { get; set; }
        double X3Y11 { get; set; }
        double X2Y12 { get; set; }
        double X1Y13 { get; set; }
        double X0Y14 { get; set; }
        double X15Y0 { get; set; }
        double X14Y1 { get; set; }
        double X13Y2 { get; set; }
        double X12Y3 { get; set; }
        double X11Y4 { get; set; }
        double X10Y5 { get; set; }
        double X9Y6 { get; set; }
        double X8Y7 { get; set; }
        double X7Y8 { get; set; }
        double X6Y9 { get; set; }
        double X5Y10 { get; set; }
        double X4Y11 { get; set; }
        double X3Y12 { get; set; }
        double X2Y13 { get; set; }
        double X1Y14 { get; set; }
        double X0Y15 { get; set; }
        double X16Y0 { get; set; }
        double X15Y1 { get; set; }
        double X14Y2 { get; set; }
        double X13Y3 { get; set; }
        double X12Y4 { get; set; }
        double X11Y5 { get; set; }
        double X10Y6 { get; set; }
        double X9Y7 { get; set; }
        double X8Y8 { get; set; }
        double X7Y9 { get; set; }
        double X6Y10 { get; set; }
        double X5Y11 { get; set; }
        double X4Y12 { get; set; }
        double X3Y13 { get; set; }
        double X2Y14 { get; set; }
        double X1Y15 { get; set; }
        double X0Y16 { get; set; }
        double X17Y0 { get; set; }
        double X16Y1 { get; set; }
        double X15Y2 { get; set; }
        double X14Y3 { get; set; }
        double X13Y4 { get; set; }
        double X12Y5 { get; set; }
        double X11Y6 { get; set; }
        double X10Y7 { get; set; }
        double X9Y8 { get; set; }
        double X8Y9 { get; set; }
        double X7Y10 { get; set; }
        double X6Y11 { get; set; }
        double X5Y12 { get; set; }
        double X4Y13 { get; set; }
        double X3Y14 { get; set; }
        double X2Y15 { get; set; }
        double X1Y16 { get; set; }
        double X0Y17 { get; set; }
        double X18Y0 { get; set; }
        double X17Y1 { get; set; }
        double X16Y2 { get; set; }
        double X15Y3 { get; set; }
        double X14Y4 { get; set; }
        double X13Y5 { get; set; }
        double X12Y6 { get; set; }
        double X11Y7 { get; set; }
        double X10Y8 { get; set; }
        double X9Y9 { get; set; }
        double X8Y10 { get; set; }
        double X7Y11 { get; set; }
        double X6Y12 { get; set; }
        double X5Y13 { get; set; }
        double X4Y14 { get; set; }
        double X3Y15 { get; set; }
        double X2Y16 { get; set; }
        double X1Y17 { get; set; }
        double X0Y18 { get; set; }
        double X19Y0 { get; set; }
        double X18Y1 { get; set; }
        double X17Y2 { get; set; }
        double X16Y3 { get; set; }
        double X15Y4 { get; set; }
        double X14Y5 { get; set; }
        double X13Y6 { get; set; }
        double X12Y7 { get; set; }
        double X11Y8 { get; set; }
        double X10Y9 { get; set; }
        double X9Y10 { get; set; }
        double X8Y11 { get; set; }
        double X7Y12 { get; set; }
        double X6Y13 { get; set; }
        double X5Y14 { get; set; }
        double X4Y15 { get; set; }
        double X3Y16 { get; set; }
        double X2Y17 { get; set; }
        double X1Y18 { get; set; }
        double X0Y19 { get; set; }
        double X20Y0 { get; set; }
        double X19Y1 { get; set; }
        double X18Y2 { get; set; }
        double X17Y3 { get; set; }
        double X16Y4 { get; set; }
        double X15Y5 { get; set; }
        double X14Y6 { get; set; }
        double X13Y7 { get; set; }
        double X12Y8 { get; set; }
        double X11Y9 { get; set; }
        double X10Y10 { get; set; }
        double X9Y11 { get; set; }
        double X8Y12 { get; set; }
        double X7Y13 { get; set; }
        double X6Y14 { get; set; }
        double X5Y15 { get; set; }
        double X4Y16 { get; set; }
        double X3Y17 { get; set; }
        double X2Y18 { get; set; }
        double X1Y19 { get; set; }
        double X0Y20 { get; set; }
        double X21Y0 { get; set; }
        double X20Y1 { get; set; }
        double X19Y2 { get; set; }
        double X18Y3 { get; set; }
        double X17Y4 { get; set; }
        double X16Y5 { get; set; }
        double X15Y6 { get; set; }
        double X14Y7 { get; set; }
        double X13Y8 { get; set; }
        double X12Y9 { get; set; }
        double X11Y10 { get; set; }
        double X10Y11 { get; set; }
        double X9Y12 { get; set; }
        double X8Y13 { get; set; }
        double X7Y14 { get; set; }
        double X6Y15 { get; set; }
        double X5Y16 { get; set; }
        double X4Y17 { get; set; }
        double X3Y18 { get; set; }
        double X2Y19 { get; set; }
        #endregion
    }

    [ComVisible(true)]
    [Guid("751C6D6A-BD6C-4BB1-997F-2A48973A84DE")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceNthOrderTerms : ISurface
    {
        IEditorCell NthOrderTermCell(int n);

        double GetNthOrderTerm(int n);
        void SetNthOrderTerm(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("A518FF41-058E-4081-93BD-FADAC1914861")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceNthEvenOrderTerms : ISurface
    {
        IEditorCell NthEvenOrderTermCell(int n);

        double GetNthEvenOrderTerm(int n);
        void SetNthEvenOrderTerm(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("7B119854-B3C6-49C9-A076-C5DD23D04F14")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceNthThickness : ISurface
    {
        IEditorCell NumberOfTermsCell { get; }
        int NumberOfTerms { get; set; }

        IEditorCell NthThicknessCell(int n);

        double GetNthThickness(int n);
        void SetNthThickness(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("BEAA3DA7-A16D-4AC7-A7E6-CA2EF2ABFC9E")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCoeff_P_NthPower : ISurface
    {
        IEditorCell NumberOfTermsCell { get; }
        int NumberOfTerms { get; set; }

        IEditorCell Coeff_P_NthPowerCell(int n);

        double GetCoeff_P_NthPower(int n);
        void SetCoeff_P_NthPower(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("D1F2452C-ED16-4649-AA1A-F6E44B4D6F82")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCoeff_R_NthPower : ISurface
    {
        IEditorCell Coeff_R_NthPowerCell(int n);

        double GetCoeff_R_NthPower(int n);
        void SetCoeff_R_NthPower(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("5E588941-4723-4BDE-AB61-A0EC79A37043")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCoeff_P_NthEvenPower : ISurface
    {
        IEditorCell NumberOfTermsCell { get; }
        int NumberOfTerms { get; set; }

        IEditorCell Coeff_P_NthEvenPowerCell(int n);

        double GetCoeff_P_NthEvenPower(int n);
        void SetCoeff_P_NthEvenPower(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("8631F57E-CD98-4062-9B31-A2156D525CB8")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCoeff_R_NthEvenPower : ISurface
    {
        IEditorCell NumberOfTermsCell { get; }
        int NumberOfTerms { get; set; }

        IEditorCell Coeff_R_NthEvenPowerCell(int n);

        double GetCoeff_R_NthEvenPower(int n);
        void SetCoeff_R_NthEvenPower(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("3F83B66B-EC9F-444E-92B5-137EF364A275")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCoeff_X_NthEvenPower_8 : ISurface
    {
        IEditorCell Coeff_X_NthEvenPowerCell(int n);

        double GetCoeff_X_NthEvenPower(int n);
        void SetCoeff_X_NthEvenPower(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("6998DB38-AE18-4AC5-8B21-DD15025B1FF0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCoeff_X_NthEvenPower : ISurface
    {
        IEditorCell NumberOfTermsCell { get; }
        int NumberOfTerms { get; set; }

        IEditorCell Coeff_X_NthEvenPowerCell(int n);

        double GetCoeff_X_NthEvenPower(int n);
        void SetCoeff_X_NthEvenPower(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("5EB29F42-52A8-4A2D-B183-1A9C6D956E90")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCoeff_Y_NthEvenPower_8 : ISurface
    {
        IEditorCell Coeff_Y_NthEvenPowerCell(int n);

        double GetCoeff_Y_NthEvenPower(int n);
        void SetCoeff_Y_NthEvenPower(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("D05054E1-7AA3-4164-A7E4-3FDA1E585BDB")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCoeff_Y_NthEvenPower : ISurface
    {
        IEditorCell NumberOfTermsCell { get; }
        int NumberOfTerms { get; set; }

        IEditorCell Coeff_Y_NthEvenPowerCell(int n);

        double GetCoeff_Y_NthEvenPower(int n);
        void SetCoeff_Y_NthEvenPower(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("D4347BC1-7605-4747-96F3-F6C47F023662")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCoeff_X1P1X2P2_NthEvenPower : ISurface
    {
        IEditorCell Coeff_X1_NthEvenPowerCell(int n);

        double GetCoeff_X1_NthEvenPower(int n);
        void SetCoeff_X1_NthEvenPower(int n, double Value);

        IEditorCell Coeff_P1_NthEvenPowerCell(int n);

        double GetCoeff_P1_NthEvenPower(int n);
        void SetCoeff_P1_NthEvenPower(int n, double Value);

        IEditorCell Coeff_X2_NthEvenPowerCell(int n);

        double GetCoeff_X2_NthEvenPower(int n);
        void SetCoeff_X2_NthEvenPower(int n, double Value);

        IEditorCell Coeff_P2_NthEvenPowerCell(int n);

        double GetCoeff_P2_NthEvenPower(int n);
        void SetCoeff_P2_NthEvenPower(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("D81FC75D-9990-4B07-9960-1737E7FBED37")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceNthZernike : ISurface
    {// SurfaceType.GridSag: return seqSurfaceType.SURF_GRID_SAG GRID_SAG

        IEditorCell NumberOfTermsCell { get; }
        IEditorCell NormRadiusCell { get; }

        IEditorCell NthZernikeCoefficientCell(int n);

        int NumberOfTerms { get; set; }
        double NormRadius { get; set; }

        double GetNthZernikeCoefficient(int n);
        void SetNthZernikeCoefficient(int n, double Value);
    };

    [ComVisible(true)]
    [Guid("E6AB5901-AF73-476D-868B-EF5B9CB2F9E3")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceFreeformNthZernike : ISurface
    {
        IEditorCell NumberOfZernikeTermsCell { get; }
        IEditorCell NormRadiusCell { get; }

        IEditorCell NthZernikeCoefficientCell(int n);

        int NumberOfZernikeTerms { get; set; }
        double NormRadius { get; set; }

        double GetNthZernikeCoefficient(int n);
        void SetNthZernikeCoefficient(int n, double Value);
    };

    [ComVisible(true)]
    [Guid("1468C9E7-0CF7-4BF8-8AD4-7A7BF86C6254")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceAPBC : ISurface
    {
        IEditorCell AnCell(int n);
        IEditorCell PnCell(int n);
        IEditorCell BnCell(int n);
        IEditorCell CnCell(int n);

        double GetAn(int n);
        void SetAn(int n, double Value);

        double GetPn(int n);
        void SetPn(int n, double Value);

        double GetBn(int n);
        void SetBn(int n, double Value);

        double GetCn(int n);
        void SetCn(int n, double Value);
    }

    [ComVisible(true)]
    [Guid("CA5F5E13-ED59-4E80-9375-D93DE6BD1981")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceStandard : ISurface
    {
        // no additional parameters
    }

    [ComVisible(true)]
    [Guid("735BC140-2235-47E0-B96E-BBFCB244754A")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceABCD : ISurface
    {// SurfaceType.ABCD: return seqSurfaceType.SURF_ABCDSURF ABCDSURF
        IEditorCell AxCell { get; }
        IEditorCell BxCell { get; }
        IEditorCell CxCell { get; }
        IEditorCell DxCell { get; }
        IEditorCell AyCell { get; }
        IEditorCell ByCell { get; }
        IEditorCell CyCell { get; }
        IEditorCell DyCell { get; }

        double Ax { get; set; }
        double Bx { get; set; }
        double Cx { get; set; }
        double Dx { get; set; }
        double Ay { get; set; }
        double By { get; set; }
        double Cy { get; set; }
        double Dy { get; set; }
    };

    [ComVisible(true)]
    [Guid("A6195FDB-56FE-4E67-B64B-E5FC6526FE59")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceAlternateEven : ISurfaceNthEvenOrderTerms
    {// SurfaceType.AlternateEven: return seqSurfaceType.SURF_ALTERNAT ALTERNAT
    };

    [ComVisible(true)]
    [Guid("7014F570-7E9B-4360-B326-5CBAE6C63923")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceAlternateOdd : ISurfaceNthOrderTerms
    {// SurfaceType.AlternateOdd: return seqSurfaceType.SURF_ALTERNAO ALTERNAO
    };

    [ComVisible(true)]
    [Guid("AAE74124-AE40-4BBD-8AD5-4BBBE212412C")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceAnnularZernikeSag : ISurfaceNthEvenOrderTerms
    {// SurfaceType.AnnularZernikeSag: return seqSurfaceType.SURF_AZERNSAG AZERNSAG
        IEditorCell ExtrapolateCell { get; }
        IEditorCell ObscurationCell { get; }
        IEditorCell NumberOfTermsCell { get; }
        IEditorCell NormRadiusCell { get; }
        IEditorCell GetZernikeTermCell(int termN);

        int Extrapolate { get; set; }
        double Obscuration { get; set; }
        int NumberOfTerms { get; set; }
        double NormRadius { get; set; }

        double GetZernikeTerm(int termN);
        void SetZernikeTerm(int termN, double Value);

    };

    [ComVisible(true)]
    [Guid("71430E2E-4C44-4116-A412-4F31BC6D3889")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceAtmospheric : ISurface
    {// SurfaceType.Atmospheric: return seqSurfaceType.SURF_ATMOSPHR ATMOSPHR
        IEditorCell ZenithCell { get; }
        IEditorCell HeightCell { get; }
        IEditorCell TemperatureCell { get; }
        IEditorCell PressureCell { get; }
        IEditorCell HumidityCell { get; }
        IEditorCell LatitudeCell { get; }
        IEditorCell IsAbsoluteCell { get; }

        double Zenith { get; set; }
        double Height { get; set; }
        double Temperature { get; set; }
        double Pressure { get; set; }
        double Humidity { get; set; }
        double Latitude { get; set; }
        bool IsAbsolute { get; set; }
    };

    [ComVisible(true)]
    [Guid("FADA3847-9FD9-4C02-8A6A-3AF139E5A4E2")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceBiconic : ISurface
    {// SurfaceType.Biconic: return seqSurfaceType.SURF_BICONICX BICONICX
        IEditorCell XRadiusCell { get; }
        IEditorCell XConicCell { get; }

        double XRadius { get; set; }
        double XConic { get; set; }
    };

    [ComVisible(true)]
    [Guid("17A514FC-ACEA-4B5A-8EC9-C61119437B6D")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceBiconicZernike : ISurface
    {// SurfaceType.BiconicZernike: return seqSurfaceType.SURF_BICONICZ BICONICZ
        IEditorCell ExtrapolateCell { get; }
        IEditorCell XRadiusCell { get; }
        IEditorCell XConicCell { get; }
        IEditorCell NumberOfTermsCell { get; }
        IEditorCell NormRadiusCell { get; }

        int Extrapolate { get; set; }
        double XRadius { get; set; }
        double XConic { get; set; }
        int NumberOfTerms { get; set; }
        double NormRadius { get; set; }

        IEditorCell GetCellXn(int n);
        IEditorCell GetCellYn(int n);
        IEditorCell GetCellZn(int n);

        double GetXn(int n);
        double GetYn(int n);
        double GetZn(int n);

        void SetXn(int n, double v);
        void SetYn(int n, double v);
        void SetZn(int n, double v);
    }

    [ComVisible(true)]
    [Guid("6705DCAE-ED22-44F5-8349-F18B5EF13C85")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceBinary1 : ISurfaceXYPolynomial, ISurfaceNthEvenOrderTerms
    {// SurfaceType.Binary1: return seqSurfaceType.SURF_BINARY_1 BINARY_1

        IEditorCell DiffractOrderCell { get; }
        IEditorCell IsAbsoluteCell { get; }
        IEditorCell NormRadiusCell { get; }

        double DiffractOrder { get; set; }
        bool IsAbsolute { get; set; }
        double NormRadius { get; set; }

    };

    [ComVisible(true)]
    [Guid("88A297A5-206C-4C82-94E0-A572DE1D40ED")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceBinary2 : ISurfaceCoeff_P_NthEvenPower, ISurfaceNthEvenOrderTerms
    {// SurfaceType.Binary2: return seqSurfaceType.SURF_BINARY_2 BINARY_2
        IEditorCell DiffractOrderCell { get; }
        IEditorCell NormRadiusCell { get; }

        double DiffractOrder { get; set; }
        double NormRadius { get; set; }

    };

    [ComVisible(true)]
    [Guid("C0EE1B60-5999-4E1F-9410-BB67946661A1")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceBinary3 : ISurface
    {// SurfaceType.Binary3: return seqSurfaceType.SURF_BINARY_3 BINARY_3
        IEditorCell R2Cell { get; }
        IEditorCell K2Cell { get; }
        IEditorCell A1Cell { get; }
        IEditorCell A2Cell { get; }
        IEditorCell M1Cell { get; }
        IEditorCell M2Cell { get; }
        IEditorCell SinDeltaZeroCell { get; }
        IEditorCell BreakCell { get; }

        double R2 { get; set; }
        double K2 { get; set; }
        double A1 { get; set; }
        double A2 { get; set; }
        double M1 { get; set; }
        double M2 { get; set; }
        double SinDeltaZero { get; set; }
        bool Break { get; set; }
    };

    [ComVisible(true)]
    [Guid("5FA944ED-1A9D-414C-B59C-E6D401DD825C")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceBinary4 : ISurface
    {// SurfaceType.Binary4: return seqSurfaceType.SURF_BINARY_4 BINARY_4
        IEditorCell NumberOfRadialZonesCell { get; }
        IEditorCell NumberOfAsphericTermsCell { get; }
        IEditorCell NumberOfPhaseTermsCell { get; }
        IEditorCell SineDeltaZeroCell { get; }
        IEditorCell RadialApertureInZoneCell(int zoneN);
        IEditorCell RadiusInZoneCell(int zoneN);
        IEditorCell ConicInZoneCell(int zoneN);
        IEditorCell OrderInZoneCell(int zoneN);
        IEditorCell AsphereInZone_P_NthEvenPowerCell(int zoneN, int n);
        IEditorCell PhaseInZone_P_NthEvenPowerCell(int zoneN, int n);

        int NumberOfRadialZones { get; set; }
        int NumberOfAsphericTerms { get; set; }
        int NumberOfPhaseTerms { get; set; }
        double SineDeltaZero { get; set; }

        double GetRadialApertureInZone(int zoneN);
        void SetRadialApertureInZone(int zoneN, double Value);

        double GetRadiusInZone(int zoneN);
        void SetRadiusInZone(int zoneN, double Value);

        double GetConicInZone(int zoneN);
        void SetConicInZone(int zoneN, double Value);

        double GetOrderInZone(int zoneN);
        void SetOrderInZone(int zoneN, double Value);

        double GetAsphereInZone_P_NthEvenPower(int zoneN, int n);
        void SetAsphereInZone_P_NthEvenPower(int zoneN, int n, double Value);

        double GetPhaseInZone_P_NthEvenPower(int zoneN, int n);
        void SetPhaseInZone_P_NthEvenPower(int zoneN, int n, double Value);
    };

    [ComVisible(true)]
    [Guid("F8BBB68A-6313-49D2-AC10-6846EABFA580")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceBirefringentIn : ISurface
    {// SurfaceType.BirefringentIn: return seqSurfaceType.SURF_BIRE__IN BIRE__IN
        IEditorCell DrawAxisCell { get; }
        IEditorCell ModeCell { get; }
        IEditorCell X_CosineCell { get; }
        IEditorCell Y_CosineCell { get; }
        IEditorCell Z_CosineCell { get; }
        IEditorCell IgnoreParaxialRaysCell { get; }
        IEditorCell ShapeCell { get; }
        IEditorCell RadiusOfRotationCell { get; }
        IEditorCell NthEvenOrderTermCell(int n);

        IEditorCell GradientModeCell { get; }
        IEditorCell DeltaTCell { get; }

        //  Gradient Mode == 1

        IEditorCell CxCell(int n);
        IEditorCell CyCell(int n);

        //  Gradient Mode == 2

        IEditorCell CzCell(int n);

        //  Gradient Mode == 3 || Mode == 5

        IEditorCell PhiCell(int n);

        //  Gradient Mode == 4

        IEditorCell aCell(int n);

        //  Gradient Mode == 6

        IEditorCell OCell { get; }
        IEditorCell ECell { get; }
        IEditorCell ACell { get; }
        IEditorCell BCell { get; }

        //  Gradient Mode == 7

        IEditorCell Mode7CxCell(int n);
        IEditorCell azCell { get; }

        //  Gradient Mode == 8

        IEditorCell Z0Cell { get; }
        IEditorCell ZnCell { get; }

        IEditorCell CmnCell(int m, int n);

        double DrawAxis { get; set; }
        int Mode { get; set; }
        double X_Cosine { get; set; }
        double Y_Cosine { get; set; }
        double Z_Cosine { get; set; }
        bool IgnoreParaxialRays { get; set; }
        int Shape { get; set; }
        double RadiusOfRotation { get; set; }
        double GetNthEvenOrderTerm(int n);
        void SetNthEvenOrderTerm(int n, double Value);

        int GradientMode { get; set; }
        double DeltaT { get; set; }

        //  Gradient Mode == 1

        double GetCx(int n);
        void SetCx(int n, double Value);
        double GetCy(int n);
        void SetCy(int n, double Value);

        //  Gradient Mode 2

        double GetCz(int n);
        void SetCz(int n, double Value);

        //  Gradient Mode == 3 || Mode == 5

        double GetPhi(int n);
        void SetPhi(int n, double Value);

        //  Gradient Mode == 4

        double Get_a(int n);
        void Set_a(int n, double Value);

        //  Gradient Mode == 6

        double O { get; set; }
        double E { get; set; }
        double A { get; set; }
        double B { get; set; }

        //  Gradient Mode == 7

        double GetMode7Cx(int n);
        void SetMode7Cx(int n, double Value);
        double az { get; set; }

        //  Gradient Mode == 8

        double Z0 { get; set; }
        double Zn { get; set; }

        double GetCmn(int m, int n);
        void SetCmn(int m, int n, double Value);
    };

    [ComVisible(true)]
    [Guid("484C1B7B-F53F-4085-968C-658909DD3989")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceBirefringentOut : ISurfaceNthEvenOrderTerms
    {// SurfaceType.BirefringentOut: return seqSurfaceType.SURF_BIRE_OUT BIRE_OUT
        IEditorCell ShapeCell { get; }
        IEditorCell RadiusOfRotationCell { get; }

        int Shape { get; set; }
        double RadiusOfRotation { get; set; }

    };

    [ComVisible(true)]
    [Guid("BE3A6768-2025-41C5-9619-DCC35E290B2F")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceBlackBoxLens : ISurface
    {// SurfaceType.BlackBoxLens: return seqSurfaceType.SURF_BLACKBOX BLACKBOX

        int NumberOfAvailableBlackBoxLensFilenames { get; }
        string GetBlackBoxLensFilenameAt(int idx);

        string BlackBoxLensFilename { get; set; }
    };

    [ComVisible(true)]
    [Guid("EB95A026-36EB-4259-BAA1-B3B70CE62D53")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceChebyShv : ISurface
    {// SurfaceType.ChebyShv: return seqSurfaceType.SURF_CHEBYSHV CHEBYSHV
        IEditorCell NumberOf_X_OrdersCell { get; }
        IEditorCell NumberOf_Y_OrdersCell { get; }
        IEditorCell Norm_X_LengthCell { get; }
        IEditorCell Norm_Y_LengthCell { get; }

        IEditorCell CxyCell(int orderX, int orderY);

        int NumberOf_X_Orders { get; set; }
        int NumberOf_Y_Orders { get; set; }
        double Norm_X_Length { get; set; }
        double Norm_Y_Length { get; set; }

        double GetCxy(int orderX, int orderY);
        void SetCxy(int orderX, int orderY, double Value);
    };

    [ComVisible(true)]
    [Guid("7089CB24-8485-4D35-B982-17A1EE5EF589")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceConjugate : ISurface
    {// SurfaceType.Conjugate: return seqSurfaceType.SURF_CONJUGAT CONJUGAT
        IEditorCell X1_Cell { get; }
        IEditorCell Y1_Cell { get; }
        IEditorCell Z1_Cell { get; }
        IEditorCell X2_Cell { get; }
        IEditorCell Y2_Cell { get; }
        IEditorCell Z2_Cell { get; }

        double X1 { get; set; }
        double Y1 { get; set; }
        double Z1 { get; set; }
        double X2 { get; set; }
        double Y2 { get; set; }
        double Z2 { get; set; }
    };

    [ComVisible(true)]
    [Guid("9AA2D1DA-633C-49BD-AB74-403FFB266F22")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCoordinateBreak : ISurface
    {// SurfaceType.CoordinateBreak: return seqSurfaceType.SURF_COORDBRK COORDBRK
        IEditorCell Decenter_X_Cell { get; }
        IEditorCell Decenter_Y_Cell { get; }
        IEditorCell TiltAbout_X_Cell { get; }
        IEditorCell TiltAbout_Y_Cell { get; }
        IEditorCell TiltAbout_Z_Cell { get; }
        IEditorCell OrderCell { get; }

        double Decenter_X { get; set; }
        double Decenter_Y { get; set; }
        double TiltAbout_X { get; set; }
        double TiltAbout_Y { get; set; }
        double TiltAbout_Z { get; set; }
        int Order { get; set; }
    };

    [ComVisible(true)]
    [Guid("70A721DC-D8D3-4A71-A824-B9CB084ABD49")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCubicSpline : ISurface
    {// SurfaceType.CubicSpline: return seqSurfaceType.SURF_CUSPLINE CUSPLINE

        IEditorCell Z_nEigthsCell(int n);

        double Get_Z_nEighths(int n);
        void Set_Z_nEighths(int n, double Value);
    };

    [ComVisible(true)]
    [Guid("DA4946D0-57F2-4CB7-B579-F3D15FAADBF9")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCylinderFrensel : ISurface, ISurfaceNthEvenOrderTerms, ISurfaceCoeff_Y_NthEvenPower
    {// SurfaceType.CylinderFrensel: return seqSurfaceType.SURF_CFRESNEL CFRESNEL

        IEditorCell CurvatureCell { get; }
        IEditorCell ConicCell { get; }

        double Curvature { get; set; }
        double Conic { get; set; }

    };

    [ComVisible(true)]
    [Guid("0ABE1002-B752-4E0C-8C90-30BC319EC3C6")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceCylinderFresnel : ISurface, ISurfaceNthEvenOrderTerms, ISurfaceCoeff_Y_NthEvenPower
    {// SurfaceType.CylinderFrensel: return seqSurfaceType.SURF_CFRESNEL CFRESNEL

        IEditorCell CurvatureCell { get; }
        IEditorCell ConicCell { get; }

        double Curvature { get; set; }
        double Conic { get; set; }

    };

    [ComVisible(true)]
    [Guid("1CD33AA5-DCBD-4DD3-9277-19684F0F2B02")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceData : ISurface
    {// SurfaceType.Data: return seqSurfaceType.SURF_DATASURF DATASURF

        IEditorCell NthExtraDataCell(int n);

        double GetNthExtraData(int n);
        void SetNthExtraData(int n, double Value);
    };

    [ComVisible(true)]
    [Guid("B5FF855C-B239-4A3E-BB70-ADDF3D206918")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceDiffractionGrating : ISurface
    {// SurfaceType.DiffractionGrating: return seqSurfaceType.SURF_DGRATING DGRATING

        IEditorCell LinesPerMicroMeterCell { get; }
        IEditorCell DiffractionOrderCell { get; }

        double LinesPerMicroMeter { get; set; }
        double DiffractionOrder { get; set; }
    };

    [ComVisible(true)]
    [Guid("29BC3501-E30B-423A-8C3B-9C3542AE64CD")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceEllipticalGrating1 : ISurfaceXYPolynomial
    {// SurfaceType.EllipticalGrating1: return seqSurfaceType.SURF_ELLIGRAT ELLIGRAT

        IEditorCell LinesPerMicroMeterCell { get; }
        IEditorCell DiffractionOrderCell { get; }
        IEditorCell aCell { get; }
        IEditorCell bCell { get; }
        IEditorCell cCell { get; }
        IEditorCell AlphaCell { get; }
        IEditorCell BetaCell { get; }
        IEditorCell GammaCell { get; }
        IEditorCell DeltaCell { get; }
        IEditorCell EpsilonCell { get; }

        IEditorCell NormRadiusCell { get; }

        double LinesPerMicroMeter { get; set; }
        double DiffractionOrder { get; set; }
        double a { get; set; }
        double b { get; set; }
        double c { get; set; }
        double Alpha { get; set; }
        double Beta { get; set; }
        double Gamma { get; set; }
        double Delta { get; set; }
        double Epsilon { get; set; }

        double NormRadius { get; set; }
    };

    [ComVisible(true)]
    [Guid("A0357781-22C6-4FFB-8531-8A6E2DCEF409")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceEllipticalGrating2 : ISurfaceXYPolynomial
    {// SurfaceType.EllipticalGrating2: return seqSurfaceType.SURF_ELLIGRA2 ELLIGRA2

        IEditorCell LinesPerMicroMeterCell { get; }
        IEditorCell DiffractionOrderCell { get; }
        IEditorCell aCell { get; }
        IEditorCell bCell { get; }
        IEditorCell cCell { get; }
        IEditorCell ThetaCell { get; }

        IEditorCell NormRadiusCell { get; }

        double LinesPerMicroMeter { get; set; }
        double DiffractionOrder { get; set; }
        double a { get; set; }
        double b { get; set; }
        double c { get; set; }
        double Theta { get; set; }

        double NormRadius { get; set; }
    };

    [ComVisible(true)]
    [Guid("5127F082-F2BE-45AD-8C01-38B62B276047")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceEvenAspheric : ISurface, ISurfaceNthEvenOrderTerms
    {// SurfaceType.EvenAspheric: return seqSurfaceType.SURF_EVENASPH EVENASPH
    };

    [ComVisible(true)]
    [Guid("299F052E-CA77-42F6-A140-094A44389601")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceExtendedToroidalGrating : ISurfaceXYPolynomial, ISurfaceNthEvenOrderTerms
    {// SurfaceType.ExtendedToroidalGrating: return seqSurfaceType.SURF_TOROGRAX TOROGRAX

        IEditorCell RadiusOfRotationCell { get; }
        IEditorCell LinesPerMicroMeterCell { get; }
        IEditorCell DiffractionOrderCell { get; }

        double RadiusOfRotation { get; set; }
        double LinesPerMicroMeter { get; set; }
        double DiffractionOrder { get; set; }

        IEditorCell NormRadiusCell { get; }

        double NormRadius { get; set; }

    };

    [ComVisible(true)]
    [Guid("E0550C75-793E-4C71-A8F0-2E4EEBF6F9C8")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceExtendedAsphere : ISurfaceCoeff_P_NthEvenPower
    {// SurfaceType.ExtendedAsphere: return seqSurfaceType.SURF_XASPHERE XASPHERE

        IEditorCell NormRadiusCell { get; }

        double NormRadius { get; set; }
    };

    [ComVisible(true)]
    [Guid("1D657164-B039-42C4-A255-CB6D4A3009B0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceExtendedCubicSpline : ISurface
    {// SurfaceType.ExtendedCubicSpline: return seqSurfaceType.SURF_XCUSPLIN XCUSPLIN

        IEditorCell NumberOfStepsCell { get; }
        IEditorCell StepSizeCell { get; }

        IEditorCell SagAtNthStepCell(int n);

        int NumberOfSteps { get; set; }
        double StepSize { get; set; }

        double GetSagAtNthStep(int n);
        void SetSagAtNthStep(int n, double Value);
    };

    [ComVisible(true)]
    [Guid("76BF0805-5CFB-4D0A-8BE6-8FD684E27736")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceExtendedFresnel : ISurface, ISurfaceNthEvenOrderTerms, ISurfaceCoeff_R_NthEvenPower
    {// SurfaceType.ExtendedFresnel: return seqSurfaceType.SURF_XFRESNEL XFRESNEL

        IEditorCell CurvatureCell { get; }
        IEditorCell ConicCell { get; }

        double Curvature { get; set; }
        double Conic { get; set; }

    };

    [ComVisible(true)]
    [Guid("928A96DB-9539-44A9-9570-2E21D62FFC93")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceExtendedOddAsphere : ISurface, ISurfaceCoeff_P_NthPower
    {// SurfaceType.ExtendedOddAsphere: return seqSurfaceType.SURF_XOSPHERE XOSPHERE

        IEditorCell NormRadiusCell { get; }

        double NormRadius { get; set; }
    };

    [ComVisible(true)]
    [Guid("CEBC6371-ECAE-47AD-B875-5F48E1B9D53C")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceExtendedPolynomial : ISurfaceXYPolynomial
    {// SurfaceType.ExtendedPolynomial: return seqSurfaceType.SURF_XPOLYNOM XPOLYNOM

        IEditorCell NormRadiusCell { get; }

        double NormRadius { get; set; }
    };

    [ComVisible(true)]
    [Guid("F9B4BED3-B199-48DE-8424-E92253C75AEF")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceFresnel : ISurfaceNthEvenOrderTerms
    {// SurfaceType.Fresnel: return seqSurfaceType.SURF_FRESNELS FRESNELS
    };

    [ComVisible(true)]
    [Guid("79A508DE-1A94-4842-88E3-FF48C7B3D59B")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGeneralizedFresnel : ISurfaceXYPolynomial, ISurfaceNthEvenOrderTerms
    {// SurfaceType.GeneralizedFresnel: return seqSurfaceType.SURF_GEN_FRES GEN_FRES

        IEditorCell NormRadiusCell { get; }

        double NormRadius { get; set; }

    };

    [ComVisible(true)]
    [Guid("4D79895B-2F63-4707-B232-ABD023EE5112")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradient1 : ISurface
    {// SurfaceType.Gradient1: return seqSurfaceType.SURF_GRINSUR1 GRINSUR1

        IEditorCell DeltaTCell { get; }
        IEditorCell n0Cell { get; }
        IEditorCell Nr2Cell { get; }
        IEditorCell Nr1Cell { get; }

        double DeltaT { get; set; }
        double n0 { get; set; }
        double Nr2 { get; set; }
        double Nr1 { get; set; }
    };

    [ComVisible(true)]
    [Guid("A6C133CD-6960-4B33-BC23-93B8BEC1356D")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradient2 : ISurface
    {// SurfaceType.Gradient2: return seqSurfaceType.SURF_GRINSUR2 GRINSUR2

        IEditorCell DeltaTCell { get; }
        IEditorCell n0Cell { get; }
        IEditorCell Nr2Cell { get; }
        IEditorCell Nr4Cell { get; }
        IEditorCell Nr6Cell { get; }
        IEditorCell Nr8Cell { get; }
        IEditorCell Nr10Cell { get; }
        IEditorCell Nr12Cell { get; }

        double DeltaT { get; set; }
        double n0 { get; set; }
        double Nr2 { get; set; }
        double Nr4 { get; set; }
        double Nr6 { get; set; }
        double Nr8 { get; set; }
        double Nr10 { get; set; }
        double Nr12 { get; set; }
    };

    [ComVisible(true)]
    [Guid("CA871284-CED0-44AC-8FA3-6871297E1AD3")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradient3 : ISurface
    {// SurfaceType.Gradient3: return seqSurfaceType.SURF_GRINSUR3 GRINSUR3

        IEditorCell DeltaTCell { get; }
        IEditorCell n0Cell { get; }
        IEditorCell Nr2Cell { get; }
        IEditorCell Nr4Cell { get; }
        IEditorCell Nr6Cell { get; }
        IEditorCell Nz1Cell { get; }
        IEditorCell Nz2Cell { get; }
        IEditorCell Nz3Cell { get; }

        double DeltaT { get; set; }
        double n0 { get; set; }
        double Nr2 { get; set; }
        double Nr4 { get; set; }
        double Nr6 { get; set; }
        double Nz1 { get; set; }
        double Nz2 { get; set; }
        double Nz3 { get; set; }
    };

    [ComVisible(true)]
    [Guid("DCA5BE1A-F3E2-473F-A894-E0984B83F37D")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradient4 : ISurface
    {// SurfaceType.Gradient4: seqSurfaceType.SURF_GRINSUR4 GRINSUR4

        IEditorCell DeltaTCell { get; }
        IEditorCell n0Cell { get; }
        IEditorCell Nx1Cell { get; }
        IEditorCell Nx2Cell { get; }
        IEditorCell Ny1Cell { get; }
        IEditorCell Ny2Cell { get; }
        IEditorCell Nz1Cell { get; }
        IEditorCell Nz2Cell { get; }

        double DeltaT { get; set; }
        double n0 { get; set; }
        double Nx1 { get; set; }
        double Nx2 { get; set; }
        double Ny1 { get; set; }
        double Ny2 { get; set; }
        double Nz1 { get; set; }
        double Nz2 { get; set; }
    };

    [ComVisible(true)]
    [Guid("85DD0F2D-6DAB-4DD1-A7CD-F24AC999D31C")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradient5 : ISurface
    {// SurfaceType.Gradient5: seqSurfaceType.SURF_GRINSUR5 GRINSUR5

        IEditorCell DeltaTCell { get; }
        IEditorCell n0Cell { get; }
        IEditorCell Nr2Cell { get; }
        IEditorCell Nr4Cell { get; }
        IEditorCell Nz1Cell { get; }
        IEditorCell Nz2Cell { get; }
        IEditorCell Nz3Cell { get; }
        IEditorCell Nz4Cell { get; }
        IEditorCell X_TangentCell { get; }
        IEditorCell Y_TangentCell { get; }

        double DeltaT { get; set; }
        double n0 { get; set; }
        double Nr2 { get; set; }
        double Nr4 { get; set; }
        double Nz1 { get; set; }
        double Nz2 { get; set; }
        double Nz3 { get; set; }
        double Nz4 { get; set; }
        double X_Tangent { get; set; }
        double Y_Tangent { get; set; }
    };

    [ComVisible(true)]
    [Guid("7A02EBBE-8A01-46A6-9B1D-A5BB25CFAE51")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradient6 : ISurface
    {// SurfaceType.Gradient6: seqSurfaceType.SURF_GRINSUR6 GRINSUR6

        IEditorCell DeltaTCell { get; }

        double DeltaT { get; set; }
    };

    [ComVisible(true)]
    [Guid("E1165182-191C-4B82-8537-A1CBB92A1BD4")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradient7 : ISurface
    {// SurfaceType.Gradient7: seqSurfaceType.SURF_GRINSUR7 GRINSUR7

        IEditorCell DeltaTCell { get; }
        IEditorCell n0Cell { get; }
        IEditorCell RCell { get; }
        IEditorCell AlphaCell { get; }
        IEditorCell BetaCell { get; }

        double DeltaT { get; set; }
        double n0 { get; set; }
        double R { get; set; }
        double Alpha { get; set; }
        double Beta { get; set; }
    };

    [ComVisible(true)]
    [Guid("C7CE2277-D2EA-4B8F-B367-BB57D503A456")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradient9 : ISurface
    {// SurfaceType.Gradient9: seqSurfaceType.SURF_GRINSUR9 GRINSUR9

        IEditorCell DeltaTCell { get; }
        IEditorCell X_TangentCell { get; }
        IEditorCell Y_TangentCell { get; }

        double DeltaT { get; set; }
        double X_Tangent { get; set; }
        double Y_Tangent { get; set; }
    };

    [ComVisible(true)]
    [Guid("1773E32A-67C3-4B2F-ADD4-CA5034DC49FC")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradient10 : ISurface
    {// SurfaceType.Gradient10: return seqSurfaceType.SURF_GRINSU10 GRINSU10

        IEditorCell DeltaTCell { get; }
        IEditorCell n0Cell { get; }
        IEditorCell Ny1Cell { get; }
        IEditorCell Ny2Cell { get; }
        IEditorCell Ny3Cell { get; }
        IEditorCell Ny4Cell { get; }
        IEditorCell Ny5Cell { get; }
        IEditorCell Ny6Cell { get; }

        double DeltaT { get; set; }
        double n0 { get; set; }
        double Ny1 { get; set; }
        double Ny2 { get; set; }
        double Ny3 { get; set; }
        double Ny4 { get; set; }
        double Ny5 { get; set; }
        double Ny6 { get; set; }
    };

    [ComVisible(true)]
    [Guid("D0C34AD0-2223-41D0-A4D3-C1880BD31738")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradient12 : ISurface
    {// SurfaceType.Gradient12: return seqSurfaceType.SURF_GRINSU12 GRINSU12

        IEditorCell DeltaTCell { get; }
        IEditorCell OrderCell { get; }
        IEditorCell n0Cell { get; }

        IEditorCell NthNxCell(int n);
        IEditorCell NthNyCell(int n);
        IEditorCell NthNzCell(int n);

        double DeltaT { get; set; }
        int Order { get; set; }
        double n0 { get; set; }

        double GetNthNx(int n);
        double GetNthNy(int n);
        double GetNthNz(int n);
        void SetNthNx(int n, double Value);
        void SetNthNy(int n, double Value);
        void SetNthNz(int n, double Value);
    };

    [ComVisible(true)]
    [Guid("79563EAD-6FCF-42DA-ACB5-EDC78871A64E")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGradium : ISurface
    {// SurfaceType.Gradium: return seqSurfaceType.SURF_GRINSUR8 GRINSUR8

        IEditorCell BouleThicknessCell { get; }
        IEditorCell DeltaTCell { get; }
        IEditorCell DeltaZCell { get; }
        IEditorCell Ref_n_Cell { get; }
        IEditorCell Dec_x_Cell { get; }
        IEditorCell Dec_y_Cell { get; }
        IEditorCell Tilt_x_Cell { get; }
        IEditorCell Tilt_y_Cell { get; }
        IEditorCell CappingCell { get; }

        double BouleThickness { get; set; }
        double DeltaT { get; set; }
        double DeltaZ { get; set; }
        double Ref_n { get; set; }
        double Dec_x { get; set; }
        double Dec_y { get; set; }
        double Tilt_x { get; set; }
        double Tilt_y { get; set; }
        double Capping { get; set; }
    };

    [ComVisible(true)]
    [Guid("CC9EB238-1A7F-4956-8937-EFA8364F0B26")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGridGradient : ISurface
    {// SurfaceType.GridGradient: return seqSurfaceType.SURF_GRINSU11 GRINSU11

        IEditorCell DeltaTCell { get; }

        double DeltaT { get; set; }
    };

    [ComVisible(true)]
    [Guid("16A5ED54-63D9-46CC-9FA7-23EC4FF018CC")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGridPhase : ISurface
    {// SurfaceType.GridPhase: return seqSurfaceType.SURF_GRID_PHA GRID_PHA

        IEditorCell DiffractOrderCell { get; }
        IEditorCell ShearDistanceCell { get; }
        IEditorCell InterpolateCell { get; }

        double DiffractOrder { get; set; }
        double ShearDistance { get; set; }
        InterpolationMethod Interpolate { get; set; }
    };

    [ComVisible(true)]
    [Guid("6412CE38-37DB-44CE-8B6C-9DACB606E4F7")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceGridSag : ISurfaceNthEvenOrderTerms, ISurfaceNthZernike
    {// SurfaceType.GridSag: return seqSurfaceType.SURF_GRID_SAG GRID_SAG

        IEditorCell InterpolateCell { get; }
        IEditorCell ZernikeDecenter_X_Cell { get; }
        IEditorCell ZernikeDecenter_Y_Cell { get; }

        InterpolationMethod Interpolate { get; set; }
        double ZernikeDecenter_X { get; set; }
        double ZernikeDecenter_Y { get; set; }

    };

    [ComVisible(true)]
    [Guid("91808826-3095-445D-A845-684AF478F99C")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceTrueFreeform : ISurfaceNthEvenOrderTerms, ISurfaceFreeformNthZernike, ISurfaceFreeformXYPolynomial
    {// SurfaceType.Freeform: return seqSurfaceType.SURF_FREEFORM FREEFORM

        IEditorCell NumVariablePointsCell { get; }
        IEditorCell RadiusXCell { get; }
        IEditorCell ConicXCell { get; }
        IEditorCell ZernikeDecenter_X_Cell { get; }
        IEditorCell ZernikeDecenter_Y_Cell { get; }

        double RadiusX { get; set; }
        double ConicX { get; set; }
        double ZernikeDecenter_X { get; set; }
        double ZernikeDecenter_Y { get; set; }
        int NumVariablePoints { get; }
    };

    [ComVisible(true)]
    [Guid("6C25EB5C-A7D3-4405-83D8-EFD97B535947")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceHologram1 : ISurface
    {// SurfaceType.Hologram1: return seqSurfaceType.SURF_HOLOGRM1 HOLOGRM1

        IEditorCell Construct_X1_Cell { get; }
        IEditorCell Construct_Y1_Cell { get; }
        IEditorCell Construct_Z1_Cell { get; }
        IEditorCell Construct_X2_Cell { get; }
        IEditorCell Construct_Y2_Cell { get; }
        IEditorCell Construct_Z2_Cell { get; }
        IEditorCell ConstructWaveCell { get; }
        IEditorCell DiffractOrderCell { get; }

        double Construct_X1 { get; set; }
        double Construct_Y1 { get; set; }
        double Construct_Z1 { get; set; }
        double Construct_X2 { get; set; }
        double Construct_Y2 { get; set; }
        double Construct_Z2 { get; set; }
        double ConstructWave { get; set; }
        double DiffractOrder { get; set; }

        IEditorCell IsVolumeHologramCell { get; }
        IEditorCell HologramThicknessCell { get; }
        IEditorCell n1Cell { get; }
        IEditorCell n2Cell { get; }
        IEditorCell nCell { get; }
        IEditorCell dnCell { get; }
        IEditorCell ShrinkageCell { get; }
        IEditorCell IndexShiftCell { get; }
        IEditorCell ConsiderFresnelCell { get; }

        int IsVolumeHologram { get; set; }
        double HologramThickness { get; set; }
        double n1 { get; set; }
        double n2 { get; set; }
        double n { get; set; }
        double dn { get; set; }
        double Shrinkage { get; set; }
        double IndexShift { get; set; }
        int ConsiderFresnel { get; set; }
    };

    [ComVisible(true)]
    [Guid("B2266597-4AA5-44B0-9C17-EDC542416E40")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceHologram2 : ISurface
    {// SurfaceType.Hologram2: return seqSurfaceType.SURF_HOLOGRM2 HOLOGRM2

        IEditorCell Construct_X1_Cell { get; }
        IEditorCell Construct_Y1_Cell { get; }
        IEditorCell Construct_Z1_Cell { get; }
        IEditorCell Construct_X2_Cell { get; }
        IEditorCell Construct_Y2_Cell { get; }
        IEditorCell Construct_Z2_Cell { get; }
        IEditorCell ConstructWaveCell { get; }
        IEditorCell DiffractOrderCell { get; }

        double Construct_X1 { get; set; }
        double Construct_Y1 { get; set; }
        double Construct_Z1 { get; set; }
        double Construct_X2 { get; set; }
        double Construct_Y2 { get; set; }
        double Construct_Z2 { get; set; }
        double ConstructWave { get; set; }
        double DiffractOrder { get; set; }

        IEditorCell IsVolumeHologramCell { get; }
        IEditorCell HologramThicknessCell { get; }
        IEditorCell n1Cell { get; }
        IEditorCell n2Cell { get; }
        IEditorCell nCell { get; }
        IEditorCell dnCell { get; }
        IEditorCell ShrinkageCell { get; }
        IEditorCell IndexShiftCell { get; }
        IEditorCell ConsiderFresnelCell { get; }

        int IsVolumeHologram { get; set; }
        double HologramThickness { get; set; }
        double n1 { get; set; }
        double n2 { get; set; }
        double n { get; set; }
        double dn { get; set; }
        double Shrinkage { get; set; }
        double IndexShift { get; set; }
        int ConsiderFresnel { get; set; }
    };

    [ComVisible(true)]
    [Guid("33A7F8DA-435D-40D9-813B-7F196BC86812")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceIrregular : ISurface
    {// SurfaceType.Irregular: return seqSurfaceType.SURF_IRREGULA IRREGULA

        IEditorCell Decenter_X_Cell { get; }
        IEditorCell Decenter_Y_Cell { get; }
        IEditorCell TiltAbout_X_Cell { get; }
        IEditorCell TiltAbout_Y_Cell { get; }
        IEditorCell SphericalCell { get; }
        IEditorCell AstigmatismCell { get; }
        IEditorCell ComaCell { get; }
        IEditorCell AngleCell { get; }

        double Decenter_X { get; set; }
        double Decenter_Y { get; set; }
        double TiltAbout_X { get; set; }
        double TiltAbout_Y { get; set; }
        double Spherical { get; set; }
        double Astigmatism { get; set; }
        double Coma { get; set; }
        double Angle { get; set; }
    };

    [ComVisible(true)]
    [Guid("23270C40-697B-47D9-B42A-222CD2EE4346")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceJonesMatrix : ISurface
    {// SurfaceType.JonesMatrix: return seqSurfaceType.JONESMATRIX JONESMATRIX

        IEditorCell Ar_Cell { get; }
        IEditorCell Ai_Cell { get; }
        IEditorCell Br_Cell { get; }
        IEditorCell Bi_Cell { get; }
        IEditorCell Cr_Cell { get; }
        IEditorCell Ci_Cell { get; }
        IEditorCell Dr_Cell { get; }
        IEditorCell Di_Cell { get; }

        double Ar { get; set; }
        double Ai { get; set; }
        double Br { get; set; }
        double Bi { get; set; }
        double Cr { get; set; }
        double Ci { get; set; }
        double Dr { get; set; }
        double Di { get; set; }
    };

    [ComVisible(true)]
    [Guid("f48f84e6-adb3-4ab5-951b-57e43bf7df7a")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceMuellerMatrix : ISurface
    {// SurfaceType.MuellerMatrix: return seqSurfaceType.MUELLERMATRIX MUELLERMATRIX

        IEditorCell Depolarize_Cell { get; }
        IEditorCell M00_Cell { get; }
        IEditorCell M01_Cell { get; }
        IEditorCell M02_Cell { get; }
        IEditorCell M03_Cell { get; }

        IEditorCell M10_Cell { get; }
        IEditorCell M11_Cell { get; }
        IEditorCell M12_Cell { get; }
        IEditorCell M13_Cell { get; }

        IEditorCell M20_Cell { get; }
        IEditorCell M21_Cell { get; }
        IEditorCell M22_Cell { get; }
        IEditorCell M23_Cell { get; }

        IEditorCell M30_Cell { get; }
        IEditorCell M31_Cell { get; }
        IEditorCell M32_Cell { get; }
        IEditorCell M33_Cell { get; }

        double Depolarize {  get; set; }
        double M00 { get; set; }
        double M01 { get; set; }
        double M02 { get; set; }
        double M03 { get; set; }

        double M10 { get; set; }
        double M11 { get; set; }
        double M12 { get; set; }
        double M13 { get; set; }

        double M20 { get; set; }
        double M21 { get; set; }
        double M22 { get; set; }
        double M23 { get; set; }

        double M30 { get; set; }
        double M31 { get; set; }
        double M32 { get; set; }
        double M33 { get; set; }

    };


    [ComVisible(true)]
    [Guid("B26D7745-8E6F-4889-943B-07C58E12C473")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceNonSequential : ISurface
    {// SurfaceType.NonSequential: return seqSurfaceType.SURF_NONSEQCO NONSEQCO

        IEditorCell DrawPortsCell { get; }
        IEditorCell ExitLocation_X_Cell { get; }
        IEditorCell ExitLocation_Y_Cell { get; }
        IEditorCell ExitLocation_Z_Cell { get; }
        IEditorCell ExitTilt_X_Cell { get; }
        IEditorCell ExitTilt_Y_Cell { get; }
        IEditorCell ExitTilt_Z_Cell { get; }
        IEditorCell OrderCell { get; }
        IEditorCell ReverseRaysCell { get; }

        int DrawPorts { get; set; }
        double ExitLocation_X { get; set; }
        double ExitLocation_Y { get; set; }
        double ExitLocation_Z { get; set; }
        double ExitTilt_X { get; set; }
        double ExitTilt_Y { get; set; }
        double ExitTilt_Z { get; set; }
        int Order { get; set; }
        int ReverseRays { get; set; }

    };

    [ComVisible(true)]
    [Guid("55F85AED-64EF-4FF8-A434-32EC54ADF6BE")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceOddAsphere : ISurfaceNthOrderTerms
    {// SurfaceType.OddAsphere: return seqSurfaceType.SURF_ODDASPHE ODDASPHE

    };

    [ComVisible(true)]
    [Guid("8C204BC8-8235-425D-B8ED-254F8441411E")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceOddCosine : ISurfaceCoeff_R_NthPower, ISurfaceAPBC
    {// SurfaceType.OddCosine: return seqSurfaceType.SURF_ODDCOSIN ODDCOSIN

        IEditorCell NumberOfTermsCell { get; }
        IEditorCell NormRadiusCell { get; }

        int NumberOfTerms { get; set; }
        double NormRadius { get; set; }
    };

    [ComVisible(true)]
    [Guid("42921245-3A76-4848-8A3E-F8C840DB24F2")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceOffAxisConicFreeform : ISurfaceXYPolynomial
    {// SurfaceType.OffAxisConicFreeform: return seqSurfaceType.SURFOFFAXISCF OFFAXISCF

        IEditorCell OffsetCell { get; }
        IEditorCell NormRadiusCell { get; }

        double Offset { get; set; }
        double NormRadius { get; set; }
    };

    [ComVisible(true)]
    [Guid("5738F224-2772-4B8A-978A-62196F970F12")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceQTypeFreeform : ISurface
    {// SurfaceType.QTypeFreeform: return seqSurfaceType.SURF_Q_FREEFORM Q_FRERFORM

        IEditorCell DecenterXCell { get; }
        IEditorCell DecenterYCell { get; }
        IEditorCell MaxPolynomialPowerCell { get; }
        IEditorCell NormRadiusCell { get; }
        IEditorCell AmnCell(int m, int n);
        IEditorCell BmnCell(int m, int n);

        double DecenterX { get; set; }
        double DecenterY { get; set; }
        int MaxPolynomialPower { get; set; }
        double NormRadius { get; set; }

        double GetAmn(int m, int n);
        void SetAmn(int m, int n, double Value);
        double GetBmn(int m, int n);
        void SetBmn(int m, int n, double Value);
    };

    [ComVisible(true)]
    [Guid("E69EECD5-7A79-477B-B470-95B89A243F3C")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceOpticallyFabricatedHologram : ISurfaceXYPolynomial
    {// SurfaceType.OpticallyFabricatedHologram: return seqSurfaceType.SURF_OFABHOL1 OFABHOL1

        IEditorCell ShapeCell { get; }
        IEditorCell HologramTypeCell { get; }
        IEditorCell OPDModeCell { get; }
        IEditorCell DiffractOrderCell { get; }
        IEditorCell CurvatureCell { get; }
        IEditorCell ConicCell { get; }
        IEditorCell Rotation_R_Cell { get; }
        IEditorCell aCell { get; }
        IEditorCell bCell { get; }
        IEditorCell cCell { get; }

        IEditorCell NormRadiusCell { get; }

        int Shape { get; set; }
        int HologramType { get; set; }
        int OPDMode { get; set; }

        double DiffractOrder { get; set; }
        double Curvature { get; set; }
        double Conic { get; set; }
        double Rotation_R { get; set; }
        double a { get; set; }
        double b { get; set; }
        double c { get; set; }

        double NormRadius { get; set; }

        IEditorCell HologramThicknessCell { get; }
        IEditorCell nCell { get; }
        IEditorCell dnCell { get; }
        IEditorCell ShrinkageCell { get; }
        IEditorCell IndexShiftCell { get; }
        IEditorCell ConsiderFresnelCell { get; }

        double HologramThickness { get; set; }
        double n { get; set; }
        double dn { get; set; }
        double Shrinkage { get; set; }
        double IndexShift { get; set; }
        int ConsiderFresnel { get; set; }
    };

    [ComVisible(true)]
    [Guid("DA1D83D8-292E-4668-AB0C-4C8B5540C0A5")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceParaxial : ISurface
    {// SurfaceType.Paraxial: return seqSurfaceType.SURF_PARAXIAL PARAXIAL

        IEditorCell FocalLengthCell { get; }
        IEditorCell OPDModeCell { get; }

        double FocalLength { get; set; }
        int OPDMode { get; set; }
    };

    [ComVisible(true)]
    [Guid("EE363065-BC12-4AB2-B9D1-ECF9D3043649")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceParaxialXY : ISurface
    {// SurfaceType.ParaxialXY: return seqSurfaceType.SURF_PARAX_XY PARAX_XY

        IEditorCell X_PowerCell { get; }
        IEditorCell Y_PowerCell { get; }

        double X_Power { get; set; }
        double Y_Power { get; set; }
    };

    [ComVisible(true)]
    [Guid("D9E22F13-027D-456A-AA31-70F1B3F5A8BF")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfacePeriodic : ISurface
    {// SurfaceType.Periodic: return seqSurfaceType.SURF_PERIODIC PERIODIC

        IEditorCell AmplitudeCell { get; }
        IEditorCell X_FrequencyCell { get; }
        IEditorCell Y_FrequencyCell { get; }

        double Amplitude { get; set; }
        double X_Frequency { get; set; }
        double Y_Frequency { get; set; }
    };

    [ComVisible(true)]
    [Guid("5B23531C-EC42-4632-A63E-EF8B7BEAF336")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfacePolynomial : ISurfaceCoeff_X_NthEvenPower_8, ISurfaceCoeff_Y_NthEvenPower_8
    {// SurfaceType.Polynomial: return seqSurfaceType.SURF_POLYNOMI POLYNOMI

    };

    [ComVisible(true)]
    [Guid("E5DC1CAC-0AB3-474B-AB7E-376F274FEAF3")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceQTypeAsphere : ISurface
    {// SurfaceType.QTypeAsphere: return seqSurfaceType.SURF_QED_TYPE QED_TYPE

        IEditorCell TypeCell { get; }
        IEditorCell NumberOfTermsCell { get; }
        IEditorCell NormRadiusCell { get; }

        IEditorCell AnCell(int n);

        QTypes QType { get; set; }
        int NumberOfTerms { get; set; }
        double NormRadius { get; set; }

        double GetAn(int n);
        void SetAn(int n, double Value);
    };

    [ComVisible(true)]
    [Guid("CF433230-1BDB-48C4-8ECD-2E2682DC39A7")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceRadialGrating : ISurfaceNthEvenOrderTerms, ISurfaceCoeff_P_NthPower
    {// SurfaceType.RadialGrating: return seqSurfaceType.SURF_RGRATING RGRATING

        IEditorCell DeffractOrderCell { get; }
        IEditorCell GratingModeCell { get; }
        IEditorCell NormRadiusCell { get; }

        double DeffractOrder { get; set; }
        int GratingMode { get; set; }
        double NormRadius { get; set; }

    };

    [ComVisible(true)]
    [Guid("A06C9BD1-D5C5-4545-A308-23CAF5C4F3F6")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceRadialNurbs : ISurface
    {// SurfaceType.RadialNurbs: return seqSurfaceType.SURF_RADNURBS RADNURBS

        IEditorCell NumberOfTermsCell { get; }
        IEditorCell YnCell(int n);
        IEditorCell ZnCell(int n);
        IEditorCell WnCell(int n);

        int NumberOfTerms { get; set; }

        double GetYn(int n);
        void SetYn(int n, double Value);

        double GetZn(int n);
        void SetZn(int n, double Value);

        double GetWn(int n);
        void SetWn(int n, double Value);
    };

    [ComVisible(true)]
    [Guid("F353B11D-A685-4E86-8855-0305B1CC8680")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceRetroReflect : ISurface
    {// SurfaceType.RetroReflect: return seqSurfaceType.SURF_RETROREF RETROREF

    };

#endregion

    [ComVisible(true)]
    [Guid("FBCD55B0-8619-4686-938F-C29BCB3F2576")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceSlide : ISurface
    {// SurfaceType.SlideSurface: return seqSurfaceType.SURF_SLIDESRF SLIDESRF

        IEditorCell ModeCell { get; }
        IEditorCell X_HalfWidthCell { get; }
        IEditorCell Y_HalfWidthCell { get; }

        int Mode { get; set; }
        double X_HalfWidth { get; set; }
        double Y_HalfWidth { get; set; }
    };

    [ComVisible(true)]
    [Guid("1863EA26-9CDE-4946-83DE-392CE81FF3B0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceSuperconic : ISurface
    {// SurfaceType.Superconic: return seqSurfaceType.SURF_SUPERCON SUPERCON

        IEditorCell NumberOfTermsCell { get; }

        IEditorCell VnCell(int n);
        IEditorCell UnCell(int n);

        int NumberOfTerms { get; set; }

        double GetVn(int n);
        void SetVn(int n, double Value);
        double GetUn(int n);
        void SetUn(int n, double Value);
    };

    [ComVisible(true)]
    [Guid("FA2CA9DE-880D-4DB5-A67D-CCE119CC79F7")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceTilted : ISurface
    {// SurfaceType.Tilted: return seqSurfaceType.SURF_TILTSURF TILTSURF

        IEditorCell X_TangentCell { get; }
        IEditorCell Y_TangentCell { get; }

        double X_Tangent { get; set; }
        double Y_Tangent { get; set; }
    };

    [ComVisible(true)]
    [Guid("B60CC842-F659-496E-8C1F-71B4B0EA56C4")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceToroidal : ISurfaceNthEvenOrderTerms, ISurfaceNthZernike
    {// SurfaceType.Toroidal: return seqSurfaceType.SURF_TOROIDAL TOROIDAL

        IEditorCell ExtrapolateCell { get; }
        IEditorCell RadiusOfRotationCell { get; }

        int Extrapolate { get; set; }
        double RadiusOfRotation { get; set; }

    };

    [ComVisible(true)]
    [Guid("2F66201F-95C9-4B86-8724-BFFF2FF7A75B")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceToroidalGrat : ISurface
    {// SurfaceType.ToroidalGrat: return seqSurfaceType.SURF_TOROGRAT TOROGRAT

        IEditorCell RadiusOfRotationCell { get; }
        IEditorCell LinesPerMicroMeterCell { get; }
        IEditorCell DiffractionOrderCell { get; }

        double RadiusOfRotation { get; set; }
        double LinesPerMicroMeter { get; set; }
        double DiffractionOrder { get; set; }
    };

    [ComVisible(true)]
    [Guid("BC6AB6CA-1619-43D4-903D-85CD29C01590")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceToroidalHologram : ISurfaceNthEvenOrderTerms
    {// SurfaceType.ToroidalHologram: return seqSurfaceType.TOROIDAL_HOLOGRAM TOROHOLO

        IEditorCell RadiusOfRotationCell { get; }

        IEditorCell Const_X1_Cell { get; }
        IEditorCell Const_Y1_Cell { get; }
        IEditorCell Const_Z1_Cell { get; }
        IEditorCell Const_X2_Cell { get; }
        IEditorCell Const_Y2_Cell { get; }
        IEditorCell Const_Z2_Cell { get; }
        IEditorCell ConstWaveCell { get; }
        IEditorCell OrderCell { get; }
        IEditorCell FlagCell { get; }

        double RadiusOfRotation { get; set; }
        double Const_X1 { get; set; }
        double Const_Y1 { get; set; }
        double Const_Z1 { get; set; }
        double Const_X2 { get; set; }
        double Const_Y2 { get; set; }
        double Const_Z2 { get; set; }
        double ConstWave { get; set; }
        double Order { get; set; }
        int Flag { get; set; }

        IEditorCell IsVolumeHologramCell { get; }
        IEditorCell HologramThicknessCell { get; }
        IEditorCell n1Cell { get; }
        IEditorCell n2Cell { get; }
        IEditorCell nCell { get; }
        IEditorCell dnCell { get; }
        IEditorCell ShrinkageCell { get; }
        IEditorCell IndexShiftCell { get; }
        IEditorCell ConsiderFresnelCell { get; }

        int IsVolumeHologram { get; set; }
        double HologramThickness { get; set; }
        double n1 { get; set; }
        double n2 { get; set; }
        double n { get; set; }
        double dn { get; set; }
        double Shrinkage { get; set; }
        double IndexShift { get; set; }
        int ConsiderFresnel { get; set; }
    };

    [ComVisible(true)]
    [Guid("513E85B8-B351-4A52-985B-D9840367C344")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceToroidalNurbs : ISurface
    {// SurfaceType.ToroidalNurbs: return seqSurfaceType.SURF_TORNURBS TORNURBS

        IEditorCell RadiusOfRotationCell { get; }

        IEditorCell Minimum_X_Cell { get; }
        IEditorCell MinimumAngleCell { get; }
        IEditorCell Maximum_X_Cell { get; }
        IEditorCell MaximumAngleCell { get; }

        double RadiusOfRotation { get; set; }
        double Minimum_X { get; set; }
        double MinimumAngle { get; set; }
        double Maximum_X { get; set; }
        double MaximumAngle { get; set; }

        IEditorCell NumberOfTermsCell { get; }

        IEditorCell YnCell(int n);
        IEditorCell ZnCell(int n);
        IEditorCell WnCell(int n);

        int NumberOfTerms { get; set; }

        double GetYn(int n);
        double GetZn(int n);
        double GetWn(int n);
        void SetYn(int n, double Value);
        void SetZn(int n, double Value);
        void SetWn(int n, double Value);
    };
    //
    //  UserDefined: Unimplemented. There's no way at compile time to know what the User is going to call things.
    //
    [ComVisible(true)]
    [Guid("05448D1B-31C0-4397-BA47-ED2381592847")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceVariableLineSpaceGrating : ISurface
    {// SurfaceType.VariableLineSpaceGrating: return seqSurfaceType.SURF_VARLSGRT VARLSGRT

        IEditorCell DiffractOrderCell { get; }
        IEditorCell FocalRadius_L_Cell { get; }
        IEditorCell CosineAlphaCell { get; }
        IEditorCell CosineBetaCell { get; }
        IEditorCell LambdaZeroCell { get; }

        double DiffractOrder { get; set; }
        double FocalRadius_L { get; set; }
        double CosineAlpha { get; set; }
        double CosineBeta { get; set; }
        double LambdaZero { get; set; }
    };

    [ComVisible(true)]
    [Guid("920C1623-DF44-4B49-A07B-FC1F08E3B0D3")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceZernikeAnnularPhase : ISurfaceNthZernike
    {// SurfaceType.ZernikeAnnularPhase: return seqSurfaceType.SURF_AZERNPHA AZERNPHA

        IEditorCell DiffractOrderCell { get; }
        IEditorCell ExtrapolateCell { get; }
        IEditorCell ObscurationCell { get; }

        double DiffractOrder { get; set; }
        int Extrapolate { get; set; }
        double Obscuration { get; set; }
    };

    [ComVisible(true)]
    [Guid("233DBA22-A8DD-48C8-A8BC-22A5C225C14F")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceZernikeFringePhase : ISurfaceNthZernike
    {// SurfaceType.ZernikeFringePhase: return seqSurfaceType.SURF_FZERNPHA FZERNPHA

        IEditorCell DiffractOrderCell { get; }
        IEditorCell ExtrapolateCell { get; }

        double DiffractOrder { get; set; }
        int Extrapolate { get; set; }
    };

    [ComVisible(true)]
    [Guid("747D3C2C-82D3-4841-B4AA-B2216486A53F")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceZernikeFringeSag : ISurfaceNthZernike, ISurfaceNthEvenOrderTerms
    {// SurfaceType.ZernikeFringeSag: return seqSurfaceType.SURF_FZERNSAG FZERNSAG

        IEditorCell ExtrapolateCell { get; }
        IEditorCell ZernikeDecenter_X_Cell { get; }
        IEditorCell ZernikeDecenter_Y_Cell { get; }

        int Extrapolate { get; set; }
        double ZernikeDecenter_X { get; set; }
        double ZernikeDecenter_Y { get; set; }
    };

    [ComVisible(true)]
    [Guid("98DE5872-A983-4F6D-B0C8-2E8C2C2318B7")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceZernikeStandardPhase : ISurfaceNthZernike
    {// SurfaceType.ZernikeStandardPhase: return seqSurfaceType.SURF_SZERNPHA SZERNPHA

        IEditorCell DiffractOrderCell { get; }
        IEditorCell ExtrapolateCell { get; }

        double DiffractOrder { get; set; }
        int Extrapolate { get; set; }
    };

    [ComVisible(true)]
    [Guid("E2BF4D28-6166-4035-875E-394F1F658806")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceZernikeStandardSag : ISurfaceNthZernike, ISurfaceNthEvenOrderTerms
    {// SurfaceType.ZernikeStandardSag: return seqSurfaceType.SURF_SZERNSAG SZERNSAG

        IEditorCell ExtrapolateCell { get; }
        IEditorCell ZernikeDecenter_X_Cell { get; }
        IEditorCell ZernikeDecenter_Y_Cell { get; }

        int Extrapolate { get; set; }
        double ZernikeDecenter_X { get; set; }
        double ZernikeDecenter_Y { get; set; }
    };

    [ComVisible(true)]
    [Guid("69807BDA-440D-4F8C-A58D-1FB5CCE87BE2")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceZonePlate : ISurfaceNthThickness
    {// SurfaceType.ZonePlate: return seqSurfaceType.SURF_ZONEPLAT ZONEPLAT

        IEditorCell ModeCell { get; }
        IEditorCell Delta_R_Cell { get; }
        IEditorCell ReferenceWaveCell { get; }

        double Mode { get; set; }
        double Delta_R { get; set; }
        double ReferenceWave { get; set; }
    };

#endregion

#region Type Tab

    [ComVisible(true)]
    [Guid("B671C677-B21F-49E9-BC66-0E4F1719596C")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDETypeData
    {
        ZemaxColor SurfaceColor { get; set; }
        ZemaxOpacity SurfaceOpacity { get; set; }
        ZemaxColor RowColor { get; set; }
        bool IsStop { get; set; }
        bool CanBeStop { get; }
        bool IsGlobalCoordinateReference { get; set; }
        bool CanBeGCR { get; }
        bool IgnoreSurface { get; set; }
        bool SurfaceCannotBeHyperhemispheric { get; set; }
    }

#endregion

#region Draw Tab

    [ComVisible(true)]
    [Guid("A7476488-250B-489B-BFB1-30CAD1FD5450")]
    public enum SurfaceEdgeDraw
    {
        Squared = 0,
        Tapered = 1,
        Flat = 2
    }

    [ComVisible(true)]
    [Guid("BAB8FE65-7A3F-47FE-89CA-19AD18EFC076")]
    public enum SubstrateType
    {
        None = 0,
        Flat = 1,
        Curved = 2
    }

    [ComVisible(true)]
    [Guid("D7A6A815-BB18-4A8A-83F7-2D99611B9BFB")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDEDrawData
    {
        bool HideRaysToThisSurface { get; set; }
        bool SkipRaysToThisSurface { get; set; }
        bool DoNotDrawThisSurface { get; set; }
        bool DoNotDrawEdgesFromThisSurface { get; set; }
        bool DrawLocalAxis { get; set; }
        bool DrawLocalOriginPoint { get; set; }
        SurfaceEdgeDraw DrawEdgesAs { get; set; }

        bool HasMirrorSettings { get; }
        SubstrateType MirrorSubstrate { get; set; }
        double MirrorThickness { get; set; }
        ZemaxColor PntMarkerColor { get; set; }
    }

#endregion

#region Aperture Tab

    [ComVisible(true)]
    [Guid("A2A10775-E99A-4C42-8299-4CFF201292BD")]
    public enum SurfaceApertureTypes
    {
        None = 0,
        CircularAperture = 1,
        CircularObscuration = 2,
        Spider = 3,
        RectangularAperture = 4,
        RectangularObscuration = 5,
        EllipticalAperture = 6,
        EllipticalObscuration = 7,
        UserAperture = 8,
        UserObscuration = 9,
        FloatingAperture = 10,
    }

    [ComVisible(true)]
    [Guid("727C3391-398E-4EF3-9045-A58D5FF1028E")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDEApertureData
    {
        int PickupFrom { get; set; }
        void SetPickupNone();

        bool IsPickedUp { get; }

        SurfaceApertureTypes CurrentType { get; }
        ISurfaceApertureType CurrentTypeSettings { get; }
        ISurfaceApertureType CreateApertureTypeSettings(SurfaceApertureTypes type);
        bool ChangeApertureTypeSettings(ISurfaceApertureType settings);

        bool DisableClearSemiDiameterMarginsForThisSurface { get; set; }
    }

    [ComVisible(true)]
    [Guid("22C145FF-5289-4675-859E-7E182A342965")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceApertureType
    {
        SurfaceApertureTypes Type { get; }
        bool IsReadOnly { get; }

        ISurfaceApertureNone _S_None { get; }
        ISurfaceApertureCircular _S_CircularAperture { get; }
        ISurfaceApertureCircular _S_CircularObscuration { get; }
        ISurfaceApertureSpider _S_Spider { get; }
        ISurfaceApertureRectangular _S_RectangularAperture { get; }
        ISurfaceApertureRectangular _S_RectangularObscuration { get; }
        ISurfaceApertureElliptical _S_EllipticalAperture { get; }
        ISurfaceApertureElliptical _S_EllipticalObscuration { get; }
        ISurfaceApertureUser _S_UserAperture { get; }
        ISurfaceApertureUser _S_UserObscuration { get; }
        ISurfaceApertureFloating _S_FloatingAperture { get; }
    }

    [ComVisible(true)]
    [Guid("121CE465-077C-4E65-807B-C0BDB12B7D57")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceApertureNone : ISurfaceApertureType
    {

    }

    [ComVisible(true)]
    [Guid("CCAAE35D-AE2A-4964-AD2B-50627010F8C8")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceApertureCircular : ISurfaceApertureType
    {
        double MinimumRadius { get; set; }
        double MaximumRadius { get; set; }
        double ApertureXDecenter { get; set; }
        double ApertureYDecenter { get; set; }
    }

    [ComVisible(true)]
    [Guid("A6E2842E-5ACE-4E68-B475-C00BCA74F1E9")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceApertureUser : ISurfaceApertureType
    {
        double UDASCale { get; set; }
        double ApertureXDecenter { get; set; }
        double ApertureYDecenter { get; set; }
        string ApertureFile { get; set; }

        string[] GetAvailableFiles();
    }

    [ComVisible(true)]
    [Guid("8BE6C8AA-543B-4B54-B33F-7B27B49668E0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceApertureSpider : ISurfaceApertureType
    {
        double WidthOfArms { get; set; }
        int NumberOfArms { get; set; }
        double ApertureXDecenter { get; set; }
        double ApertureYDecenter { get; set; }
    }

    [ComVisible(true)]
    [Guid("E4ECE7A6-63CB-474B-854D-51C168845EA2")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceApertureRectangular : ISurfaceApertureType
    {
        double XHalfWidth { get; set; }
        double YHalfWidth { get; set; }
        double ApertureXDecenter { get; set; }
        double ApertureYDecenter { get; set; }
    }

    [ComVisible(true)]
    [Guid("AF23ADF0-E641-43AF-B054-A27DD333F357")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceApertureElliptical : ISurfaceApertureType
    {
        double XHalfWidth { get; set; }
        double YHalfWidth { get; set; }
        double ApertureXDecenter { get; set; }
        double ApertureYDecenter { get; set; }
    }

    [ComVisible(true)]
    [Guid("041C78B9-C959-4788-81E4-295647D14C9B")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceApertureFloating : ISurfaceApertureType
    {

    }

#endregion

#region Scattering Tab

    [ComVisible(true)]
    [Guid("F71DB2C8-B43C-48D4-80A7-8FDF688EA112")]
    public enum SurfaceScatteringTypes
    {
        None = 0,
        Lambertian = 1,
        Gaussian = 2,
        ABg = 3,
        ABgFile = 4,
        BSDF = 5,
        User = 6,
        ISScatterCatalog = 7,
    }

    [ComVisible(true)]
    [Guid("1A1527AF-00A2-4F51-A8B6-1CFEDA81ACCA")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDEScatteringData
    {
        SurfaceScatteringTypes CurrentType { get; }
        ISurfaceScatteringType CurrentTypeSettings { get; }
        ISurfaceScatteringType CreateScatteringTypeSettings(SurfaceScatteringTypes type);
        bool ChangeScatteringTypeSettings(ISurfaceScatteringType settings);
    }

    [ComVisible(true)]
    [Guid("40FF1060-03AC-41E4-95F6-667C6C40295B")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceScatteringType
    {
        SurfaceScatteringTypes Type { get; }

        ISurfaceScatteringNone _S_None { get; }
        ISurfaceScatteringLambertian _S_Lambertian { get; }
        ISurfaceScatteringGaussian _S_Gaussian { get; }
        ISurfaceScatteringABg _S_ABg { get; }
        ISurfaceScatteringABgFile _S_ABgFile { get; }
        ISurfaceScatteringBSDF _S_BSDF { get; }
        ISurfaceScatteringUser _S_User { get; }
        ISurfaceScatteringCatalog _S_Catalog { get; }
    }

    [ComVisible(true)]
    [Guid("E783E16F-0674-4638-81C9-D6F9BCF19B64")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceScatteringNone : ISurfaceScatteringType
    {

    }

    [ComVisible(true)]
    [Guid("0595D2EE-F1D1-41A4-BD67-28543CF7C1A3")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceScatteringLambertian : ISurfaceScatteringType
    {
        double ScatterFraction { get; set; }
    }

    [ComVisible(true)]
    [Guid("4BDD3E74-B63C-415E-936B-2CC27BBDA53C")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceScatteringGaussian : ISurfaceScatteringType
    {
        double ScatterFraction { get; set; }
        double Sigma { get; set; }
    }

    [ComVisible(true)]
    [Guid("84385EA1-84D8-4FA0-AEAE-11F5BACC0ADA")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceScatteringABg : ISurfaceScatteringType
    {
        string ABgName { get; set; }
        string[] GetAvailableABgNames();
    }

    [ComVisible(true)]
    [Guid("FC24CE3A-8B8D-4570-88AC-DDA6887C7ACA")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceScatteringABgFile : ISurfaceScatteringType
    {
        string FileName { get; set; }
        string[] GetAvailableFileNames();
    }

    [ComVisible(true)]
    [Guid("3873506B-48DA-4AC5-8544-D63A88659FB5")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceScatteringBSDF : ISurfaceScatteringType
    {
        string FileName { get; set; }
        string[] GetAvailableFileNames();

        double ScatterFraction { get; set; }
        double Angle { get; set; }
    }

    [ComVisible(true)]
    [Guid("E4942D08-F3FE-4F93-94E1-C28F4D3AAFCE")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceScatteringUser : ISurfaceScatteringType
    {
        string DLLName { get; set; }
        string[] GetAvailableDLLNames();

        int NumberOfParameters { get; }
        string GetParameterName(int paramIdx);
        double GetParameterValue(int paramIdx);
        bool SetParameterValue(int paramIdx, double Value);
    }

    [ComVisible(true)]
    [Guid("FEB4D289-6E0E-4031-9435-848B3D2402BC")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISurfaceScatteringCatalog : ISurfaceScatteringType
    {
        double Angle { get; set; }
        string GetFile();
        ReflectTransmitCode SetFile(string File);
        string[] GetAvailableFiles();

        SampleSides SampleSide { get; set; }
        SampleSides[] GetSampleSides();
        Samplings Sampling { get; set; }
    }


#endregion

#region TiltDecenterTab

    [ComVisible(true)]
    [Guid("B185070F-7601-4FD7-855D-653F24FBC1DA")]
    public enum TiltDecenterOrderType
    {
        Decenter_Tilt = 0,
        Tilt_Decenter = 1,
    }

    [ComVisible(true)]
    [Guid("4265887F-9811-4673-8107-EB3C3408CD7F")]
    public enum TiltDecenterPickupType
    {
        Explicit,
        PickupSurface,
        ReverseSurface
    }

    [ComVisible(true)]
    [Guid("AEA9805B-7BB2-4C54-9101-21FB460B8E9D")]
    public enum CoordinateReturnType
    {
        None = 0,
        OrientationOnly,
        OrientationXY,
        OrientationXYZ,
    }

    [ComVisible(true)]
    [Guid("8B72B0C2-8224-4112-8D46-DA416FF6D23D")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDETiltDecenterData
    {
        TiltDecenterOrderType BeforeSurfaceOrder { get; set; }
        double BeforeSurfaceDecenterX { get; set; }
        double BeforeSurfaceDecenterY { get; set; }
        double BeforeSurfaceTiltX { get; set; }
        double BeforeSurfaceTiltY { get; set; }
        double BeforeSurfaceTiltZ { get; set; }

        TiltDecenterPickupType AfterSurfaceMode { get; }
        int AfterSurfaceModeSurface { get; }
        bool AfterSurfaceModeSurfaceIsThis { get; }

        void SetAfterSurfaceModeExplicit();
        bool SetAfterSurfaceModePickup(int fromSurface);
        bool SetAfterSurfaceModeReverse(int fromSurface);
        bool SetAfterSurfaceModePickupThis();
        bool SetAfterSurfaceModeReverseThis();

        TiltDecenterOrderType AfterSurfaceOrder { get; set; }
        double AfterSurfaceDecenterX { get; set; }
        double AfterSurfaceDecenterY { get; set; }
        double AfterSurfaceTiltX { get; set; }
        double AfterSurfaceTiltY { get; set; }
        double AfterSurfaceTiltZ { get; set; }

        bool BeforeAfterSurfaceEnabled { get; }

        bool CoordinateReturnEnabled { get; }
        CoordinateReturnType CoordinateReturn { get; set; }
        int CoordinateReturnToSurface { get; set; }

    }

#endregion

#region Physical Optics Tab

    [ComVisible(true)]
    [Guid("978862B7-C592-4B0B-A921-65D1029269B8")]
    public enum PilotRadiusMode
    {
        BestFit = 0,
        Shorter = 1,
        Longer = 2,
        X = 3,
        Y = 4,
        Plane = 5,
        User = 6,
    }

    [ComVisible(true)]
    [Guid("E9FC1903-02C2-40CD-BECB-F059C40C65F5")]
    public enum XYSampling
    {
        S32 = 0,
        S64 = 1,
        S128 = 2,
        S256 = 3,
        S512 = 4,
        S1024 = 5,
        S2048 = 6,
        S4096 = 7,
        S8192 = 8,
        S16384 = 9,
    }

    [ComVisible(true)]
    [Guid("8C61C999-6DA6-423B-A09E-76B5100AF9BA")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDEPhysicalOpticsData
    {
        bool UseRaysToPropagateToNextSurface { get; set; }
        bool DoNotRescaleBeamSizeUsingRayData { get; set; }
        bool UseAngularSpectrumPropagator { get; set; }
        bool DrawThisLensOnShadedModel { get; set; }
        bool ReComputePilotBeamParameters { get; set; }
        bool UseXaxisReference { get; set; }

        bool ResampleAfterRefraction { get; set; }
        bool AutoResample { get; set; }
        XYSampling XSampling { get; set; }
        XYSampling YSampling { get; set; }
        double XWidth { get; set; }
        double YWidth { get; set; }

        PilotRadiusMode OutputPilotRadius { get; set; }
        double XRadius { get; set; }
        double YRadius { get; set; }
    }

#endregion

#region Coating Tab

    [ComVisible(true)]
    [Guid("5C60FB77-89F2-4DE6-BB1A-3B146036CCD7")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDECoatingData
    {
        string Coating { get; set; }
        string[] GetAvailableCoatings();
        bool UseLayerMultiplierAndOffsets { get; set; }

        int NumberOfLayers { get; }
        ILDECoatingSettings GetLayerSettings(int Layer);
        bool SetLayerSettings(int Layer, ILDECoatingSettings settings);

        void SetAllThicknessVariable();
        void SetAllThicknessFixed();
        void SetAllThicknessOne();

        void SetAllIndexVariable();
        void SetAllIndexFixed();
        void SetAllIndexZero();

        void SetAllExtinctionVariable();
        void SetAllExtinctionFixed();
        void SetAllExtinctionZero();

    }

    [ComVisible(true)]
    [Guid("C63CB969-8C50-46A9-9CDD-A752FFB7EFCA")]
    public enum CoatingStatusType
    {
        Fixed,
        Variable,
        Pickup,
    }

    [ComVisible(true)]
    [Guid("A5CDB874-FC2A-49D0-8D98-1C28F5CD39AD")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDECoatingSettings
    {
        int Layer { get; }

        double ThicknessMultiplier { get; set; }
        CoatingStatusType ThicknessStatus { get; }
        int ThicknessPickupFrom { get; }
        void SetThicknessStatusFixed();
        void SetThicknessStatusVariable();
        bool SetThicknessStatusPickup(int fromLayer);

        double IndexOffset { get; set; }
        CoatingStatusType IndexStatus { get; }
        int IndexPickupFrom { get; }
        void SetIndexStatusFixed();
        void SetIndexStatusVariable();
        bool SetIndexStatusPickup(int fromLayer);

        double ExtinctionOffset { get; set; }
        CoatingStatusType ExtinctionStatus { get; }
        int ExtinctionPickupFrom { get; }
        void SetExtinctionStatusFixed();
        void SetExtinctionStatusVariable();
        bool SetExtinctionStatusPickup(int fromLayer);
    }

#endregion

#region Import Tab

    [ComVisible(true)]
    [Guid("6350E10B-0F15-4B0B-BF9C-EAD106D9406F")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDEImportData
    {
        bool ImportDataFile(string dataFile);
        string DefaultImportDirectory { get; }
        string[] GetImportFiles(string directory);

        bool CopyImportDataFrom(ILDEImportData source);
    }

    #endregion

    #region Composite Tab

    [ComVisible(true)]
    [Guid("D17F2C43-C69D-4C2F-9848-AB0F4A3CCC17")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]

    public interface ILDECompositeData
    {
        bool IsCompositeSurface { get; set; } // HYPERSURFACE
        void SetOffAxisTiltAndDecenter();
    }

    #endregion

    [ComVisible(true)]
    [Guid("21813C2A-2B66-4EB7-BCD1-7A5D2E260AE5")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDETool_AddCoatingsToAllSurfaces
    {
        string[] AvailableCoatings { get; }
        string CoatingToAdd { get; set; }
    }

    [ComVisible(true)]
    [Guid("5D66407D-D018-4A08-B6E6-1235C23B2D80")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ILDETool_TiltDecenterElements
    {
        int FirstSurface { get; set; }
        int LastSurface { get; set; }
        double DecenterX { get; set; }
        double DecenterY { get; set; }
        TiltDecenterOrderType Order { get; set; }
        double TiltX { get; set; }
        double TiltY { get; set; }
        double TiltZ { get; set; }
        double PivotX { get; set; }
        double PivotY { get; set; }
        double PivotZ { get; set; }
        bool GlobalCoordinates { get; set; }
        ZemaxColor PivotColor { get; set; }
        string PivotComment { get; set; }
        ZemaxColor CoordinateBreakColor { get; set; }
        string CoordinateBreakComment { get; set; }
        bool HideTrailingDummySurface { get; set; }
    }

}

Connect with Ansys