using System;
using System.Runtime.InteropServices;

namespace Deltares.MStab.IO.Classic
{
    public class ClassicMStabFunctionDefinitions
    {
        public static bool ClassicGetVersion(int handle, ref CMStabVersion aResult)
        {
            return GetExternalVersion(handle, ref aResult);
        }

        public static bool ClassicSetVersion(int handle, CMStabVersion aResult)
        {
            return SetExternalVersion(handle, aResult);
        }

        public static bool ClassicGetIdentificationTitles(int handle, ref MStabIdentificationTitles aResult)
        {
            return GetExternalIdentificationTitles(handle, ref aResult);
        }

        public static bool ClassicSetIdentificationTitles(int handle, MStabIdentificationTitles aResult)
        {
            return SetExternalIdentificationTitles(handle, aResult);
        }

        public static bool ClassicGetModel(int handle, ref MStabModel aResult)
        {
            return GetExternalModel(handle, ref aResult);
        }

        public static bool ClassicSetModel(int handle, MStabModel aResult)
        {
            return SetExternalModel(handle, aResult);
        }

        public static bool ClassicGetMSeepNet(int handle, ref MStabMSeepNet aResult)
        {
            return GetExternalMSeepNet(handle, ref aResult);
        }

        public static bool ClassicSetMSeepNet(int handle, MStabMSeepNet aResult)
        {
            return SetExternalMSeepNet(handle, aResult);
        }

        public static bool ClassicGetUnitWeightWater(int handle, ref MStabUnitWeightWater aResult)
        {
            return GetExternalUnitWeightWater(handle, ref aResult);
        }

        public static bool ClassicSetUnitWeightWater(int handle, MStabUnitWeightWater aResult)
        {
            return SetExternalUnitWeightWater(handle, aResult);
        }

        public static bool ClassicGetConsolidationDegree(int handle, ref MStabConsolidationDegree aResult)
        {
            return GetExternalConsolidationDegree(handle, ref aResult);
        }

        public static bool ClassicSetConsolidationDegree(int handle, MStabConsolidationDegree aResult)
        {
            return SetExternalConsolidationDegree(handle, aResult);
        }

        public static bool ClassicGetTemporaryLoadsDegree(int handle, ref MStabTemporaryLoadsDegree aResult)
        {
            return GetExternalTemporaryLoadsDegree(handle, ref aResult);
        }

        public static bool ClassicSetTemporaryLoadsDegree(int handle, MStabTemporaryLoadsDegree aResult)
        {
            return SetExternalTemporaryLoadsDegree(handle, aResult);
        }

        public static bool ClassicGetFreeWaterDegree(int handle, ref MStabFreeWaterDegree aResult)
        {
            return GetExternalFreeWaterDegree(handle, ref aResult);
        }

        public static bool ClassicSetFreeWaterDegree(int handle, MStabFreeWaterDegree aResult)
        {
            return SetExternalFreeWaterDegree(handle, aResult);
        }

        public static bool ClassicGetEarthQuakeDegree(int handle, ref MStabEarthQuakeDegree aResult)
        {
            return GetExternalEarthQuakeDegree(handle, ref aResult);
        }

        public static bool ClassicSetEarthQuakeDegree(int handle, MStabEarthQuakeDegree aResult)
        {
            return SetExternalEarthQuakeDegree(handle, aResult);
        }

        public static bool ClassicGetCircles(int handle, ref MStabCircles aResult)
        {
            return GetExternalCircles(handle, ref aResult);
        }

        public static bool ClassicSetCircles(int handle, MStabCircles aResult)
        {
            return SetExternalCircles(handle, aResult);
        }

        public static bool ClassicGetSlipSpencer1(int handle, ref MStabSlipSpencer aResult)
        {
            return GetExternalSlipSpencer1(handle, ref aResult);
        }

        public static bool ClassicSetSlipSpencer1(int handle, MStabSlipSpencer aResult)
        {
            return SetExternalSlipSpencer1(handle, aResult);
        }

        public static bool ClassicGetSlipSpencer2(int handle, ref MStabSlipSpencer aResult)
        {
            return GetExternalSlipSpencer2(handle, ref aResult);
        }

        public static bool ClassicSetSlipSpencer2(int handle, MStabSlipSpencer aResult)
        {
            return SetExternalSlipSpencer2(handle, aResult);
        }

        public static bool ClassicGetSlipInterval(int handle, ref MStabSlipInterval aResult)
        {
            return GetExternalSlipInterval(handle, ref aResult);
        }

        public static bool ClassicSetSlipInterval(int handle, MStabSlipInterval aResult)
        {
            return SetExternalSlipInterval(handle, aResult);
        }

        public static bool ClassicGetLineLoads(int handle, ref MStabLineLoads aResult)
        {
            return GetExternalLineLoads(handle, ref aResult);
        }

        public static bool ClassicGetDefaultNail(int handle, ref MStabDefaultNail aResult)
        {
            return GetExternalNailTypeDefaults(handle, ref aResult);
        }

        public static bool ClassicGetNails(int handle, ref MStabNails aResult)
        {
            return GetExternalNails(handle, ref aResult);
        }

        public static bool ClassicSetLineLoads(int handle, MStabLineLoads aResult)
        {
            return SetExternalLineLoads(handle, aResult);
        }

        public static bool ClassicGetUniformLoads(int handle, ref MStabUniformLoads aResult)
        {
            return GetExternalUniformLoads(handle, ref aResult);
        }

        public static bool ClassicSetUniformLoads(int handle, MStabUniformLoads aResult)
        {
            return SetExternalUniformLoads(handle, aResult);
        }

        public static bool ClassicGetTreeOnSlope(int handle, ref MStabTreeOnSlope aResult)
        {
            return GetExternalTreeOnSlope(handle, ref aResult);
        }

        public static bool ClassicSetTreeOnSlope(int handle, MStabTreeOnSlope aResult)
        {
            return SetExternalTreeOnSlope(handle, aResult);
        }

        public static bool ClassicGetEarthQuake(int handle, ref MStabEarthQuake aResult)
        {
            return GetExternalEarthQuake(handle, ref aResult);
        }

        public static bool ClassicsetEarthQuake(int handle, MStabEarthQuake aResult)
        {
            return SetExternalEarthQuake(handle, aResult);
        }

        public static bool ClassicGetSigmaTauCurves(int handle, ref MStabSigmaTauCurves aResult)
        {
            return GetExternalSigmaTauCurves(handle, ref aResult);
        }

        public static bool ClassicSetSigmaTauCurves(int handle, MStabSigmaTauCurves aResult)
        {
            return SetExternalSigmaTauCurves(handle, aResult);
        }

        public static bool ClassicGetBondStressDiagrams(int handle, ref MStabBondStressDiagrams aResult)
        {
            return GetExternalBondStressDiagrams(handle, ref aResult);
        }

        public static bool ClassicSetBondStressDiagrams(int handle, MStabBondStressDiagrams aResult)
        {
            return SetExternalBondStressDiagrams(handle, aResult);
        }

        public static bool ClassicGetMinimumRequiredCircleDepth(int handle, ref MStabMinimalRequiredCircleDepth aResult)
        {
            return GetExternalMinimalRequiredCircleDepth(handle, ref aResult);
        }

        public static bool ClassicSetMinimumRequiredCircleDepth(int handle, MStabMinimalRequiredCircleDepth aResult)
        {
            return SetExternalMinimalRequiredCircleDepth(handle, aResult);
        }

        public static bool ClassicGetStartValueSafetyFactor(int handle, ref MStabStartValueSafetyFactor aResult)
        {
            return GetExternalStartValueSafetyFactor(handle, ref aResult);
        }

        public static bool ClassicSetStartValueSafetyFactor(int handle, MStabStartValueSafetyFactor aResult)
        {
            return SetExternalStartValueSafetyFactor(handle, aResult);
        }

        public static bool ClassicGetReferenceLevelCu(int handle, ref MStabReferenceLevelCU aResult)
        {
            return GetExternalReferenceLevelCu(handle, ref aResult);
        }

        public static bool ClassicSetReferenceLevelCu(int handle, MStabReferenceLevelCU aResult)
        {
            return SetExternalReferenceLevelCu(handle, aResult);
        }

        public static bool ClassicGetLiftSlipData(int handle, ref MStabLiftSlipData aResult)
        {
            return GetExternalLiftSlipData(handle, ref aResult);
        }

        public static bool ClassicSetLiftSlipData(int handle, MStabLiftSlipData aResult)
        {
            return SetExternalLiftSlipData(handle, aResult);
        }

        public static bool ClassicGetWaterLevels(int handle, ref MStabExternalWaterLevels aResult)
        {
            return GetExternalWaterLevels(handle, ref aResult);
        }

        public static bool ClassicSetWaterLevels(int handle, MStabExternalWaterLevels aResult)
        {
            return SetExternalWaterLevels(handle, aResult);
        }

        public static bool ClassicGetModelFactor(int handle, ref MStabModelFactor aResult)
        {
            return GetExternalModelFactor(handle, ref aResult);
        }

        public static bool ClassicSetModelFactor(int handle, MStabModelFactor aResult)
        {
            return SetExternalModelFactor(handle, aResult);
        }

        public static bool ClassicGetCalculationOptions(int handle, ref MStabCalculationOptions aResult)
        {
            return GetExternalCalculationOptions(handle, ref aResult);
        }

        public static bool ClassicGetGeneticAlgorithmOptions(int handle, ref MStabGeneticAlgorithmOptions aResult)
        {
            return GetExternalGeneticAlgorithmOptions(handle, ref aResult);
        }

        public static bool ClassicSetCalculationOptions(int handle, MStabCalculationOptions aResult)
        {
            return SetExternalCalculationOptions(handle, aResult);
        }

        public static bool ClassicGetProbabilisticDefaults(int handle, ref MStabProbabilisticDefaults aResult)
        {
            return GetExternalProbabilisticDefaults(handle, ref aResult);
        }

        public static bool ClassicSetProbabilisticDefaults(int handle, MStabProbabilisticDefaults aResult)
        {
            return SetExternalProbabilisticDefaults(handle, aResult);
        }

        public static bool ClassicGetNewZonePlotData(int handle, ref MStabNewZonePlotData aResult)
        {
            return GetExternalNewZonePlotData(handle, ref aResult);
        }

        public static bool ClassicSetNewZonePlotData(int handle, MStabNewZonePlotData aResult)
        {
            return SetExternalNewZonePlotData(handle, aResult);
        }

        public static bool ClassicGetHorizontalBalance(int handle, ref MStabHorizontalBalance aResult)
        {
            return GetExternalHorizontalBalance(handle, ref aResult);
        }

        public static bool ClassicSetHorizontalBalance(int handle, MStabHorizontalBalance aResult)
        {
            return SetExternalHorizontalBalance(handle, aResult);
        }

        public static bool ClassicGetRequestedCircleSlices(int handle, ref MStabRequestedCircleSlices aResult)
        {
            return GetExternalRequestedCircleSlices(handle, ref aResult);
        }

        public static bool ClassicSetRequestedCircleSlices(int handle, MStabRequestedCircleSlices aResult)
        {
            return SetExternalRequestedCircleSlices(handle, aResult);
        }

        public static bool ClassicGetRequestedLiftSlices(int handle, ref MStabRequestedLiftSlices aResult)
        {
            return GetExternalRequestedLiftSlices(handle, ref aResult);
        }

        public static bool ClassicSetRequestedLiftSlices(int handle, MStabRequestedLiftSlices aResult)
        {
            return SetExternalRequestedLiftSlices(handle, aResult);
        }

        public static bool ClassicGetRequestedSpencerSlices(int handle, ref MStabRequestedSpencerSlices aResult)
        {
            return GetExternalRequestedSpencerSlices(handle, ref aResult);
        }

        public static bool ClassicSetRequestedSpencerSlices(int handle, MStabRequestedSpencerSlices aResult)
        {
            return SetExternalRequestedSpencerSlices(handle, aResult);
        }

        public static bool ClassicGetSoilResistance(int handle, ref MStabSoilResistance aResult)
        {
            return GetExternalSoilResistance(handle, ref aResult);
        }

        public static bool ClassicSetSoilResistance(int handle, MStabSoilResistance aResult)
        {
            return SetExternalSoilResistance(handle, aResult);
        }

        public static bool ClassicGetModelSpecial(int handle, ref MStabModelSpecial aResult)
        {
            return GetExternalModelSpecial(handle, ref aResult);
        }

        public static bool ClassicSetModelSpecial(int handle, MStabModelSpecial aResult)
        {
            return SetExternalModelSpecial(handle, aResult);
        }

        public static bool ClassicGetNailTypeDefaults(int handle, ref MStabNailTypeDefaults aResult)
        {
            return GetExternalNailTypeDefaults(handle, ref aResult);
        }

        public static bool ClassicSetNailTypeDefaults(int handle, MStabNailTypeDefaults aResult)
        {
            return SetExternalNailTypeDefaults(handle, aResult);
        }

        public static bool ClassicGetGeoTextiles(int handle, ref MStabGeoTextiles aResult)
        {
            return GetExternalGeoTextiles(handle, ref aResult);
        }

        public static bool ClassicSetGeoTextiles(int handle, MStabGeoTextiles aResult)
        {
            return SetExternalGeoTextiles(handle, aResult);
        }

        public static bool ClassicGetForbiddenLines(int handle, ref MStabForbiddenLines aResult)
        {
            return GetExternalForbiddenLines(handle, ref aResult);
        }

        public static bool ClassicSetForbiddenLines(int handle, MStabForbiddenLines aResult)
        {
            return SetExternalForbiddenLines(handle, aResult);
        }

        public static bool ClassicGetSoilGroups(int handle, ref SoilGroups aResult)
        {
            return GetExternalSoilGroups(handle, ref aResult);
        }

        public static bool ClassicSetSoilGroups(int handle, SoilGroups aResult)
        {
            return SetExternalSoilGroups(handle, aResult);
        }

        //MSTAB SPECIFIC  FUNCTIONS
        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalVersion(int aHandle, ref CMStabVersion aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalVersion(int aHandle, CMStabVersion aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalIdentificationTitles(int aHandle, ref MStabIdentificationTitles aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalIdentificationTitles(int aHandle, MStabIdentificationTitles aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalModel(int aHandle, ref MStabModel aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalModel(int aHandle, MStabModel aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalMSeepNet(int aHandle, ref MStabMSeepNet aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalMSeepNet(int aHandle, MStabMSeepNet aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalUnitWeightWater(int aHandle, ref MStabUnitWeightWater aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalUnitWeightWater(int aHandle, MStabUnitWeightWater aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalConsolidationDegree(int aHandle, ref MStabConsolidationDegree aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalConsolidationDegree(int aHandle, MStabConsolidationDegree aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalTemporaryLoadsDegree(int aHandle, ref MStabTemporaryLoadsDegree aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalTemporaryLoadsDegree(int aHandle, MStabTemporaryLoadsDegree aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalFreeWaterDegree(int aHandle, ref MStabFreeWaterDegree aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalFreeWaterDegree(int aHandle, MStabFreeWaterDegree aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalEarthQuakeDegree(int aHandle, ref MStabEarthQuakeDegree aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalEarthQuakeDegree(int aHandle, MStabEarthQuakeDegree aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalCircles(int aHandle, ref MStabCircles aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalCircles(int aHandle, MStabCircles aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalSlipSpencer1(int aHandle, ref MStabSlipSpencer aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalSlipSpencer1(int aHandle, MStabSlipSpencer aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalSlipSpencer2(int aHandle, ref MStabSlipSpencer aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalSlipSpencer2(int aHandle, MStabSlipSpencer aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalSlipInterval(int aHandle, ref MStabSlipInterval aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalSlipInterval(int aHandle, MStabSlipInterval aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalLineLoads(int aHandle, ref MStabLineLoads aResulte);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalLineLoads(int aHandle, MStabLineLoads aResulte);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalNailTypeDefaults(int aHandle, ref MStabDefaultNail aResulte);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalNails(int aHandle, ref MStabNails aResulte);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalNails(int aHandle, MStabNails aResulte);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalUniformLoads(int aHandle, ref MStabUniformLoads aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalUniformLoads(int aHandle, MStabUniformLoads aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalTreeOnSlope(int aHandle, ref MStabTreeOnSlope aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalTreeOnSlope(int aHandle, MStabTreeOnSlope aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalEarthQuake(int aHandle, ref MStabEarthQuake aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalEarthQuake(int aHandle, MStabEarthQuake aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalSigmaTauCurves(int aHandle, ref MStabSigmaTauCurves aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalSigmaTauCurves(int aHandle, MStabSigmaTauCurves aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalBondStressDiagrams(int aHandle, ref MStabBondStressDiagrams aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalBondStressDiagrams(int aHandle, MStabBondStressDiagrams aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalMinimalRequiredCircleDepth(int aHandle, ref MStabMinimalRequiredCircleDepth aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalMinimalRequiredCircleDepth(int aHandle, MStabMinimalRequiredCircleDepth aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalStartValueSafetyFactor(int aHandle, ref MStabStartValueSafetyFactor aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalStartValueSafetyFactor(int aHandle, MStabStartValueSafetyFactor aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalReferenceLevelCu(int aHandle, ref MStabReferenceLevelCU aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalReferenceLevelCu(int aHandle, MStabReferenceLevelCU aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalLiftSlipData(int aHandle, ref MStabLiftSlipData aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalLiftSlipData(int aHandle, MStabLiftSlipData aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalWaterLevels(int aHandle, ref MStabExternalWaterLevels aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalWaterLevels(int aHandle, MStabExternalWaterLevels aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalModelFactor(int aHandle, ref MStabModelFactor aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalModelFactor(int aHandle, MStabModelFactor aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalCalculationOptions(int aHandle, ref MStabCalculationOptions aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalCalculationOptions(int aHandle, MStabCalculationOptions aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalGeneticAlgorithmOptions(int aHandle, ref MStabGeneticAlgorithmOptions aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalProbabilisticDefaults(int aHandle, ref MStabProbabilisticDefaults aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalProbabilisticDefaults(int aHandle, MStabProbabilisticDefaults aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalNewZonePlotData(int aHandle, ref MStabNewZonePlotData aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalNewZonePlotData(int aHandle, MStabNewZonePlotData aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalHorizontalBalance(int aHandle, ref MStabHorizontalBalance aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalHorizontalBalance(int aHandle, MStabHorizontalBalance aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalRequestedCircleSlices(int aHandle, ref MStabRequestedCircleSlices aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalRequestedCircleSlices(int aHandle, MStabRequestedCircleSlices aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalRequestedLiftSlices(int aHandle, ref MStabRequestedLiftSlices aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalRequestedLiftSlices(int aHandle, MStabRequestedLiftSlices aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalRequestedSpencerSlices(int aHandle, ref MStabRequestedSpencerSlices aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalRequestedSpencerSlices(int aHandle, MStabRequestedSpencerSlices aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalSoilResistance(int aHandle, ref MStabSoilResistance aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalSoilResistance(int aHandle, MStabSoilResistance aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalModelSpecial(int aHandle, ref MStabModelSpecial aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalModelSpecial(int aHandle, MStabModelSpecial aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalNailTypeDefaults(int aHandle, ref MStabNailTypeDefaults aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalNailTypeDefaults(int aHandle, MStabNailTypeDefaults aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalGeoTextiles(int aHandle, ref MStabGeoTextiles aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalGeoTextiles(int aHandle, MStabGeoTextiles aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalForbiddenLines(int aHandle, ref MStabForbiddenLines aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalForbiddenLines(int aHandle, MStabForbiddenLines aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool GetExternalSoilGroups(int aHandle, ref SoilGroups aResult);

        [DllImport(MStabConstants.dgsSerializer)]
        private static extern bool SetExternalSoilGroups(int aHandle, SoilGroups aResult);

        #region Nested type: CMStabVersion

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class CMStabVersion
        {
            private int Dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public int mStabVersion;
            public int soilVersion;
            public int geometryVersion;
            public int stressCurveVersion;
            public int bondStressDiagramsVersion;
        };

        #endregion

        #region Nested type: ConsolidationLayer

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct ConsolidationLayer
        {
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxBoundaries)]
            public double[] loadDocLayer;
        };

        #endregion

        #region Nested type: Curves

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct Curves
        {
            public int stressPointCount;
            public string itemName;
            public int numberOfTests;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxStressPoints)]
            public StressPoint[] stressPoint;
        };

        #endregion

        #region Nested type: ForbiddenLine

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct ForbiddenLine
        {
            public string itemName;
            public double x1;
            public double y1;
            public double x2;
            public double y2;
        };

        #endregion

        #region Nested type: GeoTextile

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct GeoTextile
        {
            public string geoTextileName;
            public double xStart;
            public double yStart;
            public double xEnd;
            public double yEnd;
            public double tensileStrenght;
            public double reductionZone;
        };

        #endregion

        #region Nested type: PressurePerLength

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct LineLoad
        {
            public string itemName;
            public double magnitude;
            public double x;
            public double y;
            public double dirAngle;
            public double distriAngle;
        };

        #endregion

        #region Nested type: Nail

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct Nail
        {
            public string itemName;
            public bool useDefault;
            public double x;
            public double y;
            public double horizontalSpacing;
            public double direction;
            public double length;
            public double diameterNail;
            public double diameterGrout;
            public double yieldForce;
            public double plasticMoment;
            public double bendingStiffness;
            public int bearingPlate;

            public int NumberOfLateralStressPoints;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxStressTables)]
            public double[] LateralDistance;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxStressTables)]
            public double[] LateralSigma;

            public int NumberOfShearStressPoints;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxStressTables)]
            public double[] ShearDistance;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxStressTables)]
            public double[] ShearSigma;
        };

        #endregion

        #region Nested type: MStabBondStressDiagrams

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabBondStressDiagrams
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public int numberOfEntries;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxStressTables)]
            public Curves[] curves;
        };

        #endregion

        #region Nested type: MStabCalculationOptions

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabCalculationOptions
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public bool moveCalcGridOn;
            public int probCalculationType;
            public int searchAlgorithm;
        };

        #endregion

        #region Nested type: MStabGeneticAlgorithmOptions

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabGeneticAlgorithmOptions
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c# 

            public int populationCount;
            public int eliteCount;
            public int generationCount;

            public double crossOverScatterFraction;
            public double crossOverSinglePointFraction;
            public double crossOverDoublePointFraction;

            public double mutationJumpFraction;
            public double mutationCreepFraction;
            public double mutationInverseFraction;

            public double mutationRate;
            public double mutationCreepReduction;
        };

        #endregion

        #region Nested type: MStabCircles

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabCircles
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double gridXleft;
            public double gridXRight;
            public int gridNX;
            public double gridYBottom;
            public double gridYTop;
            public int gridNY;
            public double tanYtop;
            public double tanXBottom;
            public double tanYBottom;
            public double tanXTop;
            public int nTan;
            public double xFixed;
            public double yFixed;
            public bool bUseFixPoint;
        };

        #endregion

        #region Nested type: MStabConsolidationDegree

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabConsolidationDegree
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public int numberOfLayers;
            public bool capillair;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxBoundaries)]
            public ConsolidationLayer[] consolidationLayer;
        };

        #endregion

        #region Nested type: MStabConstants

        public static class MStabConstants
        {
            public const String dgsSerializer = "DGSMStabSerializer.dll";
            public const int maxBoundaries = 500;
            public const int maxForbiddenLines = 10;
            public const int maxGeotextiles = 10;
            public const int maxLoads = 10;
            public const int maxNails = 10;
            public const int maxSlipPoints = 100;
            public const int maxSoilGroups = 100;
            public const int maxStressPoints = 100;
            public const int maxStressTables = 1000;
            public const int pLMaxLength = 8;
        }

        #endregion

        #region Nested type: MStabEarthQuake

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabEarthQuake
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double horQuakeFact;
            public double verQuakeFact;
            public double freeWaterFact;
        };

        #endregion

        #region Nested type: MStabEarthQuakeDegree

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8, Size = 48)]
        public class MStabEarthQuakeDegree
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public int nrOfLayers;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 500)]
            public int[] quakeDocLayer;
        };

        #endregion

        #region Nested type: MStabExternalWaterLevels

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabExternalWaterLevels
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public bool waterDataUsed;
            public double mHW;
            public double decimate;
            public int exceeding;
            public int numberOfItems;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.pLMaxLength)]
            public WaterData[] waterProperties;
        };

        #endregion

        #region Nested type: MStabForbiddenLines

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabForbiddenLines
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public int numberLines;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxForbiddenLines)]
            public ForbiddenLine[] lines;
        };

        #endregion

        #region Nested type: MStabFreeWaterDegree

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabFreeWaterDegree
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public int nrOfLayers;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxBoundaries)]
            public int[] loadDocLayer;
        };

        #endregion

        #region Nested type: MStabGeoTextiles

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabGeoTextiles
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public int numberOfItems;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxGeotextiles)]
            public GeoTextile[] geoTextiles;
        };

        #endregion

        #region Nested type: MStabHorizontalBalance

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabHorizontalBalance
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double xLeft;
            public double xRight;
            public double yTop;
            public double yBottom;
            public int nYInterval;
        };

        #endregion

        #region Nested type: MStabIdentificationTitles

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabIdentificationTitles
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public string projectTitle1;
            public string projectTitle2;
            public string projectTitle3;
        };

        #endregion

        #region Nested type: MStabLiftSlipData

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabLiftSlipData
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double leftGridXleft;
            public double leftGridXright;
            public int leftGridNX;
            public double leftGridYbottom;
            public double leftGridYtop;
            public int leftGridNY;
            public double rightGridXleft;
            public double rightGridXright;
            public int rightGridNX;
            public double rightGridYbottom;
            public double rightGridYtop;
            public int rightGridNY;
            public double bottomTangentLine;
            public double topTangentLine;
            public int numberTangentLines;
            public bool isAutomaticTangentUplift;
        };

        #endregion

        #region Nested type: MStabLineLoads

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabLineLoads
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public int nLineLoads;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxLoads)]
            public LineLoad[] lineLoad;
        };

        #endregion

        #region Nested type: MStabDefaultNail

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabDefaultNail
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double length;
            public double diameterNail;
            public double diameterGrout;
            public double yieldForce;
            public double plasticMoment;
            public double bendingStiffness;
            public int bearingPlate;
        };

        #endregion

        #region Nested type: MStabNails

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabNails
        {
            //private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            //public int nNails;
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public int nNails;
            public double CriticalAngle;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxNails)]
            public Nail[] nail;
        };

        #endregion

        #region Nested type: MStabMinimalRequiredCircleDepth

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabMinimalRequiredCircleDepth
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double minimalRequiredDepth;
        };

        #endregion

        #region Nested type: MStabModel

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabModel
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public int calcType;
            public int defaulStrength;
            public bool probabilistic;
            public int defaultInputValues;
            public bool geoTextile;
            public bool nails;
            public bool zonePlot;
            public bool globalMeasurements;
        };

        #endregion

        #region Nested type: MStabModelFactor

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabModelFactor
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double limitValue;
            public double standardDeviation;
            public double referenceLength;
            public double sectionLength;
            public bool isEndSectionUsed;
            public double latStressRatioLength;
            public double varEdgeContribution;
        };

        #endregion

        #region Nested type: MStabModelSpecial

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabModelSpecial
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public bool isAlternativeStrength;
        };

        #endregion

        #region Nested type: MStabMSeepNet

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabMSeepNet
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public bool useMSeepnet;
            public string mSeepFileName;
            public bool netMakeZero;
        };

        #endregion

        #region Nested type: MStabNailTypeDefaults

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabNailTypeDefaults
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double lengthNail;
            public double diameterNail;
            public double diameterGrout;
            public double forceNail;
            public double momentNail;
            public double stiffnessNail;
            public bool bearingPlate;
        };

        #endregion

        #region Nested type: MStabNewZonePlotData

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabNewZonePlotData
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double dikeTableHeight;
            public double xStart;
            public double xMHWInfluence;
            public double yMHWInfluence;
            public double safetyZone1a;
            public double safetyZone1b;
            public double safetyZone2a;
            public double safetyZone2b;
            public double xRoadLeft;
            public double xRoadRight;
            public double safetyZone3a;
            public double safetyZone3b;
            public int stabilitySide;
            public double remoldingFactor;
            public double schematizationFactor;
            public bool standardOvertopping;
        };

        #endregion

        #region Nested type: MStabProbabilisticDefaults

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabProbabilisticDefaults
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double cohesionVariationTotal;
            public double cohesionDesignPartial;
            public double cohesionDesignStdDev;
            public int cohesionDistribution;
            public double phiVariationTotal;
            public double phiDesignPartial;
            public double phiDesignStdDev;
            public int phiDistribution;
            public double stressTableVariationTotal;
            public double stressTableDesignPartial;
            public double stressTableDesignStdDev;
            public int stressTableDistribution;
            public double ratioCuPcVariationTotal;
            public double ratioCuPcDesignPartial;
            public double ratioCuPcDesignStdDev;
            public int ratioCuPcDistribution;
            public double cuVariationTotal;
            public double cuDesignPartial;
            public double cuDesignStdDev;
            public int cuDistribution;
            public double popVariationTotal;
            public double popDesignPartial;
            public double popDesignStdDev;
            public int popDistribution;
            public double compressionRatioVariationTotal;
            public double compressionRatioDesignPartial;
            public double compressionRatioDesignStdDev;
            public int compressionRatioDistribution;
            public double consolidationCoefTotalStdDev;
            public double consolidationCoefDesignPartial;
            public double consolidationCoefDesignStdDev;
            public int consolidationCoefDistribution;
            public double hydraulicPressureTotalStdDev;
            public double hydraulicPressureDesignPartial;
            public double hydraulicPressureDesignStdDev;
            public int hydraulicPressureDistribution;
            public double limitValueBishopMean;
            public double limitValueBishopStdDev;
            public int limitValueBishopDistribution;
            public double limitValueVanMean;
            public double limitValueVanStdDev;
            public int limitValueVanDistribution;
        };

        #endregion

        #region Nested type: MStabReferenceLevelCU

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabReferenceLevelCU
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public int cuReferenceLevel;
        };

        #endregion

        #region Nested type: MStabRequestedCircleSlices

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabRequestedCircleSlices
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public int StriveCircle;
        };

        #endregion

        #region Nested type: MStabRequestedLiftSlices

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabRequestedLiftSlices
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public int striveLift;
        };

        #endregion

        #region Nested type: MStabRequestedSpencerSlices

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabRequestedSpencerSlices
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public int striveSpencer;
        };

        #endregion

        #region Nested type: MStabSigmaTauCurves

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabSigmaTauCurves
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public int numberOfEntries;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxStressTables)]
            public Curves[] curves;
        };

        #endregion

        #region Nested type: MStabSlipInterval

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabSlipInterval
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public int slipInterval;
        };

        #endregion

        #region Nested type: MStabSlipSpencer

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabSlipSpencer
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public int nCoordinates;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxSlipPoints)]
            public Point[] points;
        };

        #endregion

        #region Nested type: MStabSoilResistance

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabSoilResistance
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public int soilResistanceDowelAction;
            public int soilResistancePullOut;
        };

        #endregion

        #region Nested type: MStabStartValueSafetyFactor

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabStartValueSafetyFactor
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double startValueSafetyFactor;
        };

        #endregion

        #region Nested type: MStabTemporaryLoadsDegree

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabTemporaryLoadsDegree
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public bool capillairLoad;
            public int nrOfLayers;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxBoundaries)]
            public int[] loadDocLayer;
        };

        #endregion

        #region Nested type: MStabTreeOnSlope

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabTreeOnSlope
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double windForce;
            public double xCoordinate;
            public double yCoordinate;
            public double widthOfRootZone;
            public double angleOfDistribution;
        };

        #endregion

        #region Nested type: MStabUniformLoads

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabUniformLoads
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public int nUniformLoads;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxLoads)]
            public UniformLoad[] uniformLoad;
        };

        #endregion

        #region Nested type: MStabUnitWeightWater

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class MStabUnitWeightWater
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#         
            public double gamWater;
        };

        #endregion

        #region Nested type: PL

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct PL
        {
            public int pLTop;
            public int pLBot;
        };

        #endregion

        #region Nested type: Point

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct Point
        {
            public double x;
            public double y;
        };

        #endregion

        #region Nested type: SoilGroups

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public class SoilGroups
        {
            private int dummy; //Reserved. The structure size of a class in delphi differs from c#           
            public int numberOfItems;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxSoilGroups)]
            public string[] name;
        };

        #endregion

        #region Nested type: StressPoint

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct StressPoint
        {
            public double sigma;
            public double tau;
            public double tauCharacteristic;
            public double tauMean;
        };

        #endregion

        #region Nested type: UniformLoad

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct UniformLoad
        {
            public string itemName;
            public double magnitude;
            public double xStart;
            public double xend;
            public double distriAngle;
            public int loadType;
        };

        #endregion

        #region Nested type: WaterData

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 8)]
        public struct WaterData
        {
            public string name;
            public int phreaLine;
            public double level;
            public int countPls;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = MStabConstants.maxBoundaries)]
            public PL[] pLs;
        };

        #endregion
    }
}