/******************************************************************************
 *                                                                         
 *               Nimbus auto-generated file
 *               !!! WARNING !!! -- DO NOT DIRECTLY EDIT THE CONTENTS OF THIS FILE.
 *				 Changes will be OVERWRITTEN by NIMBUS.
 *
 *****************************************************************************/

#ifndef __INTERFACES_NIMBUS_H__
#define __INTERFACES_NIMBUS_H__

#include "HelpContextIds.nimbus.h"
#include <winerror.h>

[
	export, 
	library_block, 
	uuid("daa6a8e5-6242-4075-80af-b167ab3f2e13"),
	v1_enum
]
enum Agilent34950AErrorCodesEnum
{
	E_AGILENT34950A_WRAPPED_DRIVER_ERROR = 0x80044217,
	E_AGILENT34950A_VALUE_OUT_OF_RANGE = 0x80044217,
	E_AGILENT34950A_MODEL_NOT_SUPPORTED = 0x80044216,
	E_AGILENT34950A_IO_TIMEOUT = 0x80044215,
	E_AGILENT34950A_IO_GENERAL = 0x80044214,
	E_AGILENT34950A_PERSONALITY_NOT_LICENSED = 0x80044213,
	E_AGILENT34950A_PERSONALITY_NOT_INSTALLED = 0x80044212,
	E_AGILENT34950A_PERSONALITY_NOT_ACTIVE = 0x80044211,
	E_AGILENT34950A_UNEXPECTED = 0x80044210
};


__interface IAgilent34950AHandshake;
[idl_quote("interface IAgilent34950AHandshake;")];

__interface IAgilent34950AInput;
[idl_quote("interface IAgilent34950AInput;")];

__interface IAgilent34950AInputMemory;
[idl_quote("interface IAgilent34950AInputMemory;")];

__interface IAgilent34950AOutput;
[idl_quote("interface IAgilent34950AOutput;")];

__interface IAgilent34950AOutputMemory;
[idl_quote("interface IAgilent34950AOutputMemory;")];

__interface IAgilent34950ATrace;
[idl_quote("interface IAgilent34950ATrace;")];

__interface IAgilent34950ACounter;
[idl_quote("interface IAgilent34950ACounter;")];

__interface IAgilent34950ATotalizer;
[idl_quote("interface IAgilent34950ATotalizer;")];

__interface IAgilent34950AMeasurement;
[idl_quote("interface IAgilent34950AMeasurement;")];

__interface IAgilent34950AOutputClock;
[idl_quote("interface IAgilent34950AOutputClock;")];

__interface IAgilent34950A;
[idl_quote("interface IAgilent34950A;")];

__interface IAgilent34950ADigital;
[idl_quote("interface IAgilent34950ADigital;")];


[
	export, 
	library_block, 
	uuid("7f803482-7fad-4513-8c17-eb21d91576d0"),
	v1_enum, 
	helpstring("Enumeration for the comparison types."), 
	helpcontext(HID_AGILENT34950ACOMPARISONTYPEENUM)
]
enum Agilent34950AComparisonTypeEnum
{
	Agilent34950AComparisonTypeEqual = 0,
	Agilent34950AComparisonTypeNotEqual = 1
};

[
	export, 
	library_block, 
	uuid("2b4f85b6-2a0a-4430-8aed-f9e2aae58d6b"),
	v1_enum, 
	helpstring("Enumerates possible states of channels - input or output."), 
	helpcontext(HID_AGILENT34950ADIRECTIONENUM)
]
enum Agilent34950ADirectionEnum
{
	Agilent34950ADirectionInput = 0,
	Agilent34950ADirectionOutput = 1
};

[
	export, 
	library_block, 
	uuid("9f33a102-a68c-4148-ae90-399d263062fa"),
	v1_enum, 
	helpstring("Enumeration for the slope types."), 
	helpcontext(HID_AGILENT34950ATOTALIZESLOPEENUM)
]
enum Agilent34950ATotalizeSlopeEnum
{
	Agilent34950ATotalizeSlopePositive = 0,
	Agilent34950ATotalizeSlopeNegative = 1
};

[
	export, 
	library_block, 
	uuid("a4c22ea1-e7d1-4752-a748-442512b497ee"),
	v1_enum, 
	helpstring("Enumeration for the totalize types."), 
	helpcontext(HID_AGILENT34950ATOTALIZETYPEENUM)
]
enum Agilent34950ATotalizeTypeEnum
{
	Agilent34950ATotalizeTypeRead = 0,
	Agilent34950ATotalizeTypeRReset = 1
};

[
	export, 
	library_block, 
	uuid("9d68bcd6-396a-43e5-8465-dc7c7f9b9c7d"),
	v1_enum, 
	helpstring("Enumeration for the digital channels widths."), 
	helpcontext(HID_AGILENT34950ACHANNELWIDTHENUM)
]
enum Agilent34950AChannelWidthEnum
{
	Agilent34950AChannelWidthByte = 0,
	Agilent34950AChannelWidthWord = 1,
	Agilent34950AChannelWidthLWord = 2
};

[
	export, 
	library_block, 
	uuid("e55380c1-f3f5-4805-82ae-3b6b873d3b89"),
	v1_enum, 
	helpstring("Enumeration for the polarity values."), 
	helpcontext(HID_AGILENT34950APOLARITYENUM)
]
enum Agilent34950APolarityEnum
{
	Agilent34950APolarityNormal = 0,
	Agilent34950APolarityInverted = 1
};

[
	export, 
	library_block, 
	uuid("16f3a297-918e-4a07-8c4d-97799750c4c3"),
	v1_enum, 
	helpstring("Enumeration for the handshake modes."), 
	helpcontext(HID_AGILENT34950AHANDSHAKEMODEENUM)
]
enum Agilent34950AHandshakeModeEnum
{
	Agilent34950AHandshakeModeAsynchronous = 0,
	Agilent34950AHandshakeModeSynchronous = 1
};

[
	export, 
	library_block, 
	uuid("ef0a9e62-604a-4432-8596-2ad6a6ef8c7d"),
	v1_enum, 
	helpstring("Enumeration for the types of driving the handshake lines."), 
	helpcontext(HID_AGILENT34950AHANDSHAKELINETYPEENUM)
]
enum Agilent34950AHandshakeLineTypeEnum
{
	Agilent34950AHandshakeLineTypeActive = 0,
	Agilent34950AHandshakeLineTypeOpenCollector = 1
};

[
	export, 
	library_block, 
	uuid("ad66be02-c5b1-447d-8570-2b30df63d9a7"),
	v1_enum, 
	helpstring("Enumeration for the modes of handshaking lines."), 
	helpcontext(HID_AGILENT34950AHANDSHAKELINEIDENUM)
]
enum Agilent34950AHandshakeLineIDEnum
{
	Agilent34950AHandshakeLineIDH0 = 0,
	Agilent34950AHandshakeLineIDH1 = 1,
	Agilent34950AHandshakeLineIDH2 = 3,
	Agilent34950AHandshakeLineIDAll = 2
};

[
	export, 
	library_block, 
	uuid("d9f9a8fe-38d8-4f5c-afa4-f6e85ca07f09"),
	v1_enum, 
	helpstring("Enumeration for the state modes."), 
	helpcontext(HID_AGILENT34950ASTATEENUM)
]
enum Agilent34950AStateEnum
{
	Agilent34950AStateHiImpedance = 0,
	Agilent34950AStateOff = 1,
	Agilent34950AStateOn = 2
};

[
	export, 
	library_block, 
	uuid("4ce1e7dd-4a47-4fcd-96c1-bba792406220"),
	v1_enum, 
	helpstring("Enumeration for the Strobe modes."), 
	helpcontext(HID_AGILENT34950AHANDSHAKESTROBESOURCEENUM)
]
enum Agilent34950AHandshakeStrobeSourceEnum
{
	Agilent34950AHandshakeStrobeSourceInternal = 0,
	Agilent34950AHandshakeStrobeSourceExternal = 1
};

[
	export, 
	library_block, 
	uuid("79cae73d-4a8f-4c24-ad6d-8212a15584b4"),
	v1_enum, 
	helpstring("Enumeration for the actions."), 
	helpcontext(HID_AGILENT34950AACTIONENUM)
]
enum Agilent34950AActionEnum
{
	Agilent34950AActionContinue = 0,
	Agilent34950AActionStart = 1,
	Agilent34950AActionStop = 2
};

[
	export, 
	library_block, 
	uuid("64356f45-d4e7-484b-b891-00fd74dcf2d1"),
	v1_enum, 
	helpstring("Enumeration for the memory data formats."), 
	helpcontext(HID_AGILENT34950ADATAFORMATENUM)
]
enum Agilent34950ADataFormatEnum
{
	Agilent34950ADataFormatList = 0,
	Agilent34950ADataFormatBlock = 1
};

[
	export, 
	library_block, 
	uuid("145255b2-71a7-4771-8974-f4b18d12df4c"),
	v1_enum, 
	helpstring("Enumeration for the  report conditions."), 
	helpcontext(HID_AGILENT34950AREPORTCONDITIONENUM)
]
enum Agilent34950AReportConditionEnum
{
	Agilent34950AReportConditionFull = 0,
	Agilent34950AReportConditionCompare = 1
};

[
	export, 
	library_block, 
	uuid("e63f98eb-084b-4ee1-8c52-9e33212d5252"),
	v1_enum, 
	helpstring("Enumeration for the output modes."), 
	helpcontext(HID_AGILENT34950AOUTPUTMODEENUM)
]
enum Agilent34950AOutputModeEnum
{
	Agilent34950AOutputModeGate = 0,
	Agilent34950AOutputModeStart = 1,
	Agilent34950AOutputModeStop = 2
};

[
	export, 
	library_block, 
	uuid("399ba27a-22ee-40de-a580-798c091ae68e"),
	v1_enum, 
	helpstring("Enumeration for the trace types."), 
	helpcontext(HID_AGILENT34950ATRACETYPEENUM)
]
enum Agilent34950ATraceTypeEnum
{
	Agilent34950ATraceTypeCount = 0,
	Agilent34950ATraceTypeWones = 1
};

[
	export, 
	library_block, 
	uuid("a9e9b6b8-4727-4906-aaa1-2f75cf4b049c"),
	v1_enum, 
	helpstring("Enumeration for the counter functions."), 
	helpcontext(HID_AGILENT34950AFUNCTIONENUM)
]
enum Agilent34950AFunctionEnum
{
	Agilent34950AFunctionFrequency = 0,
	Agilent34950AFunctionPeriod = 1,
	Agilent34950AFunctionDutyCycle = 2,
	Agilent34950AFunctionPulseWidth = 3,
	Agilent34950AFunctionTotalizer = 4
};

[
	export, 
	library_block, 
	uuid("32a30f04-af54-4e29-ac79-0f3264ad46e6"),
	v1_enum, 
	helpstring("Enumeration for the gate sources."), 
	helpcontext(HID_AGILENT34950AGATESOURCEENUM)
]
enum Agilent34950AGateSourceEnum
{
	Agilent34950AGateSourceInternal = 0,
	Agilent34950AGateSourceExternal = 1
};


[
	object, 
	library_block,
	uuid("87c20a7b-ec6d-4e19-93af-0a14cfbd2e2b"),
	helpstring("IAgilent34950AHandshake interface."), 
	helpcontext(HID_IAGILENT34950AHANDSHAKE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950AHandshake : IUnknown
{
	[helpstring("Sets up all the handshaking parameters for a bank"), helpcontext(HID_IAGILENT34950AHANDSHAKE_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34950AHandshakeModeEnum Mode, [in] double Threshold, [in] double Level);

	[helpstring("Gets the polarity of the specified lines."), helpcontext(HID_IAGILENT34950AHANDSHAKE_GETPOLARITY)]
	HRESULT GetPolarity([in] BSTR ChannelList, [in] Agilent34950AHandshakeLineIDEnum Mode, [out, retval] Agilent34950APolarityEnum* val);

	[helpstring("Sets the polarity on the specified lines."), helpcontext(HID_IAGILENT34950AHANDSHAKE_SETPOLARITY)]
	HRESULT SetPolarity([in] BSTR ChannelList, [in] Agilent34950AHandshakeLineIDEnum Mode, [in] Agilent34950APolarityEnum Polarity);

	[propget, helpstring("Sets or gets the timeout for an asynchronous transfer."), helpcontext(HID_IAGILENT34950AHANDSHAKE_ASYNCTIMEOUT)]
	HRESULT AsyncTimeout([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the timeout for an asynchronous transfer."), helpcontext(HID_IAGILENT34950AHANDSHAKE_ASYNCTIMEOUT)]
	HRESULT AsyncTimeout(BSTR ChannelList, double val);

	[propget, helpstring("Sets or gets the general speed of the bank, in seconds, from which the clock rate, setup and hold time parameters are derived for the handshaking signals."), helpcontext(HID_IAGILENT34950AHANDSHAKE_CYCLETIME)]
	HRESULT CycleTime([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the general speed of the bank, in seconds, from which the clock rate, setup and hold time parameters are derived for the handshaking signals."), helpcontext(HID_IAGILENT34950AHANDSHAKE_CYCLETIME)]
	HRESULT CycleTime(BSTR ChannelList, double val);

	[propget, helpstring("Sets or gets up the high output voltage on the H0, H1 handshaking lines as well as the interrupt line (when it is an output)."), helpcontext(HID_IAGILENT34950AHANDSHAKE_LEVEL)]
	HRESULT Level([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets up the high output voltage on the H0, H1 handshaking lines as well as the interrupt line (when it is an output)."), helpcontext(HID_IAGILENT34950AHANDSHAKE_LEVEL)]
	HRESULT Level(BSTR ChannelList, double val);

	[propget, helpstring("Sets or gets all the handshaking parameters for a bank."), helpcontext(HID_IAGILENT34950AHANDSHAKE_MODE)]
	HRESULT Mode([in] BSTR ChannelList, [out, retval] Agilent34950AHandshakeModeEnum* val);

	[propput, helpstring("Sets or gets all the handshaking parameters for a bank."), helpcontext(HID_IAGILENT34950AHANDSHAKE_MODE)]
	HRESULT Mode(BSTR ChannelList, Agilent34950AHandshakeModeEnum val);

	[propget, helpstring("Sets or gets the general speed of the bank, in Hz, from which the clock rate, setup and hold time parameters are derived for the handshaking signals."), helpcontext(HID_IAGILENT34950AHANDSHAKE_RATE)]
	HRESULT Rate([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the general speed of the bank, in Hz, from which the clock rate, setup and hold time parameters are derived for the handshaking signals."), helpcontext(HID_IAGILENT34950AHANDSHAKE_RATE)]
	HRESULT Rate(BSTR ChannelList, double val);

	[propget, helpstring("Sets or gets the behavior of the handshaking pins."), helpcontext(HID_IAGILENT34950AHANDSHAKE_STATE)]
	HRESULT State([in] BSTR ChannelList, [out, retval] Agilent34950AStateEnum* val);

	[propput, helpstring("Sets or gets the behavior of the handshaking pins."), helpcontext(HID_IAGILENT34950AHANDSHAKE_STATE)]
	HRESULT State(BSTR ChannelList, Agilent34950AStateEnum val);

	[propget, helpstring("Sets or gets the strobe (aka clock) source for SYNC handshaking mode."), helpcontext(HID_IAGILENT34950AHANDSHAKE_SYNCSTROBE)]
	HRESULT SyncStrobe([in] BSTR ChannelList, [out, retval] Agilent34950AHandshakeStrobeSourceEnum* val);

	[propput, helpstring("Sets or gets the strobe (aka clock) source for SYNC handshaking mode."), helpcontext(HID_IAGILENT34950AHANDSHAKE_SYNCSTROBE)]
	HRESULT SyncStrobe(BSTR ChannelList, Agilent34950AHandshakeStrobeSourceEnum val);

	[propget, helpstring("Sets or gets the input threshold for the H2 handshaking line as well as the interrupt line (when it is an input)."), helpcontext(HID_IAGILENT34950AHANDSHAKE_THRESHOLD)]
	HRESULT Threshold([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the input threshold for the H2 handshaking line as well as the interrupt line (when it is an input)."), helpcontext(HID_IAGILENT34950AHANDSHAKE_THRESHOLD)]
	HRESULT Threshold(BSTR ChannelList, double val);

	[propget, helpstring("Gets the drive type for any handshaking lines that are outputs."), helpcontext(HID_IAGILENT34950AHANDSHAKE_DRIVE)]
	HRESULT Drive([in] BSTR ChannelList, [out, retval] Agilent34950AHandshakeLineTypeEnum* val);

	[propput, helpstring("Gets the drive type for any handshaking lines that are outputs."), helpcontext(HID_IAGILENT34950AHANDSHAKE_DRIVE)]
	HRESULT Drive(BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum val);
};

[
	object, 
	library_block,
	uuid("351edf80-86b9-4967-8974-87ae4f518d2a"),
	helpstring("IAgilent34950AInput interface."), 
	helpcontext(HID_IAGILENT34950AINPUT),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950AInput : IUnknown
{
	[helpstring("Configures a digital channel as an input of the specified width.."), helpcontext(HID_IAGILENT34950AINPUT_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34950AChannelWidthEnum Width, [in] double Threshold);

	[propget, helpstring("Sets or gets the digital input threshold for the given channel(s)."), helpcontext(HID_IAGILENT34950AINPUT_THRESHOLD)]
	HRESULT Threshold([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the digital input threshold for the given channel(s)."), helpcontext(HID_IAGILENT34950AINPUT_THRESHOLD)]
	HRESULT Threshold(BSTR ChannelList, double val);

	[propget, helpstring("Pointer to the IAgilent34950AInputMemory interface."), helpcontext(HID_IAGILENT34950AINPUT_MEMORY)]
	HRESULT Memory([out, retval] IAgilent34950AInputMemory** val);
};

[
	object, 
	library_block,
	uuid("dc3fad89-c3d2-490b-8175-ca4f54f49902"),
	helpstring("IAgilent34950AInputMemory interface."), 
	helpcontext(HID_IAGILENT34950AINPUTMEMORY),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950AInputMemory : IUnknown
{
	[helpstring("Configures the buffered memory for input."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34950AActionEnum Action, [in] long Count);

	[helpstring("Clears the buffered memory."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_CLEAR)]
	HRESULT Clear([in] BSTR ChannelList);

	[helpstring("Confogures the Interrupt Settings."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_INTERRUPTSETTINGS)]
	HRESULT InterruptSettings([in] BSTR ChannelList, [in] VARIANT_BOOL State, [in] Agilent34950AReportConditionEnum Mode, [in] Agilent34950AHandshakeLineTypeEnum Drive);

	[helpstring("Non-destructive read all of the data currently stored in the bank memory."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_READALLDATA)]
	HRESULT ReadAllData([in] BSTR Channel, [out, retval] [satype(long)] SAFEARRAY** val);

	[helpstring("Non-destructive read of the data in memory."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_READSELECTEDDATA)]
	HRESULT ReadSelectedData([in] BSTR Channel, [in] long Index, [in] long Count, [out, retval] [satype(long)] SAFEARRAY** val);

	[helpstring("Starts the buffered read."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_START)]
	HRESULT Start([in] BSTR ChannelList);

	[helpstring("Steps a buffered read."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_STEP)]
	HRESULT Step([in] BSTR ChannelList);

	[helpstring("Stops a buffered read."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_STOP)]
	HRESULT Stop([in] BSTR ChannelList);

	[propget, helpstring("Set or gets the action taken on a pattern match for the buffered input memory."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_COMPAREACTION)]
	HRESULT CompareAction([in] BSTR ChannelList, [out, retval] Agilent34950AActionEnum* val);

	[propput, helpstring("Set or gets the action taken on a pattern match for the buffered input memory."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_COMPAREACTION)]
	HRESULT CompareAction(BSTR ChannelList, Agilent34950AActionEnum val);

	[propget, helpstring("Selects the format of data returned by buffered input operation on the 34950A Digital IO module."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_DATAFORMAT)]
	HRESULT DataFormat([in] BSTR Channel, [out, retval] Agilent34950ADataFormatEnum* val);

	[propput, helpstring("Selects the format of data returned by buffered input operation on the 34950A Digital IO module."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_DATAFORMAT)]
	HRESULT DataFormat(BSTR Channel, Agilent34950ADataFormatEnum val);

	[propget, helpstring("Returns the number of samples currently in memory."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_DATAPOINTS)]
	HRESULT DataPoints([in] BSTR Channel, [out, retval] long* val);

	[propget, helpstring("Enables or disables buffered reads (aka memory capture) on the bank, clears memory, applies the sample count, and puts the bank into the ready for trigger state."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_ENABLE)]
	HRESULT Enable([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables or disables buffered reads (aka memory capture) on the bank, clears memory, applies the sample count, and puts the bank into the ready for trigger state."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_ENABLE)]
	HRESULT Enable(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the condition to be reported by the interrupt line"), helpcontext(HID_IAGILENT34950AINPUTMEMORY_INTERRUPTMODE)]
	HRESULT InterruptMode([in] BSTR ChannelList, [out, retval] Agilent34950AReportConditionEnum* val);

	[propput, helpstring("Sets or gets the condition to be reported by the interrupt line"), helpcontext(HID_IAGILENT34950AINPUTMEMORY_INTERRUPTMODE)]
	HRESULT InterruptMode(BSTR ChannelList, Agilent34950AReportConditionEnum val);

	[propget, helpstring("Enables (ON) or disables (OFF) the interrupt line on the bank as an output."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_INTERRUPTENABLE)]
	HRESULT InterruptEnable([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables (ON) or disables (OFF) the interrupt line on the bank as an output."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_INTERRUPTENABLE)]
	HRESULT InterruptEnable(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the polarity of the interrupt line on the bank."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_INTERRUPTPOLARITY)]
	HRESULT InterruptPolarity([in] BSTR ChannelList, [out, retval] Agilent34950APolarityEnum* val);

	[propput, helpstring("Sets or gets the polarity of the interrupt line on the bank."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_INTERRUPTPOLARITY)]
	HRESULT InterruptPolarity(BSTR ChannelList, Agilent34950APolarityEnum val);

	[propget, helpstring("Queries the state of the interrupt line."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_INTERRUPTSTATUS)]
	HRESULT InterruptStatus([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propget, helpstring("Sets or gets how many samples to read into memory."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_SAMPLECOUNT)]
	HRESULT SampleCount([in] BSTR ChannelList, [out, retval] long* val);

	[propput, helpstring("Sets or gets how many samples to read into memory."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_SAMPLECOUNT)]
	HRESULT SampleCount(BSTR ChannelList, long val);

	[propget, helpstring("This query returns 1 if currently reading data into memory or waiting on a handshake and 0 if memory is disabled or stopped."), helpcontext(HID_IAGILENT34950AINPUTMEMORY_STATUS)]
	HRESULT Status([in] BSTR Channel, [out, retval] VARIANT_BOOL* val);
};

[
	object, 
	library_block,
	uuid("b8866b07-6088-417a-837a-52ec87cfdb8f"),
	helpstring("IAgilent34950AOutput interface."), 
	helpcontext(HID_IAGILENT34950AOUTPUT),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950AOutput : IUnknown
{
	[helpstring("Configures the specified channels as an output of the specified width."), helpcontext(HID_IAGILENT34950AOUTPUT_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34950AChannelWidthEnum Width, [in] double VoltageLevel);

	[propget, helpstring("Sets or gets the output driver mode."), helpcontext(HID_IAGILENT34950AOUTPUT_DRIVE)]
	HRESULT Drive([in] BSTR ChannelList, [out, retval] Agilent34950AHandshakeLineTypeEnum* val);

	[propput, helpstring("Sets or gets the output driver mode."), helpcontext(HID_IAGILENT34950AOUTPUT_DRIVE)]
	HRESULT Drive(BSTR ChannelList, Agilent34950AHandshakeLineTypeEnum val);

	[propget, helpstring("Sets or gets the voltage level output by the digital out when it is outputting a logic 1."), helpcontext(HID_IAGILENT34950AOUTPUT_VOLTLEVEL)]
	HRESULT VoltLevel([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the voltage level output by the digital out when it is outputting a logic 1."), helpcontext(HID_IAGILENT34950AOUTPUT_VOLTLEVEL)]
	HRESULT VoltLevel(BSTR ChannelList, double val);

	[propget, helpstring("Pointer to the IAgilent34950AOutputMemory interface."), helpcontext(HID_IAGILENT34950AOUTPUT_MEMORY)]
	HRESULT Memory([out, retval] IAgilent34950AOutputMemory** val);
};

[
	object, 
	library_block,
	uuid("7f36917f-8576-443d-89ae-2f58d6adebf6"),
	helpstring("IAgilent34950AOutputMemory interface."), 
	helpcontext(HID_IAGILENT34950AOUTPUTMEMORY),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950AOutputMemory : IUnknown
{
	[helpstring("Configures the output memory."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_CONFIGURE)]
	HRESULT Configure([in] BSTR Channel, [in] BSTR TraceName, [in] long Cycles);

	[helpstring("Aborts the buffered output."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_ABORT)]
	HRESULT Abort([in] BSTR ChannelList);

	[helpstring("Configures the interrupt settings."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_INTERRUPTSETTINGS)]
	HRESULT InterruptSettings([in] BSTR ChannelList, [in] VARIANT_BOOL State, [in] Agilent34950AOutputModeEnum Mode);

	[helpstring("Starts the buffered write."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_START)]
	HRESULT Start([in] BSTR ChannelList);

	[helpstring("Steps a buffered write."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_STEP)]
	HRESULT Step([in] BSTR ChannelList);

	[helpstring("Stops a buffered write."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_STOP)]
	HRESULT Stop([in] BSTR ChannelList);

	[propget, helpstring("Sets or gets the number of times to output the trace."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_CYCLECOUNT)]
	HRESULT CycleCount([in] BSTR ChannelList, [out, retval] long* val);

	[propput, helpstring("Sets or gets the number of times to output the trace."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_CYCLECOUNT)]
	HRESULT CycleCount(BSTR ChannelList, long val);

	[propget, helpstring("Enables or disables the bank for buffered write."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_ENABLE)]
	HRESULT Enable([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables or disables the bank for buffered write."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_ENABLE)]
	HRESULT Enable(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Enables (ON) or disables (OFF) the interrupt line as an input for controlling the buffered output."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_INTERRUPTENABLE)]
	HRESULT InterruptEnable([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables (ON) or disables (OFF) the interrupt line as an input for controlling the buffered output."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_INTERRUPTENABLE)]
	HRESULT InterruptEnable(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the behavior of the interrupt line when the bank is enabled for buffered output."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_INTERRUPTMODE)]
	HRESULT InterruptMode([in] BSTR ChannelList, [out, retval] Agilent34950AOutputModeEnum* val);

	[propput, helpstring("Sets or gets the behavior of the interrupt line when the bank is enabled for buffered output."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_INTERRUPTMODE)]
	HRESULT InterruptMode(BSTR ChannelList, Agilent34950AOutputModeEnum val);

	[propget, helpstring("Sets or gets the polarity of the interrupt line on the bank."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_INTERRUPTPOLARITY)]
	HRESULT InterruptPolarity([in] BSTR ChannelList, [out, retval] Agilent34950APolarityEnum* val);

	[propput, helpstring("Sets or gets the polarity of the interrupt line on the bank."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_INTERRUPTPOLARITY)]
	HRESULT InterruptPolarity(BSTR ChannelList, Agilent34950APolarityEnum val);

	[propget, helpstring("Sets or gets the trace assigned to the bank."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_TRACESELECT)]
	HRESULT TraceSelect([in] BSTR Channel, [out, retval] BSTR* val);

	[propput, helpstring("Sets or gets the trace assigned to the bank."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_TRACESELECT)]
	HRESULT TraceSelect(BSTR Channel, BSTR val);

	[propget, helpstring("This query returns 1 if currently reading data into memory or waiting on a handshake, 0 if memory is disabled or stopped."), helpcontext(HID_IAGILENT34950AOUTPUTMEMORY_STATUS)]
	HRESULT Status([in] BSTR Channel, [out, retval] VARIANT_BOOL* val);
};

[
	object, 
	library_block,
	uuid("60a6d504-70ae-4335-90b8-32f66c9a4af6"),
	helpstring("IAgilent34950ATrace interface."), 
	helpcontext(HID_IAGILENT34950ATRACE),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950ATrace : IUnknown
{
	[helpstring("Downloads user defined data to the bank."), helpcontext(HID_IAGILENT34950ATRACE_CREATECUSTOM)]
	HRESULT CreateCustom([in] BSTR Channel, [in] BSTR Name, [in] [satype(long)] SAFEARRAY** Data, [in] Agilent34950AChannelWidthEnum Width, [in] long Points);

	[helpstring("Generates and downloads a predefined trace to the bank."), helpcontext(HID_IAGILENT34950ATRACE_CREATESTANDARD)]
	HRESULT CreateStandard([in] BSTR Channel, [in] Agilent34950ATraceTypeEnum Type, [in] BSTR Name, [in] long Points);

	[helpstring("Deletes a trace of the given name from the bank."), helpcontext(HID_IAGILENT34950ATRACE_DELETE)]
	HRESULT Delete([in] BSTR Channel, [in] BSTR Name);

	[helpstring("Deletes all traces on the bank."), helpcontext(HID_IAGILENT34950ATRACE_DELETEALL)]
	HRESULT DeleteAll([in] BSTR Channel);

	[helpstring("Returns the length of the given trace in number of samples."), helpcontext(HID_IAGILENT34950ATRACE_GETPOINTS)]
	HRESULT GetPoints([in] BSTR Channel, [in] BSTR TraceName, [out, retval] long* val);

	[propget, helpstring("Returns commas separated names of the traces on the bank."), helpcontext(HID_IAGILENT34950ATRACE_CATALOG)]
	HRESULT Catalog([in] BSTR Channel, [out, retval] BSTR* val);

	[propget, helpstring("Returns the amount of free space on the bank in terms of number of samples."), helpcontext(HID_IAGILENT34950ATRACE_MEMORYFREE)]
	HRESULT MemoryFree([in] BSTR Channel, [out, retval] long* val);
};

[
	object, 
	library_block,
	uuid("7c59fb84-18c9-4e82-b118-6bdf31cca1a9"),
	helpstring("IAgilent34950ACounter interface."), 
	helpcontext(HID_IAGILENT34950ACOUNTER),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950ACounter : IUnknown
{
	[helpstring("Configures the Counter sub-system."), helpcontext(HID_IAGILENT34950ACOUNTER_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34950AFunctionEnum Function, [in] double GateTime);

	[propget, helpstring("Sets or gets the counter function."), helpcontext(HID_IAGILENT34950ACOUNTER_FUNCTION)]
	HRESULT Function([in] BSTR ChannelList, [out, retval] Agilent34950AFunctionEnum* val);

	[propput, helpstring("Sets or gets the counter function."), helpcontext(HID_IAGILENT34950ACOUNTER_FUNCTION)]
	HRESULT Function(BSTR ChannelList, Agilent34950AFunctionEnum val);

	[propget, helpstring("Sets or gets the gate time."), helpcontext(HID_IAGILENT34950ACOUNTER_GATETIME)]
	HRESULT GateTime([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the gate time."), helpcontext(HID_IAGILENT34950ACOUNTER_GATETIME)]
	HRESULT GateTime(BSTR ChannelList, double val);

	[propget, helpstring("Sets or gets the gate source."), helpcontext(HID_IAGILENT34950ACOUNTER_GATESOURCE)]
	HRESULT GateSource([in] BSTR ChannelList, [out, retval] Agilent34950AGateSourceEnum* val);

	[propput, helpstring("Sets or gets the gate source."), helpcontext(HID_IAGILENT34950ACOUNTER_GATESOURCE)]
	HRESULT GateSource(BSTR ChannelList, Agilent34950AGateSourceEnum val);

	[propget, helpstring("Sets or gets the polarity of the gate to either active high (default; NORMal), or active low (INVerted).  The query returns NORM or INV."), helpcontext(HID_IAGILENT34950ACOUNTER_GATEPOLARITY)]
	HRESULT GatePolarity([in] BSTR ChannelList, [out, retval] Agilent34950APolarityEnum* val);

	[propput, helpstring("Sets or gets the polarity of the gate to either active high (default; NORMal), or active low (INVerted).  The query returns NORM or INV."), helpcontext(HID_IAGILENT34950ACOUNTER_GATEPOLARITY)]
	HRESULT GatePolarity(BSTR ChannelList, Agilent34950APolarityEnum val);

	[propget, helpstring("Sets or gets the threshold voltage for the gate on the counter."), helpcontext(HID_IAGILENT34950ACOUNTER_GATETHRESHOLD)]
	HRESULT GateThreshold([in] long SlotNumber, [out, retval] double* val);

	[propput, helpstring("Sets or gets the threshold voltage for the gate on the counter."), helpcontext(HID_IAGILENT34950ACOUNTER_GATETHRESHOLD)]
	HRESULT GateThreshold(long SlotNumber, double val);

	[propget, helpstring("Sets or gets the slope of the input signal."), helpcontext(HID_IAGILENT34950ACOUNTER_SLOPE)]
	HRESULT Slope([in] BSTR ChannelList, [out, retval] Agilent34950ATotalizeSlopeEnum* val);

	[propput, helpstring("Sets or gets the slope of the input signal."), helpcontext(HID_IAGILENT34950ACOUNTER_SLOPE)]
	HRESULT Slope(BSTR ChannelList, Agilent34950ATotalizeSlopeEnum val);

	[propget, helpstring("Pointer to the IAgilent34950ATotalizer interface."), helpcontext(HID_IAGILENT34950ACOUNTER_TOTALIZER)]
	HRESULT Totalizer([out, retval] IAgilent34950ATotalizer** val);

	[propget, helpstring("Pointer to the IAgilent34950AMeasurement interface."), helpcontext(HID_IAGILENT34950ACOUNTER_MEASUREMENT)]
	HRESULT Measurement([out, retval] IAgilent34950AMeasurement** val);

	[propget, helpstring("Sets or gets the threshold voltage for the counter."), helpcontext(HID_IAGILENT34950ACOUNTER_THRESHOLD)]
	HRESULT Threshold([in] BSTR ChannelList, [out, retval] double* val);

	[propput, helpstring("Sets or gets the threshold voltage for the counter."), helpcontext(HID_IAGILENT34950ACOUNTER_THRESHOLD)]
	HRESULT Threshold(BSTR ChannelList, double val);
};

[
	object, 
	library_block,
	uuid("f1a86eb0-c38f-46b8-a7ec-5307c7bb5429"),
	helpstring("IAgilent34950ATotalizer interface."), 
	helpcontext(HID_IAGILENT34950ATOTALIZER),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950ATotalizer : IUnknown
{
	[helpstring("Configures Totalizer system."), helpcontext(HID_IAGILENT34950ATOTALIZER_CONFIGURE)]
	HRESULT Configure([in] BSTR ChannelList, [in] Agilent34950AGateSourceEnum GateSource, [in] Agilent34950ATotalizeTypeEnum ReadType);

	[helpstring("Clears the totalizer count."), helpcontext(HID_IAGILENT34950ATOTALIZER_CLEAR)]
	HRESULT Clear([in] BSTR ChannelList);

	[helpstring("Returns the current totalizer count."), helpcontext(HID_IAGILENT34950ATOTALIZER_READDATA)]
	HRESULT ReadData([in] BSTR ChannelList, [out, retval] long* val);

	[propget, helpstring("Sets or gets the read type."), helpcontext(HID_IAGILENT34950ATOTALIZER_READTYPE)]
	HRESULT ReadType([in] BSTR ChannelList, [out, retval] Agilent34950ATotalizeTypeEnum* val);

	[propput, helpstring("Sets or gets the read type."), helpcontext(HID_IAGILENT34950ATOTALIZER_READTYPE)]
	HRESULT ReadType(BSTR ChannelList, Agilent34950ATotalizeTypeEnum val);
};

[
	object, 
	library_block,
	uuid("c135f982-97e5-4cf6-9580-21207fef578d"),
	helpstring("IAgilent34950AMeasurement interface."), 
	helpcontext(HID_IAGILENT34950AMEASUREMENT),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950AMeasurement : IUnknown
{
	[helpstring("Aborts an initiated counter measurement in progress."), helpcontext(HID_IAGILENT34950AMEASUREMENT_ABORT)]
	HRESULT Abort([in] BSTR ChannelList);

	[helpstring("Initiates a gated measurement"), helpcontext(HID_IAGILENT34950AMEASUREMENT_INITIATE)]
	HRESULT Initiate([in] BSTR ChannelList);

	[helpstring("Returns the data from the last configured measurement."), helpcontext(HID_IAGILENT34950AMEASUREMENT_READDATA)]
	HRESULT ReadData([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Returns the measured frequency."), helpcontext(HID_IAGILENT34950AMEASUREMENT_FREQUENCY)]
	HRESULT Frequency([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Returns the measured period."), helpcontext(HID_IAGILENT34950AMEASUREMENT_PERIOD)]
	HRESULT Period([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Returns the measured pulse width."), helpcontext(HID_IAGILENT34950AMEASUREMENT_PULSEWIDTH)]
	HRESULT PulseWidth([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Returns the measured duty cycle."), helpcontext(HID_IAGILENT34950AMEASUREMENT_PULSEDUTYCYCLE)]
	HRESULT PulseDutyCycle([in] BSTR ChannelList, [out, retval] double* val);

	[propget, helpstring("Returns the current totalizer count."), helpcontext(HID_IAGILENT34950AMEASUREMENT_TOTALIZECOUNT)]
	HRESULT TotalizeCount([in] BSTR ChannelList, [out, retval] long* val);
};

[
	object, 
	library_block,
	uuid("59de67b5-0ad2-4bb4-96fb-cc7fed211574"),
	helpstring("IAgilent34950AOutputClock interface."), 
	helpcontext(HID_IAGILENT34950AOUTPUTCLOCK),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950AOutputClock : IUnknown
{
	[helpstring("Configures the clock output."), helpcontext(HID_IAGILENT34950AOUTPUTCLOCK_CONFIGURE)]
	HRESULT Configure([in] double Frequency, [in] long Slot, [in] double Voltage);

	[propget, helpstring("Sets or gets the module clock output frequency."), helpcontext(HID_IAGILENT34950AOUTPUTCLOCK_FREQUENCY)]
	HRESULT Frequency([in] long Slot, [out, retval] double* val);

	[propput, helpstring("Sets or gets the module clock output frequency."), helpcontext(HID_IAGILENT34950AOUTPUTCLOCK_FREQUENCY)]
	HRESULT Frequency(long Slot, double val);

	[propget, helpstring("Enables (ON) or disables (default; OFF) the clock output."), helpcontext(HID_IAGILENT34950AOUTPUTCLOCK_STATE)]
	HRESULT State([in] long Slot, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Enables (ON) or disables (default; OFF) the clock output."), helpcontext(HID_IAGILENT34950AOUTPUTCLOCK_STATE)]
	HRESULT State(long Slot, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the voltage level."), helpcontext(HID_IAGILENT34950AOUTPUTCLOCK_LEVEL)]
	HRESULT Level([in] long Slot, [out, retval] double* val);

	[propput, helpstring("Sets or gets the voltage level."), helpcontext(HID_IAGILENT34950AOUTPUTCLOCK_LEVEL)]
	HRESULT Level(long Slot, double val);
};

[
	object, 
	library_block,
	uuid("93a6d949-6249-4bf6-be93-07232d3fffcd"),
	helpstring("Agilent34950A root interface."), 
	helpcontext(HID_IAGILENT34950A),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950A : IUnknown
{
	[propget, helpstring("Retrieves a pointer to the Digital interface."), helpcontext(HID_IAGILENT34950A_DIGITAL)]
	HRESULT Digital([out, retval] IAgilent34950ADigital** val);

	[propget, helpstring("Pointer to the IAgilent34950ACounter interface."), helpcontext(HID_IAGILENT34950A_COUNTER)]
	HRESULT Counter([out, retval] IAgilent34950ACounter** val);

	[propget, helpstring("Pointer to the IAgilent34950AOutputClock interface."), helpcontext(HID_IAGILENT34950A_OUTPUTCLOCK)]
	HRESULT OutputClock([out, retval] IAgilent34950AOutputClock** val);
};

[
	object, 
	library_block,
	uuid("ae9ad702-700a-415b-acdf-28bf6a07abd1"),
	helpstring("IAgilent34950ADigitalEx interface."), 
	helpcontext(HID_IAGILENT34950ADIGITAL),
	pointer_default(unique),
	oleautomation
]
__interface IAgilent34950ADigital : IUnknown
{
	[helpstring("Returns the last 8-bit (byte) value written to the specified output channels."), helpcontext(HID_IAGILENT34950ADIGITAL_QUERYLASTBYTE)]
	HRESULT QueryLastByte([in] BSTR ChannelList, [out, retval] BYTE* val);

	[helpstring("Returns the last 16-bit value written to the specified output channels."), helpcontext(HID_IAGILENT34950ADIGITAL_QUERYLASTWORD)]
	HRESULT QueryLastWord([in] BSTR ChannelList, [out, retval] short* val);

	[helpstring("Reads the value of the specified bit location (0 through 31) on the specified digital input channels and sends the results directly to the instrument output buffer."), helpcontext(HID_IAGILENT34950ADIGITAL_READBIT)]
	HRESULT ReadBit([in] BSTR ChannelList, [in] long BitNumber, [out, retval] VARIANT_BOOL* val);

	[helpstring("Performs an 8-bit read on the specified digital input channels and sends the results directly to the instrument's output buffer."), helpcontext(HID_IAGILENT34950ADIGITAL_READBYTE)]
	HRESULT ReadByte([in] BSTR ChannelList, [out, retval] BYTE* val);

	[helpstring("Performs a 16-bit read on the specified digital input channel (specified channel must be either the first channel or third channel on the module) and sends the results directly to the instrument's output buffer."), helpcontext(HID_IAGILENT34950ADIGITAL_READWORD)]
	HRESULT ReadWord([in] BSTR ChannelList, [out, retval] short* val);

	[helpstring("Performs a 32-bit read on the specified digital input channel (specified channel must be the first channel on a bank of 4 channels) and sends the results directly to the instrument's output buffer."), helpcontext(HID_IAGILENT34950ADIGITAL_READLONGWORD)]
	HRESULT ReadLongWord([in] BSTR ChannelList, [out, retval] long* val);

	[helpstring("Sets or clears individual bits on the specified digital output channels."), helpcontext(HID_IAGILENT34950ADIGITAL_WRITEBIT)]
	HRESULT WriteBit([in] BSTR ChannelList, [in] long Data, [in] long BitNumber);

	[helpstring("Outputs the specified 8-bit (byte) value on the specified digital output channels."), helpcontext(HID_IAGILENT34950ADIGITAL_WRITEBYTE)]
	HRESULT WriteByte([in] BSTR ChannelList, [in] long Data);

	[helpstring("Outputs the specified 16-bit pattern on the specified digital output channels (must be either first or third channel on a module)."), helpcontext(HID_IAGILENT34950ADIGITAL_WRITEWORD)]
	HRESULT WriteWord([in] BSTR ChannelList, [in] long Data);

	[helpstring("Outputs the specified 32-bit pattern on the specified digital output channels (must be the first channel on a bank of 4 channels)."), helpcontext(HID_IAGILENT34950ADIGITAL_WRITELONGWORD)]
	HRESULT WriteLongWord([in] BSTR ChannelList, [in] long Data);

	[helpstring("Queries the last value (0 or 1) that was output at this bit position."), helpcontext(HID_IAGILENT34950ADIGITAL_QUERYLASTBIT)]
	HRESULT QueryLastBit([in] BSTR ChannelList, [in] long BitNumber, [out, retval] BYTE* val);

	[helpstring("Reads an 8-, 16-, or 32-bit digital pattern from the specified digital output channels."), helpcontext(HID_IAGILENT34950ADIGITAL_QUERYLASTLONGWORD)]
	HRESULT QueryLastLongWord([in] BSTR ChannelList, [out, retval] long* val);

	[propget, helpstring("Disables or enables the pattern comparison mode on the digital modules. This command applies to digital input operations on the specified bank (DIO1 or DIO2)."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONENABLE)]
	HRESULT ComparisonEnable([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the pattern comparison mode on the digital modules. This command applies to digital input operations on the specified bank (DIO1 or DIO2)."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONENABLE)]
	HRESULT ComparisonEnable(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the type of comparison - Equal or NotEqual."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONTYPE)]
	HRESULT ComparisonType([in] BSTR ChannelList, [out, retval] Agilent34950AComparisonTypeEnum* val);

	[propput, helpstring("Sets or gets the type of comparison - Equal or NotEqual."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONTYPE)]
	HRESULT ComparisonType(BSTR ChannelList, Agilent34950AComparisonTypeEnum val);

	[propget, helpstring("Sets or gets the state of the channel - input or output"), helpcontext(HID_IAGILENT34950ADIGITAL_DIRECTION)]
	HRESULT Direction([in] BSTR ChannelList, [out, retval] Agilent34950ADirectionEnum* val);

	[propput, helpstring("Sets or gets the state of the channel - input or output"), helpcontext(HID_IAGILENT34950ADIGITAL_DIRECTION)]
	HRESULT Direction(BSTR ChannelList, Agilent34950ADirectionEnum val);

	[propget, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONDATABYTE)]
	HRESULT ComparisonDataByte([in] BSTR ChannelList, [out, retval] BYTE* val);

	[propput, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONDATABYTE)]
	HRESULT ComparisonDataByte(BSTR ChannelList, BYTE val);

	[propget, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules"), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONDATAWORD)]
	HRESULT ComparisonDataWord([in] BSTR ChannelList, [out, retval] short* val);

	[propput, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules"), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONDATAWORD)]
	HRESULT ComparisonDataWord(BSTR ChannelList, short val);

	[propget, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules"), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONDATALONGWORD)]
	HRESULT ComparisonDataLongWord([in] BSTR ChannelList, [out, retval] long* val);

	[propput, helpstring("Sets or gets the data bit pattern for comparisons on the digital modules"), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONDATALONGWORD)]
	HRESULT ComparisonDataLongWord(BSTR ChannelList, long val);

	[propget, helpstring("Disables or enables the pattern comparison mode on the digital modules."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONALARMENABLE)]
	HRESULT ComparisonAlarmEnable([in] BSTR ChannelList, [out, retval] VARIANT_BOOL* val);

	[propput, helpstring("Disables or enables the pattern comparison mode on the digital modules."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONALARMENABLE)]
	HRESULT ComparisonAlarmEnable(BSTR ChannelList, VARIANT_BOOL val);

	[propget, helpstring("Sets or gets the comparison mask."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONMASKBYTE)]
	HRESULT ComparisonMaskByte([in] BSTR ChannelList, [out, retval] BYTE* val);

	[propput, helpstring("Sets or gets the comparison mask."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONMASKBYTE)]
	HRESULT ComparisonMaskByte(BSTR ChannelList, BYTE val);

	[propget, helpstring("Sets or gets the word comparison mask."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONMASKWORD)]
	HRESULT ComparisonMaskWord([in] BSTR ChannelList, [out, retval] short* val);

	[propput, helpstring("Sets or gets the word comparison mask."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONMASKWORD)]
	HRESULT ComparisonMaskWord(BSTR ChannelList, short val);

	[propget, helpstring("Sets or gets the long word comparison mask."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONMASKLONGWORD)]
	HRESULT ComparisonMaskLongWord([in] BSTR ChannelList, [out, retval] long* val);

	[propput, helpstring("Sets or gets the long word comparison mask."), helpcontext(HID_IAGILENT34950ADIGITAL_COMPARISONMASKLONGWORD)]
	HRESULT ComparisonMaskLongWord(BSTR ChannelList, long val);

	[propget, helpstring("Sets or gets the width of the digital channel."), helpcontext(HID_IAGILENT34950ADIGITAL_WIDTH)]
	HRESULT Width([in] BSTR ChannelList, [out, retval] Agilent34950AChannelWidthEnum* val);

	[propput, helpstring("Sets or gets the width of the digital channel."), helpcontext(HID_IAGILENT34950ADIGITAL_WIDTH)]
	HRESULT Width(BSTR ChannelList, Agilent34950AChannelWidthEnum val);

	[propget, helpstring("Sets or gets the polarity of the dio channel."), helpcontext(HID_IAGILENT34950ADIGITAL_POLARITY)]
	HRESULT Polarity([in] BSTR ChannelList, [out, retval] Agilent34950APolarityEnum* val);

	[propput, helpstring("Sets or gets the polarity of the dio channel."), helpcontext(HID_IAGILENT34950ADIGITAL_POLARITY)]
	HRESULT Polarity(BSTR ChannelList, Agilent34950APolarityEnum val);

	[propget, helpstring("Pointer to the IAgilent34950AHandshake interface."), helpcontext(HID_IAGILENT34950ADIGITAL_HANDSHAKE)]
	HRESULT Handshake([out, retval] IAgilent34950AHandshake** val);

	[propget, helpstring("Pointer to the IAgilent34950AInput interface."), helpcontext(HID_IAGILENT34950ADIGITAL_INPUT)]
	HRESULT Input([out, retval] IAgilent34950AInput** val);

	[propget, helpstring("Pointer to the IAgilent34950AOutput interface."), helpcontext(HID_IAGILENT34950ADIGITAL_OUTPUT)]
	HRESULT Output([out, retval] IAgilent34950AOutput** val);

	[propget, helpstring("Pointer to the IAgilent34950ATrace interface."), helpcontext(HID_IAGILENT34950ADIGITAL_TRACE)]
	HRESULT Trace([out, retval] IAgilent34950ATrace** val);
};


#endif // __INTERFACES_NIMBUS_H__
