/// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndGetPosition().</remarks>
 /// <param name="aIndex"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginGetPosition(uint aIndex, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionGetPosition, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionGetPosition.InputParameter(inIndex++), aIndex));
     int outIndex = 0;
     invocation.AddOutput(new ArgumentUint((ParameterUint)iActionGetPosition.OutputParameter(outIndex++)));
     invocation.AddOutput(new ArgumentUint((ParameterUint)iActionGetPosition.OutputParameter(outIndex++)));
     invocation.AddOutput(new ArgumentUint((ParameterUint)iActionGetPosition.OutputParameter(outIndex++)));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndListPresets().</remarks>
 /// <param name="aInstanceID"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginListPresets(uint aInstanceID, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionListPresets, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionListPresets.InputParameter(inIndex++), aInstanceID));
     int outIndex = 0;
     invocation.AddOutput(new ArgumentString((ParameterString)iActionListPresets.OutputParameter(outIndex++)));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSetBlueVideoBlackLevel().</remarks>
 /// <param name="aInstanceID"></param>
 /// <param name="aDesiredBlueVideoBlackLevel"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSetBlueVideoBlackLevel(uint aInstanceID, uint aDesiredBlueVideoBlackLevel, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSetBlueVideoBlackLevel, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetBlueVideoBlackLevel.InputParameter(inIndex++), aInstanceID));
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetBlueVideoBlackLevel.InputParameter(inIndex++), aDesiredBlueVideoBlackLevel));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSetVolumeDB().</remarks>
 /// <param name="aInstanceID"></param>
 /// <param name="aChannel"></param>
 /// <param name="aDesiredVolume"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSetVolumeDB(uint aInstanceID, String aChannel, int aDesiredVolume, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSetVolumeDB, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetVolumeDB.InputParameter(inIndex++), aInstanceID));
     invocation.AddInput(new ArgumentString((ParameterString)iActionSetVolumeDB.InputParameter(inIndex++), aChannel));
     invocation.AddInput(new ArgumentInt((ParameterInt)iActionSetVolumeDB.InputParameter(inIndex++), aDesiredVolume));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndGetVerticalKeystone().</remarks>
 /// <param name="aInstanceID"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginGetVerticalKeystone(uint aInstanceID, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionGetVerticalKeystone, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionGetVerticalKeystone.InputParameter(inIndex++), aInstanceID));
     int outIndex = 0;
     invocation.AddOutput(new ArgumentInt((ParameterInt)iActionGetVerticalKeystone.OutputParameter(outIndex++)));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndResetRecordTask().</remarks>
 /// <param name="aRecordTaskID"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginResetRecordTask(String aRecordTaskID, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionResetRecordTask, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentString((ParameterString)iActionResetRecordTask.InputParameter(inIndex++), aRecordTaskID));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSetHorizontalKeystone().</remarks>
 /// <param name="aInstanceID"></param>
 /// <param name="aDesiredHorizontalKeystone"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSetHorizontalKeystone(uint aInstanceID, int aDesiredHorizontalKeystone, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSetHorizontalKeystone, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetHorizontalKeystone.InputParameter(inIndex++), aInstanceID));
     invocation.AddInput(new ArgumentInt((ParameterInt)iActionSetHorizontalKeystone.InputParameter(inIndex++), aDesiredHorizontalKeystone));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSourceXml().</remarks>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSourceXml(CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSourceXml, aCallback);
     int outIndex = 0;
     invocation.AddOutput(new ArgumentString((ParameterString)iActionSourceXml.OutputParameter(outIndex++)));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSourceXmlChangeCount().</remarks>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSourceXmlChangeCount(CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSourceXmlChangeCount, aCallback);
     int outIndex = 0;
     invocation.AddOutput(new ArgumentUint((ParameterUint)iActionSourceXmlChangeCount.OutputParameter(outIndex++)));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSetStandby().</remarks>
 /// <param name="aValue"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSetStandby(bool aValue, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSetStandby, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentBool((ParameterBool)iActionSetStandby.InputParameter(inIndex++), aValue));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSource().</remarks>
 /// <param name="aIndex"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSource(uint aIndex, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSource, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionSource.InputParameter(inIndex++), aIndex));
     int outIndex = 0;
     invocation.AddOutput(new ArgumentString((ParameterString)iActionSource.OutputParameter(outIndex++)));
     invocation.AddOutput(new ArgumentString((ParameterString)iActionSource.OutputParameter(outIndex++)));
     invocation.AddOutput(new ArgumentString((ParameterString)iActionSource.OutputParameter(outIndex++)));
     invocation.AddOutput(new ArgumentBool((ParameterBool)iActionSource.OutputParameter(outIndex++)));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSetSourceIndexByName().</remarks>
 /// <param name="aValue"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSetSourceIndexByName(String aValue, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSetSourceIndexByName, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentString((ParameterString)iActionSetSourceIndexByName.InputParameter(inIndex++), aValue));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSetSourceIndex().</remarks>
 /// <param name="aValue"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSetSourceIndex(uint aValue, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSetSourceIndex, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetSourceIndex.InputParameter(inIndex++), aValue));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSetColor().</remarks>
 /// <param name="aIndex"></param>
 /// <param name="aColor"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSetColor(uint aIndex, uint aColor, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSetColor, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetColor.InputParameter(inIndex++), aIndex));
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetColor.InputParameter(inIndex++), aColor));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndGetSortCapabilities().</remarks>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginGetSortCapabilities(CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionGetSortCapabilities, aCallback);
     int outIndex = 0;
     invocation.AddOutput(new ArgumentString((ParameterString)iActionGetSortCapabilities.OutputParameter(outIndex++)));
     invocation.AddOutput(new ArgumentUint((ParameterUint)iActionGetSortCapabilities.OutputParameter(outIndex++)));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndStandby().</remarks>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginStandby(CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionStandby, aCallback);
     int outIndex = 0;
     invocation.AddOutput(new ArgumentBool((ParameterBool)iActionStandby.OutputParameter(outIndex++)));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndGetStateUpdateID().</remarks>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginGetStateUpdateID(CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionGetStateUpdateID, aCallback);
     int outIndex = 0;
     invocation.AddOutput(new ArgumentUint((ParameterUint)iActionGetStateUpdateID.OutputParameter(outIndex++)));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndBrowseRecordTasks().</remarks>
 /// <param name="aRecordScheduleID"></param>
 /// <param name="aFilter"></param>
 /// <param name="aStartingIndex"></param>
 /// <param name="aRequestedCount"></param>
 /// <param name="aSortCriteria"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginBrowseRecordTasks(String aRecordScheduleID, String aFilter, uint aStartingIndex, uint aRequestedCount, String aSortCriteria, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionBrowseRecordTasks, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentString((ParameterString)iActionBrowseRecordTasks.InputParameter(inIndex++), aRecordScheduleID));
     invocation.AddInput(new ArgumentString((ParameterString)iActionBrowseRecordTasks.InputParameter(inIndex++), aFilter));
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionBrowseRecordTasks.InputParameter(inIndex++), aStartingIndex));
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionBrowseRecordTasks.InputParameter(inIndex++), aRequestedCount));
     invocation.AddInput(new ArgumentString((ParameterString)iActionBrowseRecordTasks.InputParameter(inIndex++), aSortCriteria));
     int outIndex = 0;
     invocation.AddOutput(new ArgumentString((ParameterString)iActionBrowseRecordTasks.OutputParameter(outIndex++)));
     invocation.AddOutput(new ArgumentUint((ParameterUint)iActionBrowseRecordTasks.OutputParameter(outIndex++)));
     invocation.AddOutput(new ArgumentUint((ParameterUint)iActionBrowseRecordTasks.OutputParameter(outIndex++)));
     invocation.AddOutput(new ArgumentUint((ParameterUint)iActionBrowseRecordTasks.OutputParameter(outIndex++)));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndSetGreenVideoGain().</remarks>
 /// <param name="aInstanceID"></param>
 /// <param name="aDesiredGreenVideoGain"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginSetGreenVideoGain(uint aInstanceID, uint aDesiredGreenVideoGain, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionSetGreenVideoGain, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetGreenVideoGain.InputParameter(inIndex++), aInstanceID));
     invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetGreenVideoGain.InputParameter(inIndex++), aDesiredGreenVideoGain));
     iService.InvokeAction(invocation);
 }

 /// <summary>
 /// Invoke the action asynchronously
 /// </summary>
 /// <remarks>Returns immediately and will run the client-specified callback when the action
 /// later completes.  Any output arguments can then be retrieved by calling
 /// EndEnableRecordSchedule().</remarks>
 /// <param name="aRecordScheduleID"></param>
 /// <param name="aCallback">Delegate to run when the action completes.
 /// This is guaranteed to be run but may indicate an error</param>
 public void BeginEnableRecordSchedule(String aRecordScheduleID, CallbackAsyncComplete aCallback)
 {
     Invocation invocation = iService.Invocation(iActionEnableRecordSchedule, aCallback);
     int inIndex = 0;
     invocation.AddInput(new ArgumentString((ParameterString)iActionEnableRecordSchedule.InputParameter(inIndex++), aRecordScheduleID));
     iService.InvokeAction(invocation);
 }