using NIDAQmx.DAQmxEnum;
using NIDAQmxConst;

namespace NIDAQmx
{
    public class CIChannelConfig : BaseChannelConfig
    {
        internal CIChannelConfig(ChannelAttributeSession session) : base(session)
        {
            AttributeSession = session;
            Timestamp = new TimestampConfig(session);
            Freq = new FreqConfig(session);
            Period = new PeriodConfig(session);
            SemiPeriod = new SemiPeriodConfig(session);
            CountEdges = new CountEdgesConfig(session);
            DutyCycle = new DutyCycleConfig(session);
            Position = new PositionConfig(session);
            PulseWidth = new PulseWidthConfig(session);
            Velocity = new VelocityConfig(session);
            TwoEdgeSep = new TwoEdgeSepConfig(session);
            Pulse = new PulseConfig(session);
            GeneralProperties = new GeneralPropertiesConfig(session);
        }
        public FreqConfig Freq { get; }
        public PeriodConfig Period { get; }
        public CountEdgesConfig CountEdges { get; }
        public DutyCycleConfig DutyCycle { get; }
        public PositionConfig Position { get; }
        public PulseWidthConfig PulseWidth { get; }
        public TimestampConfig Timestamp { get; }
        public VelocityConfig Velocity { get; }
        public TwoEdgeSepConfig TwoEdgeSep { get; }
        public PulseConfig Pulse { get; }
        public SemiPeriodConfig SemiPeriod { get; }
        public GeneralPropertiesConfig GeneralProperties { get; }
        internal override ChannelAttributeSession AttributeSession { get; }
        public double Max { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIMax, double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIMax, double>(value); }
        public double Min { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIMin,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIMin,double>(value); }
        public string CustomScaleName { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICustomScaleName>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICustomScaleName>(value); }
        public CIMeasType MeasType { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIMeasType,CIMeasType>(); }
        public class FreqConfig : BaseChannelConfig
        {
            internal FreqConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                DigFltr = new DigFltrConfig(session);
            }
            public DigFltrConfig DigFltr { get; }
            internal override ChannelAttributeSession AttributeSession { get; }
            public CIFreqUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqUnits,CIFreqUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqUnits,CIFreqUnits>(value); }
            public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqTermCfg,CITermCfg>(value); }
            public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqTerm>(value); }
            public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqLogicLvlBehavior,CILogicLvlBehavior>(value); }
            public double ThreshVoltage { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqThreshVoltage,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqThreshVoltage,double>(value); }
            public double Hyst { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqHyst,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqHyst,double>(value); }
            public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqDigSyncEnable,bool>(value); }
            public AnalogActiveEdge StartingEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqStartingEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqStartingEdge,AnalogActiveEdge>(value); }
            public CIMeasMeth MeasMeth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqMeasMeth,CIMeasMeth>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqMeasMeth,CIMeasMeth>(value); }
            public bool EnableAveraging { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqEnableAveraging,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqEnableAveraging,bool>(value); }
            public double MeasTime { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqMeasTime,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqMeasTime,double>(value); }
            public uint Dev { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqDiv,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqDiv,uint>(value); }

            public class DigFltrConfig : BaseChannelConfig
            {
                internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqDigFltrEnable,bool>(value); }
                public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqDigFltrMinPulseWidth,double>(value); }
                public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqDigFltrTimebaseSrc>(value); }
                public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIFreqDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIFreqDigFltrTimebaseRate,double>(value); }
            }
        }
        public class PeriodConfig : BaseChannelConfig
        {
            internal PeriodConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                DigFltr = new DigFltrConfig(session);
            }
            public DigFltrConfig DigFltr { get; }
            internal override ChannelAttributeSession AttributeSession { get; }
            public CIPeriodUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodUnits,CIPeriodUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodUnits,CIPeriodUnits>(value); }
            public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodTerm>(value); }
            public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodTermCfg,CITermCfg>(value); }
            public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodLogicLvlBehavior,CILogicLvlBehavior>(value); }
            public double ThreshVoltage { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodThreshVoltage,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodThreshVoltage,double>(value); }
            public double Hyst { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodHyst,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodHyst,double>(value); }
            public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodDigSyncEnable,bool>(value); }
            public AnalogActiveEdge StartingEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodStartingEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodStartingEdge,AnalogActiveEdge>(value); }
            public CIMeasMeth MeasMeth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodMeasMeth,CIMeasMeth>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodMeasMeth,CIMeasMeth>(value); }
            public bool EnableAveraging { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodEnableAveraging,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodEnableAveraging,bool>(value); }
            public double MeasTime { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodMeasTime,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodMeasTime,double>(value); }
            public uint Div { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodDiv,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodDiv,uint>(value); }
            public class DigFltrConfig : BaseChannelConfig
            {
                internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodDigFltrEnable,bool>(value); }
                public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodDigFltrMinPulseWidth,double>(value); }
                public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodDigFltrTimebaseRate>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodDigFltrTimebaseSrc>(value); }
                public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPeriodDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPeriodDigFltrTimebaseRate,double>(value); }
            }
        }

        public class CountEdgesConfig : BaseChannelConfig
        {
            internal CountEdgesConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                Gate = new GateConfig(session);
                CountReset = new CountResetConfig(session);
                DigFltr = new DigFltrConfig(session);
                CountDir = new CountDirConfig(session);
            }
            internal override ChannelAttributeSession AttributeSession { get; }
            public DigFltrConfig DigFltr { get; }
            public CountDirConfig CountDir { get; }
            public CountResetConfig CountReset { get; }
            public GateConfig Gate { get; }
            public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesTerm>(value); }
            public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesTermCfg,CITermCfg>(value); }
            public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesLogicLvlBehavior,CILogicLvlBehavior>(value); }
            public double ThreshVoltage { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesThreshVoltage,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesThreshVoltage,double>(value); }
            public double Hyst { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesHyst,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesHyst,double>(value); }
            public uint InitialCnt { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesInitialCnt,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesInitialCnt,uint>(value); }
            public AnalogActiveEdge ActiveEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesActiveEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesActiveEdge,AnalogActiveEdge>(value); }

            public class DigFltrConfig : BaseChannelConfig
            {
                internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesDigFltrEnable,bool>(value); }
                public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesDigFltrMinPulseWidth,double>(value); }
                public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesDigFltrTimebaseSrc>(value); }
                public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesDigFltrTimebaseRate,double>(value); }
            }
            public class CountDirConfig : BaseChannelConfig
            {
                internal CountDirConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public CICountEdgesDir Dir { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesDir,CICountEdgesDir>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesDir,CICountEdgesDir>(value); }
                public string DirTerm { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesDirTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesDirTerm>(value); }
                public CITermCfg TermCfg
                {
                    get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesTermCfg,CITermCfg>(value);
                }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountDirLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountDirLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public double ThreshVoltage { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountDirThreshVoltage,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountDirThreshVoltage,double>(value); }
                public double Hyst { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountDirHyst,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountDirHyst,double>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountDirDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountDirDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountDirDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountDirDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountDirDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountDirDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxSetCICountEdgesCountDirDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountDirDigFltrTimebaseRate,double>(value); }
                }
            }
            public class CountResetConfig : BaseChannelConfig
            {
                internal CountResetConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetEnable,bool>(value); }
                public uint ResetCnt { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetResetCount,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetResetCount,uint>(value); }
                public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetTerm>(value); }
                public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetTermCfg,CITermCfg>(value); }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public double ThreshVoltage { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetThreshVoltage,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetThreshVoltage,double>(value); }
                public double Hyst { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetHyst,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetHyst,double>(value); }
                public AnalogActiveEdge ActiveEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetActiveEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetActiveEdge,AnalogActiveEdge>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesCountResetDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesCountResetDigFltrTimebaseRate,double>(value); }
                }
            }
            public class GateConfig : BaseChannelConfig
            {
                internal GateConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesGateEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateEnable,bool>(value); }
                public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesGateTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateTerm>(value); }
                public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesGateTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateTermCfg,CITermCfg>(value); }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesGateLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public double ThreshVoltage { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesGateThreshVoltage,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateThreshVoltage,double>(value); }
                public double Hyst { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesGateHyst,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateHyst,double>(value); }
                public OutputState When { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesGateWhen,OutputState>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateWhen,OutputState>(value); }
                public DigFltrConfig DigFltr { get; }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesGateDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesGateDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxSetCICountEdgesGateDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICountEdgesGateDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICountEdgesGateDigFltrTimebaseRate,double>(value); }
                }
            }
        }
        public class DutyCycleConfig : BaseChannelConfig
        {
            internal DutyCycleConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                DigFltr = new DigFltrConfig(session);
            }
            public DigFltrConfig DigFltr { get; }
            internal override ChannelAttributeSession AttributeSession { get; }
            public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDutyCycleTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDutyCycleTerm>(value); }
            public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDutyCycleTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDutyCycleTermCfg,CITermCfg>(value); }
            public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDutyCycleLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDutyCycleLogicLvlBehavior,CILogicLvlBehavior>(value); }
            public AnalogActiveEdge StartingEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDutyCycleStartingEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDutyCycleStartingEdge,AnalogActiveEdge>(value); }
            public class DigFltrConfig : BaseChannelConfig
            {
                internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDutyCycleDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDutyCycleDigFltrEnable,bool>(value); }
                public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDutyCycleDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDutyCycleDigFltrMinPulseWidth,double>(value); }
                public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDutyCycleDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDutyCycleDigFltrTimebaseSrc>(value); }
                public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDutyCycleDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDutyCycleDigFltrTimebaseRate,double>(value); }
            }
        }
        public class PositionConfig : BaseChannelConfig
        {
            internal PositionConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                AngEncoder = new AngEncoderConfig(session);
                LinEncoder = new LinEncoderConfig(session);
                AInput = new AInputConfig(session);
                BInput = new BInputConfig(session);
                ZInput = new ZInputConfig(session);
            }
            internal override ChannelAttributeSession AttributeSession { get; }
            public AngEncoderConfig AngEncoder { get; }
            public LinEncoderConfig LinEncoder { get; }
            public AInputConfig AInput { get; }
            public BInputConfig BInput { get; }
            public ZInputConfig ZInput { get; }
            public DecodingType DecodingType { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderDecodingType,DecodingType>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderDecodingType,DecodingType>(value); }
            public bool ZIndexEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZIndexEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZIndexEnable,bool>(value); }
            public double ZIndexVal { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZIndexVal,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZIndexVal,double>(value); }
            public CIZIndexPhase ZIndexPhase { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZIndexPhase,CIZIndexPhase>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZIndexPhase,CIZIndexPhase>(value); }
            public class AngEncoderConfig : BaseChannelConfig
            {
                internal AngEncoderConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public CIAngEncoderUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIAngEncoderUnits,CIAngEncoderUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIAngEncoderUnits,CIAngEncoderUnits>(value); }
                public uint PulsesPerRev { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIAngEncoderPulsesPerRev,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIAngEncoderPulsesPerRev,uint>(value); }
                public double InitialAngle { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIAngEncoderInitialAngle,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIAngEncoderInitialAngle,double>(value); }
            }
            public class LinEncoderConfig : BaseChannelConfig
            {
                internal LinEncoderConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public CILinEncoderUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCILinEncoderUnits,CILinEncoderUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCILinEncoderUnits,CILinEncoderUnits>(value); }
                public double DistPerPulse { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCILinEncoderDistPerPulse,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCILinEncoderDistPerPulse,double>(value); }
                public double InitialPos { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCILinEncoderInitialPos,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCILinEncoderInitialPos,double>(value); }
            }
            public class AInputConfig : BaseChannelConfig
            {
                internal AInputConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderAInputTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderAInputTerm>(value); }
                public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderAInputTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderAInputTermCfg,CITermCfg>(value); }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderAInputLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxGetCIEncoderAInputLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderAInputDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderAInputDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderAInputDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderAInputDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderAInputDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderAInputDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderAInputDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderAInputDigFltrTimebaseRate,double>(value); }
                    public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxSetCIEncoderAInputDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderAInputDigSyncEnable,bool>(value); }
                }
            }
            public class BInputConfig : BaseChannelConfig
            {
                internal BInputConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderBInputTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderBInputTerm>(value); }
                public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderBInputTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderBInputTermCfg,CITermCfg>(value); }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderBInputLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderBInputLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderBInputDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderBInputDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderBInputDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderBInputDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderBInputDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderBInputDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderBInputDigFltrTimebaseRate, double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderBInputDigFltrTimebaseRate,double>(value); }
                    public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderBInputDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderBInputDigSyncEnable,bool>(value); }
                }
            }
            public class ZInputConfig : BaseChannelConfig
            {
                internal ZInputConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZInputTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZInputTerm>(value); }
                public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZInputTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZInputTermCfg,CITermCfg>(value); }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZInputLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZInputLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZInputDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZInputDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZInputDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZInputDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZInputDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZInputDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZInputDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZInputDigFltrTimebaseRate,double>(value); }
                    public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIEncoderZInputDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderZInputDigSyncEnable,bool>(value); }
                }
            }

        }
        public class PulseWidthConfig : BaseChannelConfig
        {
            internal PulseWidthConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                DigFltr = new DigFltrConfig(session);
            }
            internal override ChannelAttributeSession AttributeSession { get; }
            public DigFltrConfig DigFltr { get; }
            public CIPeriodUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseWidthUnits,CIPeriodUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseWidthUnits,CIPeriodUnits>(value); }
            public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseWidthTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseWidthTerm>(value); }
            public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseWidthTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseWidthTermCfg,CITermCfg>(value); }
            public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseWidthLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseWidthLogicLvlBehavior,CILogicLvlBehavior>(value); }
            public AnalogActiveEdge StartingEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqLogicLvlBehavior,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseWidthStartingEdge,AnalogActiveEdge>(value); }
            public class DigFltrConfig : BaseChannelConfig
            {
                internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxSetCIPulseWidthDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseWidthDigFltrEnable,bool>(value); }
                public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseWidthDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseWidthDigFltrMinPulseWidth,double>(value); }
                public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseWidthDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseWidthDigFltrTimebaseSrc>(value); }
                public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseWidthDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseWidthDigFltrTimebaseRate,double>(value); }
                public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseWidthDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseWidthDigSyncEnable,bool>(value); }
            }
        }
        public class TimestampConfig : BaseChannelConfig
        {
            internal TimestampConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                GPS = new GPSConfig(session);
            }
            internal override ChannelAttributeSession AttributeSession { get; }
            public GPSConfig GPS { get; }
            public TimestampUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITimestampUnits,TimestampUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITimestampUnits,TimestampUnits>(value); }
            public uint InitialSeconds { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITimestampInitialSeconds,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITimestampInitialSeconds,uint>(value); }
            public class GPSConfig : BaseChannelConfig
            {
                internal GPSConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public GPSSyncMethod SyncMethod { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIGPSSyncMethod,GPSSyncMethod>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIGPSSyncMethod,GPSSyncMethod>(value); }
                public string SyncSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIGPSSyncSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIGPSSyncSrc>(value); }
            }
        }

        public class VelocityConfig : BaseChannelConfig
        {
            internal VelocityConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                AngEncoder = new AngEncoderConfig(session);
                LinEncoder = new LinEncoderConfig(session);
                AInput = new AInputConfig(session);
                BInput = new BInputConfig(session);
            }
            internal override ChannelAttributeSession AttributeSession { get; }
            public AngEncoderConfig AngEncoder { get; }
            public LinEncoderConfig LinEncoder { get; }
            public AInputConfig AInput { get; }
            public BInputConfig BInput { get; }
            public uint Div { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityDiv,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityDiv,uint>(value); }
            public double MeasTime { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityMeasTime,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityMeasTime,double>(value); }
            public DecodingType DecodingType { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderDecodingType,DecodingType>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderDecodingType,DecodingType>(value); }
            public class AngEncoderConfig : BaseChannelConfig
            {
                internal AngEncoderConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public VelocityAngEncoderUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityAngEncoderUnits,VelocityAngEncoderUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityAngEncoderUnits,VelocityAngEncoderUnits>(value); }
                public uint PulsesPerRev { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIAngEncoderPulsesPerRev,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIAngEncoderPulsesPerRev,uint>(value); }
            }
            public class LinEncoderConfig : BaseChannelConfig
            {
                internal LinEncoderConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public VelocityUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCILinEncoderUnits,VelocityUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCILinEncoderUnits,VelocityUnits>(value); }
                public double DistPerPulse { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCILinEncoderDistPerPulse,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCILinEncoderDistPerPulse,double>(value); }
            }


            public class AInputConfig : BaseChannelConfig
            {
                internal AInputConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderAInputTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderAInputTerm>(value); }
                public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderAInputTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderAInputTermCfg,CITermCfg>(value); }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderAInputLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderAInputLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderAInputDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderAInputDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderAInputDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderAInputDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderAInputDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderAInputDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxSetCIEncoderAInputDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderAInputDigFltrTimebaseRate,double>(value); }
                }
            }


            public class BInputConfig : BaseChannelConfig
            {
                internal BInputConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderBInputTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderBInputTerm>(value); }
                public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxSetCIVelocityEncoderBInputTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderBInputTermCfg,CITermCfg>(value); }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderBInputLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderBInputLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderBInputDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderBInputDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderBInputDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIEncoderBInputDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderBInputDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderBInputDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIVelocityEncoderBInputDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIVelocityEncoderBInputDigFltrTimebaseRate,double>(value); }
                }
            }
        }
        public class TwoEdgeSepConfig : BaseChannelConfig
        {
            internal TwoEdgeSepConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                First = new FirstConfig(session);
                Second = new SecondConfig(session);
            }
            internal override ChannelAttributeSession AttributeSession { get; }
            public FirstConfig First { get; }
            public SecondConfig Second { get; }
            public CIPeriodUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepUnits,CIPeriodUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepUnits,CIPeriodUnits>(value); }

            public class FirstConfig : BaseChannelConfig
            {
                internal FirstConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public AnalogActiveEdge Edge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepFirstEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepFirstEdge,AnalogActiveEdge>(value); }
                public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepFirstTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepFirstTerm>(value); }
                public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepFirstTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepFirstTermCfg,CITermCfg>(value); }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepFirstLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepFirstLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepFirstDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepFirstDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepFirstDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepFirstDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepFirstDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepSecondDigFltrTimebaseRate,double>(value); }
                    public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepFirstDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepFirstDigSyncEnable,bool>(value); }

                }

            }

            public class SecondConfig : BaseChannelConfig
            {
                internal SecondConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public AnalogActiveEdge Edge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepSecondEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepSecondEdge,AnalogActiveEdge>(value); }
                public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepSecondDigFltrTimebaseSrc>(value); }
                public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepSecondTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepSecondTermCfg,CITermCfg>(value); }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepSecondLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepSecondLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepSecondDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepSecondDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepSecondDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepSecondDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepSecondDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepSecondDigFltrTimebaseRate,double>(value); }
                    public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCITwoEdgeSepSecondDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCITwoEdgeSepSecondDigSyncEnable,bool>(value); }

                }

            }
        }

        public class SemiPeriodConfig : BaseChannelConfig
        {
            internal SemiPeriodConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                Input = new InputConfig(session);
            }
            internal override ChannelAttributeSession AttributeSession { get; }
            public InputConfig Input { get; }
            public CIPeriodUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISemiPeriodUnits,CIPeriodUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISemiPeriodUnits,CIPeriodUnits>(value); }
            public AnalogActiveEdge StartingEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISemiPeriodStartingEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISemiPeriodStartingEdge,AnalogActiveEdge>(value); }

            public class InputConfig : BaseChannelConfig
            {
                internal InputConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISemiPeriodTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISemiPeriodTerm>(value); }
                public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISemiPeriodTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISemiPeriodTermCfg,CITermCfg>(value); }
                public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISemiPeriodLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISemiPeriodLogicLvlBehavior,CILogicLvlBehavior>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISemiPeriodDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISemiPeriodDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISemiPeriodDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISemiPeriodDigFltrMinPulseWidth,double>(value); }
                    public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISemiPeriodDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISemiPeriodDigFltrTimebaseSrc>(value); }
                    public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISemiPeriodDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISemiPeriodDigFltrTimebaseRate,double>(value); }
                    public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISemiPeriodDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISemiPeriodDigSyncEnable,bool>(value); }

                }

            }
        }
        public class PulseConfig : BaseChannelConfig
        {
            internal PulseConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                Freq = new FreqConfig(session);
                Time = new TimeConfig(session);
                Ticks = new TicksConfig(session);
            }
            public FreqConfig Freq { get; }
            public TimeConfig Time { get; }
            public TicksConfig Ticks { get; }
            internal override ChannelAttributeSession AttributeSession { get; }

            public class FreqConfig : BaseChannelConfig
            {
                internal FreqConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    Input = new InputConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public InputConfig Input { get; }
                public PulseFreqUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqUnits,PulseFreqUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseFreqUnits,PulseFreqUnits>(value); }
                public AnalogActiveEdge StartingEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqStartEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseFreqStartEdge,AnalogActiveEdge>(value); }

                public class InputConfig : BaseChannelConfig
                {
                    internal InputConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                        DigFltr = new DigFltrConfig(session);
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public DigFltrConfig DigFltr { get; }
                    public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseFreqTerm>(value); }
                    public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseFreqTermCfg,CITermCfg>(value); }
                    public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseFreqLogicLvlBehavior,CILogicLvlBehavior>(value); }
                    public class DigFltrConfig : BaseChannelConfig
                    {
                        internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                        {
                            AttributeSession = session;
                        }
                        internal override ChannelAttributeSession AttributeSession { get; }
                        public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseFreqDigFltrEnable,bool>(value); }
                        public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseFreqDigFltrMinPulseWidth,double>(value); }
                        public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseFreqDigFltrTimebaseSrc>(value); }
                        public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseFreqDigFltrTimebaseRate,double>(value); }
                        public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseFreqDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseFreqDigSyncEnable,bool>(value); }

                    }

                }
            }

            public class TimeConfig : BaseChannelConfig
            {
                internal TimeConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    Input = new InputConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public InputConfig Input { get; }
                public PulseTimeUnits Units { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTimeUnits,PulseTimeUnits>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTimeUnits,PulseTimeUnits>(value); }
                public AnalogActiveEdge StartingEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTimeStartEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTimeStartEdge,AnalogActiveEdge>(value); }

                public class InputConfig : BaseChannelConfig
                {
                    internal InputConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                        DigFltr = new DigFltrConfig(session);
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public DigFltrConfig DigFltr { get; }
                    public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTimeTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTimeTerm>(value); }
                    public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTimeTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTimeTermCfg,CITermCfg>(value); }
                    public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTimeLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTimeLogicLvlBehavior,CILogicLvlBehavior>(value); }
                    public class DigFltrConfig : BaseChannelConfig
                    {
                        internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                        {
                            AttributeSession = session;
                        }
                        internal override ChannelAttributeSession AttributeSession { get; }
                        public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTimeDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTimeDigFltrEnable,bool>(value); }
                        public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTimeDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTimeDigFltrMinPulseWidth,double>(value); }
                        public string TimebaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTimeDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTimeDigFltrTimebaseSrc>(value); }
                        public double TimebaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTimeDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTimeDigFltrTimebaseRate,double>(value); }
                        public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTimeDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTimeDigSyncEnable,bool>(value); }

                    }

                }
            }

            public class TicksConfig : BaseChannelConfig
            {
                internal TicksConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    Input = new InputConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public InputConfig Input { get; }
                public AnalogActiveEdge StartingEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTicksStartEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTicksStartEdge,AnalogActiveEdge>(value); }

                public class InputConfig : BaseChannelConfig
                {
                    internal InputConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                        DigFltr = new DigFltrConfig(session);
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public DigFltrConfig DigFltr { get; }
                    public string Term { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTicksTerm>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTicksTerm>(value); }
                    public CITermCfg TermCfg { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTicksTermCfg,CITermCfg>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTicksTermCfg,CITermCfg>(value); }
                    public CILogicLvlBehavior LogicLvlBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTicksLogicLvlBehavior,CILogicLvlBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTicksLogicLvlBehavior,CILogicLvlBehavior>(value); }
                    public class DigFltrConfig : BaseChannelConfig
                    {
                        internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                        {
                            AttributeSession = session;
                        }
                        internal override ChannelAttributeSession AttributeSession { get; }
                        public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTicksDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTicksDigFltrEnable,bool>(value); }
                        public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTicksDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTicksDigFltrMinPulseWidth,double>(value); }
                        public string TicksbaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTicksDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTicksDigFltrTimebaseSrc>(value); }
                        public double TicksbaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTicksDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTicksDigFltrTimebaseRate,double>(value); }
                        public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPulseTicksDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPulseTicksDigSyncEnable,bool>(value); }

                    }

                }
            }

        }
        public class GeneralPropertiesConfig : BaseChannelConfig
        {
            internal GeneralPropertiesConfig(ChannelAttributeSession session) : base(session)
            {
                AttributeSession = session;
                CtrTimebase = new CtrTimebaseConfig(session);
                Advanced = new AdvancedConfig(session);
            }
            internal override ChannelAttributeSession AttributeSession { get; }
            public double ThreshVoltage { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIThreshVoltage,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIThreshVoltage,double>(value); }
            public uint Count => AttributeSession.GetValue<Internal.CI.DAQmxGetCICount,uint>();
            public OutputState OutputState => AttributeSession.GetValue<Internal.CI.DAQmxGetCIOutputState,OutputState>();
            public bool TCReached => AttributeSession.GetValue<Internal.CI.DAQmxGetCITCReached,bool>();
            public uint CtrTimebaseMasterTimebaseDiv { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICtrTimebaseMasterTimebaseDiv,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICtrTimebaseMasterTimebaseDiv,uint>(value); }
            public SampClkOverrunBehavior SampClkOverrunBehavior { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISampClkOverrunBehavior,SampClkOverrunBehavior>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISampClkOverrunBehavior,SampClkOverrunBehavior>(value); }
            public int SampClkOverrunSentinelVal { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCISampClkOverrunSentinelVal,int>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCISampClkOverrunSentinelVal,int>(value); }

            public CtrTimebaseConfig CtrTimebase { get; }
            public AdvancedConfig Advanced { get; }

            public class CtrTimebaseConfig : BaseChannelConfig
            {
                internal CtrTimebaseConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                    DigFltr = new DigFltrConfig(session);
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DigFltrConfig DigFltr { get; }
                public string Src { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICtrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICtrTimebaseSrc>(value); }
                public double Rate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICtrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICtrTimebaseRate,double>(value); }
                public AnalogActiveEdge ActiveEdge { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICtrTimebaseActiveEdge,AnalogActiveEdge>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICtrTimebaseActiveEdge,AnalogActiveEdge>(value); }
                public class DigFltrConfig : BaseChannelConfig
                {
                    internal DigFltrConfig(ChannelAttributeSession session) : base(session)
                    {
                        AttributeSession = session;
                    }
                    internal override ChannelAttributeSession AttributeSession { get; }
                    public bool Enable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICtrTimebaseDigFltrEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxGetCICtrTimebaseDigFltrEnable,bool>(value); }
                    public double MinPulseWidth { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICtrTimebaseDigFltrMinPulseWidth,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICtrTimebaseDigFltrMinPulseWidth,double>(value); }
                    public string TicksbaseSrc { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICtrTimebaseDigFltrTimebaseSrc>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICtrTimebaseDigFltrTimebaseSrc>(value); }
                    public double TicksbaseRate { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICtrTimebaseDigFltrTimebaseRate,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICtrTimebaseDigFltrTimebaseRate,double>(value); }
                    public bool DigSyncEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCICtrTimebaseDigSyncEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCICtrTimebaseDigSyncEnable,bool>(value); }

                }

            }

            public class AdvancedConfig : BaseChannelConfig
            {
                internal AdvancedConfig(ChannelAttributeSession session) : base(session)
                {
                    AttributeSession = session;
                }
                internal override ChannelAttributeSession AttributeSession { get; }
                public DataXferMech DataXferMech { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDataXferMech,DataXferMech>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDataXferMech,DataXferMech>(value); }
                public InputDataXferReqCond DataXferReqCond { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDataXferReqCond,InputDataXferReqCond>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDataXferReqCond,InputDataXferReqCond>(value); }
                public uint UsbXferReqSize { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIUsbXferReqSize,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIUsbXferReqSize,uint>(value); }
                public uint UsbXferReqCount { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIUsbXferReqCount,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIUsbXferReqCount,uint>(value); }
                public bool MemMapEnable { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIMemMapEnable,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIMemMapEnable,bool>(value); }
                public double MaxMeasPeriod { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIMaxMeasPeriod,double>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIMaxMeasPeriod,double>(value); }
                public uint NumPossiblyInvalidSamps => AttributeSession.GetValue<Internal.CI.DAQmxGetCINumPossiblyInvalidSamps,uint>();
                public bool DupCountPrevention { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIDupCountPrevent,bool>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIDupCountPrevent,bool>(value); }
                public uint Prescaler { get => AttributeSession.GetValue<Internal.CI.DAQmxGetCIPrescaler,uint>(); set => AttributeSession.SetValue<Internal.CI.DAQmxSetCIPrescaler,uint>(value); }
            }
        }
    }
}
