text: /**
   * Proxy for av.openhome.org:Pins:1
   */
  #ifndef HEADER_AVOPENHOMEORGPINS1_C
  #define HEADER_AVOPENHOMEORGPINS1_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 CpProxyAvOpenhomeOrgPins1
   * @ingroup Proxies
   * @{
   */
  
  /**
   * Constructor.
   * Creates an instance of CpProxyAvOpenhomeOrgPins1 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 CpProxyAvOpenhomeOrgPins1Create(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 CpProxyAvOpenhomeOrgPins1Create
   */
  DllExport void STDCALL CpProxyAvOpenhomeOrgPins1Destroy(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 CpProxyAvOpenhomeOrgPins1Create
   * @param[out] aDeviceMax
   * @param[out] aAccountMax
   *
   * @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 CpProxyAvOpenhomeOrgPins1SyncGetDeviceAccountMax(THandle aHandle, uint32_t* aDeviceMax, uint32_t* aAccountMax);
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1BeginGetDeviceAccountMax(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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aDeviceMax
   * @param[out] aAccountMax
   *
   * @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 CpProxyAvOpenhomeOrgPins1EndGetDeviceAccountMax(THandle aHandle, OhNetHandleAsync aAsync, uint32_t* aDeviceMax, uint32_t* aAccountMax);
  
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[out] aModes
   *
   * @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 CpProxyAvOpenhomeOrgPins1SyncGetModes(THandle aHandle, char** aModes);
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1BeginGetModes(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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aModes
   *
   * @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 CpProxyAvOpenhomeOrgPins1EndGetModes(THandle aHandle, OhNetHandleAsync aAsync, char** aModes);
  
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[out] aIdArray
   *
   * @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 CpProxyAvOpenhomeOrgPins1SyncGetIdArray(THandle aHandle, char** aIdArray);
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1BeginGetIdArray(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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aIdArray
   *
   * @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 CpProxyAvOpenhomeOrgPins1EndGetIdArray(THandle aHandle, OhNetHandleAsync aAsync, char** aIdArray);
  
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aIds
   * @param[out] aList
   *
   * @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 CpProxyAvOpenhomeOrgPins1SyncReadList(THandle aHandle, const char* aIds, char** aList);
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aIds
   * @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 CpProxyAvOpenhomeOrgPins1BeginReadList(THandle aHandle, const char* aIds, 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aAsync    Argument passed to the callback set in the above Begin function
   * @param[out] aList
   *
   * @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 CpProxyAvOpenhomeOrgPins1EndReadList(THandle aHandle, OhNetHandleAsync aAsync, char** aList);
  
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aId
   *
   * @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 CpProxyAvOpenhomeOrgPins1SyncInvokeId(THandle aHandle, uint32_t aId);
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aId
   * @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 CpProxyAvOpenhomeOrgPins1BeginInvokeId(THandle aHandle, uint32_t aId, 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 CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1EndInvokeId(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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aIndex
   *
   * @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 CpProxyAvOpenhomeOrgPins1SyncInvokeIndex(THandle aHandle, uint32_t aIndex);
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aIndex
   * @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 CpProxyAvOpenhomeOrgPins1BeginInvokeIndex(THandle aHandle, uint32_t aIndex, 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 CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1EndInvokeIndex(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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aIndex
   * @param[in]  aMode
   * @param[in]  aType
   * @param[in]  aUri
   * @param[in]  aTitle
   * @param[in]  aDescription
   * @param[in]  aArtworkUri
   * @param[in]  aShuffle
   *
   * @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 CpProxyAvOpenhomeOrgPins1SyncSetDevice(THandle aHandle, uint32_t aIndex, const char* aMode, const char* aType, const char* aUri, const char* aTitle, const char* aDescription, const char* aArtworkUri, uint32_t aShuffle);
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aIndex
   * @param[in]  aMode
   * @param[in]  aType
   * @param[in]  aUri
   * @param[in]  aTitle
   * @param[in]  aDescription
   * @param[in]  aArtworkUri
   * @param[in]  aShuffle
   * @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 CpProxyAvOpenhomeOrgPins1BeginSetDevice(THandle aHandle, uint32_t aIndex, const char* aMode, const char* aType, const char* aUri, const char* aTitle, const char* aDescription, const char* aArtworkUri, uint32_t aShuffle, 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 CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1EndSetDevice(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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aIndex
   * @param[in]  aMode
   * @param[in]  aType
   * @param[in]  aUri
   * @param[in]  aTitle
   * @param[in]  aDescription
   * @param[in]  aArtworkUri
   * @param[in]  aShuffle
   *
   * @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 CpProxyAvOpenhomeOrgPins1SyncSetAccount(THandle aHandle, uint32_t aIndex, const char* aMode, const char* aType, const char* aUri, const char* aTitle, const char* aDescription, const char* aArtworkUri, uint32_t aShuffle);
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aIndex
   * @param[in]  aMode
   * @param[in]  aType
   * @param[in]  aUri
   * @param[in]  aTitle
   * @param[in]  aDescription
   * @param[in]  aArtworkUri
   * @param[in]  aShuffle
   * @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 CpProxyAvOpenhomeOrgPins1BeginSetAccount(THandle aHandle, uint32_t aIndex, const char* aMode, const char* aType, const char* aUri, const char* aTitle, const char* aDescription, const char* aArtworkUri, uint32_t aShuffle, 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 CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1EndSetAccount(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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aId
   *
   * @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 CpProxyAvOpenhomeOrgPins1SyncClear(THandle aHandle, uint32_t aId);
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aId
   * @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 CpProxyAvOpenhomeOrgPins1BeginClear(THandle aHandle, uint32_t aId, 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 CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1EndClear(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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aIndex1
   * @param[in]  aIndex2
   *
   * @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 CpProxyAvOpenhomeOrgPins1SyncSwap(THandle aHandle, uint32_t aIndex1, uint32_t aIndex2);
  /**
   * 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[in]  aIndex1
   * @param[in]  aIndex2
   * @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 CpProxyAvOpenhomeOrgPins1BeginSwap(THandle aHandle, uint32_t aIndex1, uint32_t aIndex2, 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 CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1EndSwap(THandle aHandle, OhNetHandleAsync aAsync);
  /**
   * Set a callback to be run when the DeviceMax state variable changes.
   *
   * Callbacks may be run in different threads but callbacks for a
   * CpProxyAvOpenhomeOrgPins1 instance will not overlap.
   *
   * @param[in]  aHandle   Handle returned by CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1SetPropertyDeviceMaxChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr);
  /**
   * Set a callback to be run when the AccountMax state variable changes.
   *
   * Callbacks may be run in different threads but callbacks for a
   * CpProxyAvOpenhomeOrgPins1 instance will not overlap.
   *
   * @param[in]  aHandle   Handle returned by CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1SetPropertyAccountMaxChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr);
  /**
   * Set a callback to be run when the Modes state variable changes.
   *
   * Callbacks may be run in different threads but callbacks for a
   * CpProxyAvOpenhomeOrgPins1 instance will not overlap.
   *
   * @param[in]  aHandle   Handle returned by CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1SetPropertyModesChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr);
  /**
   * Set a callback to be run when the IdArray state variable changes.
   *
   * Callbacks may be run in different threads but callbacks for a
   * CpProxyAvOpenhomeOrgPins1 instance will not overlap.
   *
   * @param[in]  aHandle   Handle returned by CpProxyAvOpenhomeOrgPins1Create
   * @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 CpProxyAvOpenhomeOrgPins1SetPropertyIdArrayChanged(THandle aHandle, OhNetCallback aCallback, void* aPtr);
  
  /**
   * Query the value of the DeviceMax 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[out] aDeviceMax
   * @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 CpProxyAvOpenhomeOrgPins1PropertyDeviceMax(THandle aHandle, uint32_t* aDeviceMax);
  /**
   * Query the value of the AccountMax 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[out] aAccountMax
   * @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 CpProxyAvOpenhomeOrgPins1PropertyAccountMax(THandle aHandle, uint32_t* aAccountMax);
  /**
   * Query the value of the Modes 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[out] aModes
   * @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 CpProxyAvOpenhomeOrgPins1PropertyModes(THandle aHandle, char** aModes);
  /**
   * Query the value of the IdArray 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 CpProxyAvOpenhomeOrgPins1Create
   * @param[out] aIdArray
   * @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 CpProxyAvOpenhomeOrgPins1PropertyIdArray(THandle aHandle, char** aIdArray);
  
  /* @} */
  
  #ifdef __cplusplus
  } // extern "C"
  #endif
  
  #endif // HEADER_AVOPENHOMEORGPINS1_C
  
  