text: /**
   * Proxy for upnp.org:Dimming:1
   */
  #ifndef HEADER_UPNPORGDIMMING1_C
  #define HEADER_UPNPORGDIMMING1_C
  
  #include <OpenHome/OsTypes.h>
  #include <OpenHome/Defines.h>
  #include <OpenHome/Net/C/Async.h>
  #include <OpenHome/Net/C/OhNet.h>
  #include <OpenHome/Net/C/CpDevice.h>
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  /**
   * @addtogroup CpProxyUpnpOrgDimming1
   * @ingroup Proxies
   * @{
   */
  
  /**
   * Constructor.
   * Creates an instance of CpProxyUpnpOrgDimming1 without support for eventing.
   * Use CpProxyC[Un]Subscribe() to enable/disable querying of state variable and
   * reporting of their changes.
   *
   * @param[in]  aDevice   The device to use
   *
   * @return  Handle which should be used with all other functions in this header
   */
  DllExport THandle STDCALL CpProxyUpnpOrgDimming1Create(CpDeviceC aDevice);
  /**
   * Destructor.
   * If any asynchronous method is in progress, this will block until they complete.
   * [Note that any methods still in progress are likely to complete with an error.]
   * Clients who have called CpProxyCSubscribe() do not need to call CpProxyCSubscribe()
   * before calling delete.  An unsubscribe will be triggered automatically when required.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1Destroy(THandle aHandle);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewLoadlevelTarget
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncSetLoadLevelTarget(THandle aHandle, uint32_t anewLoadlevelTarget);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewLoadlevelTarget
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginSetLoadLevelTarget(THandle aHandle, uint32_t anewLoadlevelTarget, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndSetLoadLevelTarget(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aGetLoadlevelTarget
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetLoadLevelTarget(THandle aHandle, uint32_t* aGetLoadlevelTarget);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginGetLoadLevelTarget(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aGetLoadlevelTarget
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndGetLoadLevelTarget(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aGetLoadlevelTarget);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aretLoadlevelStatus
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetLoadLevelStatus(THandle aHandle, uint32_t* aretLoadlevelStatus);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginGetLoadLevelStatus(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aretLoadlevelStatus
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndGetLoadLevelStatus(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretLoadlevelStatus);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewOnEffectLevel
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncSetOnEffectLevel(THandle aHandle, uint32_t anewOnEffectLevel);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewOnEffectLevel
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginSetOnEffectLevel(THandle aHandle, uint32_t anewOnEffectLevel, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndSetOnEffectLevel(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewOnEffect
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncSetOnEffect(THandle aHandle, const char* anewOnEffect);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewOnEffect
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginSetOnEffect(THandle aHandle, const char* anewOnEffect, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndSetOnEffect(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aretOnEffect
   * @param[out] aretOnEffectLevel
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetOnEffectParameters(THandle aHandle, char** aretOnEffect, uint32_t* aretOnEffectLevel);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginGetOnEffectParameters(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aretOnEffect
   * @param[out] aretOnEffectLevel
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndGetOnEffectParameters(THandle aHandle, OhNetHandleAsync aAsync, char** aretOnEffect, uint32_t* aretOnEffectLevel);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncStepUp(THandle aHandle);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginStepUp(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndStepUp(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncStepDown(THandle aHandle);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginStepDown(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndStepDown(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncStartRampUp(THandle aHandle);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginStartRampUp(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndStartRampUp(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncStartRampDown(THandle aHandle);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginStartRampDown(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndStartRampDown(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncStopRamp(THandle aHandle);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginStopRamp(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndStopRamp(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewLoadLevelTarget
   * @param[in]  anewRampTime
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncStartRampToLevel(THandle aHandle, uint32_t anewLoadLevelTarget, uint32_t anewRampTime);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewLoadLevelTarget
   * @param[in]  anewRampTime
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginStartRampToLevel(THandle aHandle, uint32_t anewLoadLevelTarget, uint32_t anewRampTime, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndStartRampToLevel(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewStepDelta
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncSetStepDelta(THandle aHandle, uint32_t anewStepDelta);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewStepDelta
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginSetStepDelta(THandle aHandle, uint32_t anewStepDelta, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndSetStepDelta(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aretStepDelta
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetStepDelta(THandle aHandle, uint32_t* aretStepDelta);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginGetStepDelta(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aretStepDelta
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndGetStepDelta(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretStepDelta);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewRampRate
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncSetRampRate(THandle aHandle, uint32_t anewRampRate);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  anewRampRate
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginSetRampRate(THandle aHandle, uint32_t anewRampRate, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndSetRampRate(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aretRampRate
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetRampRate(THandle aHandle, uint32_t* aretRampRate);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginGetRampRate(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aretRampRate
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndGetRampRate(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretRampRate);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncPauseRamp(THandle aHandle);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginPauseRamp(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndPauseRamp(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncResumeRamp(THandle aHandle);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginResumeRamp(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndResumeRamp(THandle aHandle, OhNetHandleAsync aAsync);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aretIsRamping
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetIsRamping(THandle aHandle, uint32_t* aretIsRamping);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginGetIsRamping(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aretIsRamping
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndGetIsRamping(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretIsRamping);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aretRampPaused
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetRampPaused(THandle aHandle, uint32_t* aretRampPaused);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginGetRampPaused(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aretRampPaused
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndGetRampPaused(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretRampPaused);
  
  /**
   * Invoke the action synchronously.  Blocks until the action has been processed
   * on the device and sets any output arguments.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aretRampTime
   *
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1SyncGetRampTime(THandle aHandle, uint32_t* aretRampTime);
  /**
   * Invoke the action asynchronously.
   * Returns immediately and will run the client-specified callback when the action
   * later completes.  Any output arguments can then be retrieved by calling
   * EndGetProtocolInfo().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback Callback to run when the action completes.
   *                       This is guaranteed to be run but may indicate an error
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1BeginGetRampTime(THandle aHandle, OhNetCallbackAsync aCallback, void* aPtr);
  /**
   * Retrieve the output arguments from an asynchronously invoked action.
   * This may only be called from the callback set in the above Begin function.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aretRampTime
   *
   * @return  0 if the function succedded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1EndGetRampTime(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aretRampTime);
  /**
   * Set a callback to be run when the LoadLevelStatus state variable changes.
   *
   * Callbacks may be run in different threads but callbacks for a
   * CpProxyUpnpOrgDimming1 instance will not overlap.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback The callback to run when the state variable changes
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1SetPropertyLoadLevelStatusChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr);
  /**
   * Set a callback to be run when the StepDelta state variable changes.
   *
   * Callbacks may be run in different threads but callbacks for a
   * CpProxyUpnpOrgDimming1 instance will not overlap.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback The callback to run when the state variable changes
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1SetPropertyStepDeltaChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr);
  /**
   * Set a callback to be run when the RampRate state variable changes.
   *
   * Callbacks may be run in different threads but callbacks for a
   * CpProxyUpnpOrgDimming1 instance will not overlap.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback The callback to run when the state variable changes
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1SetPropertyRampRateChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr);
  /**
   * Set a callback to be run when the IsRamping state variable changes.
   *
   * Callbacks may be run in different threads but callbacks for a
   * CpProxyUpnpOrgDimming1 instance will not overlap.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback The callback to run when the state variable changes
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1SetPropertyIsRampingChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr);
  /**
   * Set a callback to be run when the RampPaused state variable changes.
   *
   * Callbacks may be run in different threads but callbacks for a
   * CpProxyUpnpOrgDimming1 instance will not overlap.
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[in]  aCallback The callback to run when the state variable changes
   * @param[in]  aPtr      Data to be passed to the callback
   */
  DllExport void STDCALL CpProxyUpnpOrgDimming1SetPropertyRampPausedChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr);
  
  /**
   * Query the value of the LoadLevelStatus property.
   *
   * This function is threadsafe and can only be called after the first callback
   * following a call to CpProxyCSubscribe() and before CpProxyCUnsubscribe().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aLoadLevelStatus
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1PropertyLoadLevelStatus(THandle aHandle, uint32_t* aLoadLevelStatus);
  /**
   * Query the value of the StepDelta property.
   *
   * This function is threadsafe and can only be called after the first callback
   * following a call to CpProxyCSubscribe() and before CpProxyCUnsubscribe().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aStepDelta
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1PropertyStepDelta(THandle aHandle, uint32_t* aStepDelta);
  /**
   * Query the value of the RampRate property.
   *
   * This function is threadsafe and can only be called after the first callback
   * following a call to CpProxyCSubscribe() and before CpProxyCUnsubscribe().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aRampRate
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1PropertyRampRate(THandle aHandle, uint32_t* aRampRate);
  /**
   * Query the value of the IsRamping property.
   *
   * This function is threadsafe and can only be called after the first callback
   * following a call to CpProxyCSubscribe() and before CpProxyCUnsubscribe().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aIsRamping
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1PropertyIsRamping(THandle aHandle, uint32_t* aIsRamping);
  /**
   * Query the value of the RampPaused property.
   *
   * This function is threadsafe and can only be called after the first callback
   * following a call to CpProxyCSubscribe() and before CpProxyCUnsubscribe().
   *
   * @param[in]  aHandle   Handle returned by CpProxyUpnpOrgDimming1Create
   * @param[out] aRampPaused
   * @return  0 if the function succeeded; non-zero if it failed.  State of output
   *          arguments is not guaranteed in the case of failure
   */
  DllExport int32_t STDCALL CpProxyUpnpOrgDimming1PropertyRampPaused(THandle aHandle, uint32_t* aRampPaused);
  
  /* @} */
  
  #ifdef __cplusplus
  } // extern "C"
  #endif
  
  #endif // HEADER_UPNPORGDIMMING1_C
  
  