windows-server-2003/public/sdk/inc/cluscfgserver.idl

//////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2000-2002 Microsoft Corporation
//
//  Module Name:
//      ClusCfgServer.idl
//
//  Description:
//      This file is the IDL file for the IClusCfgServer interface of the
//      Cluster Setup application.
//
//      The IClusCfgServer interface provides the functions required to gather
//      information about storage devices, networks, the operating
//      system, etc. on a computer. It also has functions to form a cluster
//      on this computer, to add this node to a cluster, to remove this node
//      from a cluster, etc.
//
//////////////////////////////////////////////////////////////////////////////


// Comments for generated files
cpp_quote( "//////////////////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// Copyright (c) 2000-2001 Microsoft Corporation" )
cpp_quote( "//" )
cpp_quote( "// Remarks:" )
cpp_quote( "//     Generated file. See file ClusCfgServer.idl for more details." )
cpp_quote( "//" )
cpp_quote( "//////////////////////////////////////////////////////////////////////////////" )


//////////////////////////////////////////////////////////////////////////////
// Imported Files
//////////////////////////////////////////////////////////////////////////////

// For IUnknown
import "unknwn.idl";


////////////////////////////////////////////////////////////////////////////
// Forward Declarations
//////////////////////////////////////////////////////////////////////////////

interface IClusCfgNodeInfo;
interface IEnumClusCfgManagedResources;
interface IClusCfgManagedResourceInfo;
interface IEnumClusCfgNetworks;
interface IEnumClusCfgPartitions;
interface IClusCfgPartitionInfo;
interface IEnumClusCfgIPAddresses;
interface IClusCfgIPAddressInfo;
interface IClusCfgNetworkInfo;
interface IClusCfgClusterInfo;
interface IClusCfgInitialize;
interface IClusCfgCallback;
interface IClusCfgCredentials;
interface IClusCfgCapabilities;

interface IClusCfgManagedResourceCfg;
interface IClusCfgResourcePreCreate;
interface IClusCfgResourceCreate;
interface IClusCfgResourcePostCreate;
interface IClusCfgGroupCfg;
interface IClusCfgResourceTypeInfo;
interface IClusCfgResourceTypeCreate;
interface IClusCfgMemberSetChangeListener;
interface IClusCfgEvictCleanup;
interface IClusCfgManagedResourceData;
interface IClusCfgVerifyQuorum;

//////////////////////////////////////////////////////////////////////////////
// Type Definitions
//////////////////////////////////////////////////////////////////////////////

//
// This enumeration is used to indicate the differetnt usage
// states of a drive letter.
//
typedef enum
{
    dluUNKNOWN = 0,

    dluNO_ROOT_DIRECTORY,
    dluREMOVABLE_DISK,
    dluFIXED_DISK,
    dluNETWORK_DRIVE,
    dluCOMPACT_DISC,
    dluRAM_DISK,
    dluSYSTEM,
    dluUNUSED,

    //
    //  Disks that are on a system bus will have a usage enum that starts from here.
    //

    dluSTART_OF_SYSTEM_BUS = 50,

    dluNO_ROOT_DIRECTORY_SYSTEM_BUS,
    dluREMOVABLE_DISK_SYSTEM_BUS,
    dluFIXED_DISK_SYSTEM_BUS,
    dluNETWORK_DRIVE_SYSTEM_BUS,
    dluCOMPACT_DISC_SYSTEM_BUS,
    dluRAM_DISK_SYSTEM_BUS,
    dluSYSTEM_SYSTEM_BUS,
    dluUNUSED_SYSTEM_BUS,

    dluMAX
} EDriveLetterUsage;

typedef struct _DRIVELETTERMAPPING
{
    EDriveLetterUsage dluDrives[ 26 ];
} SDriveLetterMapping;

//
// This enumeration is used to indicate the mode of the ClusCfgServer commit operation.
//
typedef enum
{
    cmUNKNOWN = 0,
    cmCREATE_CLUSTER,
    cmADD_NODE_TO_CLUSTER,
    cmCLEANUP_NODE_AFTER_EVICT,
    cmMAX
} ECommitMode;

typedef
[
    uuid( FFCF84AD-5892-4f4c-8C22-ACE041D6ACC2 ),
    helpstring( "The reason that Cleanup was called." )
]
enum EClusCfgCleanupReason {
    [ helpstring( "The operation completed successfully" ) ]                    crSUCCESS   = 0,
    [ helpstring( "The operation was cancelled" ) ]                             crCANCELLED = 1,
    [ helpstring( "The operation encountered an error and was terminated" ) ]   crERROR     = 2
} EClusCfgCleanupReason;

typedef
[
    uuid( 1DAF9692-6662-43b1-AD45-D50F7849B0CD ),
    helpstring( "Resource dependency flags" )
]
enum EDependencyFlags
{
    [ helpstring( "Unknown access" ) ]              dfUNKNOWN   = 0,
    [ helpstring( "Shared access resource" ) ]      dfSHARED    = 1,
    [ helpstring( "Exclusive access resource" ) ]   dfEXCLUSIVE = 2
} EDependencyFlags;

//////////////////////////////////////////////////////////////////////////////
// Constant Definitions
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// Interface Definitions
//////////////////////////////////////////////////////////////////////////////


//****************************************************************************
//++
//
//  interface IClusCfgNodeInfo
//
//  Description:
//      This interface contains information about the node configuration.
//
//--
//****************************************************************************
[
    object,
    uuid( E4B5FA15-DD07-439e-A623-8823524E3D19 ),
    async_uuid( 4F3BB40B-DF27-40a0-B31A-BA18324CEB9D ),
    pointer_default( unique )
]
interface IClusCfgNodeInfo : IUnknown
{
    //
    //  Name
    //

    //////////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetName(
    //      [ out ] BSTR * pbstrNameOut
    //      )
    //
    //  Description:
    //      Retrieves the node's fully qualified domain name. e.g.
    //      cluster1.ntdev.microsoft.com.
    //
    //  Parameter:
    //      pbstrNameOut
    //          Pointer to the name of the node. This should be freed by the caller
    //          by calling SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////////
    HRESULT
        GetName( [ out ] BSTR * pbstrNameOut );

    //////////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetName(
    //      [ in ] LPCWSTR pcszNameIn
    //      )
    //
    //  Description:
    //      Stores the new name for the node. This does not take effect until after
    //      the changes have been commited. This is stubbed out for future
    //      functionality.
    //
    //  Parameter:
    //      pcszNameIn
    //          The new name for the node.
    //
    //  Return Values:
    //      E_NOTIMPL
    //          The call is not implemented.
    //
    //////////////////////////////////////////////////////////////////////////////
    HRESULT
        SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );

    //
    // Membership?
    //

    //////////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IsMemberOfCluster( void )
    //
    //  Description:
    //      Call this to determine if the node is part of a cluster.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded and the result is "TRUE."
    //
    //      S_FALSE
    //          Call succeeded and the result is "FALSE."
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////////
    HRESULT
        IsMemberOfCluster( void );

    //////////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetClusterConfigInfo(
    //      [ out ] IClusCfgClusterInfo ** ppClusCfgClusterInfoOut
    //      )
    //
    //  Description:
    //      If it is a member, use this method to obtain an interface to
    //      IClusCfgClusterInfo.
    //
    //  Parameter:
    //      ppClusCfgClusterInfoOut
    //          Pointer to the IClusCfgClusterInfo interface.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////////
    HRESULT
        GetClusterConfigInfo( [ out ] IClusCfgClusterInfo ** ppClusCfgClusterInfoOut );

    //////////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetOSVersion(
    //      [ out ] DWORD * pdwMajorVersionOut,
    //      [ out ] DWORD * pdwMinorVersionOut,
    //      [ out ] WORD *  pwSuiteMaskOut,
    //      [ out ] BYTE *  pbProductTypeOut,
    //      [ out ] BSTR *  pbstrCSDVersionOut
    //      )
    //
    //////////////////////////////////////////////////////////////////////////////
    HRESULT
        GetOSVersion(
            [ out ] DWORD * pdwMajorVersionOut,
            [ out ] DWORD * pdwMinorVersionOut,
            [ out ] WORD *  pwSuiteMaskOut,
            [ out ] BYTE *  pbProductTypeOut,
            [ out ] BSTR *  pbstrCSDVersionOut
            );

    //////////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetClusterVersion(
    //      [ out ] DWORD * pdwNodeHighestVersion,
    //      [ out ] DWORD * pdwNodeLowestVersion
    //      )
    //
    //  Description:
    //      Retrieves the version of the cluster.
    //
    //  Parameters:
    //      pdwNodeHighestVersion
    //          The highest version in the cluster.
    //
    //      pdwNodeLowestVersion
    //          The lowest version in the cluster.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////////
    HRESULT
        GetClusterVersion(
            [ out ] DWORD * pdwNodeHighestVersion,
            [ out ] DWORD * pdwNodeLowestVersion
            );

    //////////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetDriveLetterMappings(
    //      [ out ] SDriveLetterMapping dlmDriveLetterUsageOut
    //      )
    //
    //  Description:
    //      Retrieves the drive letter mappings on the node.
    //
    //  Parameter:
    //      rgDriveLetterUsage
    //          An array of flags representing A: thru Z: (26) drive mappings to
    //          the drives. See SDriveLetterMapping for flag values.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetDriveLetterMappings( [ out ] SDriveLetterMapping * pdlmDriveLetterUsageOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetMaxNodeCount(
    //      [ out ] DWORD * pcMaxNodesOut
    //      )
    //
    //  Description:
    //      Returns the maximun number of nodes for this node's product
    //      suite type.
    //
    //  Notes:
    //
    //  Parameter:
    //      pcMaxNodesOut
    //          The maximum number of nodes allowed by this node's product
    //          suite type.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetMaxNodeCount(
            [ out ] DWORD * pcMaxNodesOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetProcessorInfo(
    //        [ out ] WORD *    pwProcessorArchitectureOut
    //      , [ out ] WORD *    pwProcessorLevelOut
    //      )
    //
    //  Description:
    //      Returns the processor information for this node.
    //
    //  Notes:
    //
    //  Parameter:
    //      pwProcessorArchitectureOut
    //          The processor architecture.
    //
    //      pwProcessorLevelOut
    //          The processor level.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //  Remarks:
    //      See SYSTEM_INFO in MSDN and/or the Platform SDK for more
    //      information.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetProcessorInfo(
              [ out ] WORD *    pwProcessorArchitectureOut
            , [ out ] WORD *    pwProcessorLevelOut
            );

}; //*** interface IClusCfgNodeInfo


//****************************************************************************
//++
//
//  interface IEnumClusCfgManagedResources
//
//  Description:
//      This interface enumerates all resources on this computer that the
//      cluster service can manage.
//
//--
//****************************************************************************
[
    object,
    uuid( 7DBE11EB-A5DF-4534-ABF6-8BAC7B53FC95 ),
    async_uuid( B138483F-9695-4fa6-A98F-0DE2FB355449 ),
    pointer_default( unique )
]
interface IEnumClusCfgManagedResources : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Next(
    //      [ in ]                                                                 ULONG                            cNumberRequestedIn,
    //      [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgManagedResourceInfo **   rgpManagedResourceInfoOut,
    //      [ out ]                                                                ULONG *                          pcNumberFetchedOut
    //      );
    //
    //  Description:
    //      Retrieves the next cNumberRequestedIn items in the enumeration sequence.
    //      If there are fewer than the requested number of elements left in the
    //      sequence, it retrieves the remaining elements. The number of elements
    //      actually retrieved is returned through pcNumberFetchedOut (unless the
    //      caller passed in NULL for that parameter).
    //
    //  Parameters:
    //      cNumberRequestedIn
    //          number of elements being requested.
    //
    //      rgpManagedResourceInfoOut
    //          Array of size cNumberRequestedIn (or larger) of the elements of interest.
    //          The type of this parameter depends on the item being enumerated.
    //
    //      pcNumberFetchedOut
    //          Pointer to the number of elements actually supplied in
    //          rgpManagedResourceInfoOut. Caller can pass in NULL if cNumberRequestedIn
    //          is one.
    //
    //  Return Values:
    //      S_OK
    //          The number of elements supplied is cNumberRequestedIn
    //
    //      S_FALSE
    //          The number of elements supplied is not cNumberRequestedIn
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Next(
            [ in ]                                                                 ULONG                            cNumberRequestedIn,
            [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgManagedResourceInfo **   rgpManagedResourceInfoOut,
            [ out ]                                                                ULONG *                          pcNumberFetchedOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Reset( void );
    //
    //  Description:
    //      Reset the enumeration sequence to the beginning.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Reset( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Skip(
    //      [ in ] ULONG cNumberToSkip
    //      );
    //
    //  Description:
    //      Skips over the next specified number of elements in the enumeration sequence.
    //
    //  Parameter:
    //      cNumberToSkip
    //          The number of elements to be skipped.
    //
    //  Return Value:
    //      S_OK
    //          The number of elements skipped is cNumberToSkip.
    //
    //      S_FALSE
    //          Success, but you're past the last element.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Skip( [ in ] ULONG cNumberToSkip );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Clone(
    //      [ out ] IEnumClusCfgManagedResources ** ppEnumManagedResources
    //      );
    //
    //  Description:
    //      Creates another enumerator that contains the same enumeration state
    //      as the current one. Using this function, a client can record a
    //      particular point in the enumeration sequence, and then return to
    //      that point at a later time. The new enumerator supports the same
    //      interface as the original one.
    //
    //  Return Values:
    //      E_INVALIDARG
    //          ppEnumManagedResources is invalid.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      E_UNEXPECTED
    //          Unknown error (it's in the EnumXXXX docs).
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Clone( [ out ] IEnumClusCfgManagedResources ** ppEnumManagedResourcesOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Count(
    //      [ out, ref ] DWORD * pnCountOut
    //      );
    //
    //  Description:
    //      Returns the size (possibly zero) of the enumerator's collection.
    //
    //  Return Values:
    //      E_POINTER
    //          pnCountOut was null.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Count( [ out, ref ] DWORD * pnCountOut );

}; //*** interface IEnumClusCfgManagedResources


//****************************************************************************
//++
//
//  interface IEnumClusCfgNetworks
//
//  Description:
//      This interface enumerates the networks on this computer.
//
//--
//****************************************************************************
[
    object,
    uuid( CF3FAED8-1322-4bcb-9923-B5B745A69E36 ),
    async_uuid( F56B9B0D-E7B8-49ec-A843-5475076B947D ),
    pointer_default( unique )
]
interface IEnumClusCfgNetworks : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Next(
    //      [ in ]                                                                 ULONG                    cNumberRequestedIn,
    //      [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgNetworkInfo **   rgpNetworkInfoOut,
    //      [ out ]                                                                ULONG *                  pcNumberFetchedOut
    //      );
    //
    //  Description:
    //      Retrieves the next cNumberRequestedIn items in the enumeration sequence.
    //      If there are fewer than the requested number of elements left in the
    //      sequence, it retrieves the remaining elements. The number of elements
    //      actually retrieved is returned through pcNumberFetchedOut (unless the
    //      caller passed in NULL for that parameter).
    //
    //  Parameters:
    //      cNumberRequestedIn
    //          number of elements being requested.
    //
    //      rgpNetworkInfoOut
    //          Array of size cNumberRequestedIn (or larger) of the elements of interest.
    //          The type of this parameter depends on the item being enumerated.
    //
    //      pcNumberFetchedOut
    //          Pointer to the number of elements actually supplied in
    //          rgpNetworkInfoOut. Caller can pass in NULL if cNumberRequestedIn
    //          is one.
    //
    //  Return Values:
    //      S_OK
    //          The number of elements supplied is cNumberRequestedIn
    //
    //      S_FALSE
    //          The number of elements supplied is not cNumberRequestedIn.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Next(
            [ in ]                                                                  ULONG                   cNumberRequestedIn,
            [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ]  IClusCfgNetworkInfo **  rgpNetworkInfoOut,
            [ out ]                                                                 ULONG *                 pcNumberFetchedOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Skip(
    //      [ in ] ULONG cNumberToSkip
    //      );
    //
    //  Description:
    //      Skips over the next specified number of elements in the enumeration sequence.
    //
    //  Parameter:
    //      cNumberToSkip
    //          The number of elements to be skipped.
    //
    //  Return Value:
    //      S_OK
    //          The number of elements skipped is cNumberToSkip.
    //
    //      S_FALSE
    //          Success, but you've past the last element.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Skip( [ in ] ULONG cNumberToSkipIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Reset( void );
    //
    //  Description:
    //      Reset the enumeration sequence to the beginning.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Reset( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Clone(
    //      [ out ] IEnumClusCfgNetworks ** ppEnumNetworksOut
    //      );
    //
    //  Description:
    //      Creates another enumerator that contains the same enumeration state
    //      as the current one. Using this function, a client can record a
    //      particular point in the enumeration sequence, and then return to
    //      that point at a later time. The new enumerator supports the same
    //      interface as the original one.
    //
    //  Parameter:
    //      ppEnumNetworksOut
    //          Address of IEnumClusCfgManagedResources * pointer variable that receives
    //          the interface pointer to the enumeration object. If the method is
    //          unsuccessful, the value of this output variable is undefined.
    //
    //  Return Values:
    //      E_INVALIDARG
    //          ppEnumNetworksOut is invalid.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      E_UNEXPECTED
    //          Unknown error (it's in the EnumXXXX docs).
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Clone( [ out ] IEnumClusCfgNetworks **  ppEnumNetworksOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Count(
    //      [ out, ref ] DWORD * pnCountOut
    //      );
    //
    //  Description:
    //      Returns the size (possibly zero) of the enumerator's collection.
    //
    //  Return Values:
    //      E_POINTER
    //          pnCountOut was null.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Count( [ out, ref ] DWORD * pnCountOut );

}; //*** interface IEnumClusCfgNetworks


//****************************************************************************
//++
//
//  interface IClusCfgManagedResourceInfo
//
//  Description:
//      This interface encapsulates a manageable resource on this computer.
//
//--
//****************************************************************************
[
    object,
    uuid( 8389D687-DF99-442b-81AB-58BA5B029688 ),
    async_uuid( 0560D153-892F-4bf5-87B0-06AF2803955C ),
    pointer_default( unique )
]
interface IClusCfgManagedResourceInfo : IUnknown
{
    //
    // UID
    //


    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetUID(
    //      [ out ] BSTR * pbstrUIDOut
    //      )
    //
    //  Description:
    //      Retrieve the Unique IDentifier for this resource. This is not a Universally
    //      Unique IDentifier (UUID or GUID). This indentifer should match identifiers
    //      that can be generated on other nodes that can see this resource from a shared
    //      bus (such as a SCSI disk).
    //
    //  Parameters:
    //      pbstrUIDOut
    //          Pointer to the UID string. pbstrUIDOut should be freed by the caller
    //          by calling SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetUID( [ out ] BSTR * pbstrUIDOut );

    //
    // Name
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetName(
    //      [ out ] BSTR * pbstrNameOut
    //      )
    //
    //  Description:
    //      Retrieves a "user friendly" name of the resource.
    //
    //  Parameter:
    //      pbstrNameOut
    //          Pointer to resource name. This should be freed by the caller by calling
    //          SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetName( [ out ] BSTR * pbstrNameOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetName(
    //      [ in ] LPCWSTR pcszNameIn
    //      )
    //
    //  Description:
    //      Stores a new name for the resource to be set when the cluster
    //      configuration is commited.
    //
    //  Parameter:
    //      pcszNameIn
    //          The name of the user wants to assigned the resource.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );

    //
    // Managed by cluster?
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IsManaged( void )
    //
    //  Description:
    //      Call this to determine if the resource is/will be managed by the cluster.
    //
    //      A managed device will always have a resource created for it in the
    //      cluster.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded and the result is "TRUE."
    //
    //      S_FALSE
    //          Call succeeded and the result is "FALSE."
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        IsManaged( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetManaged(
    //      [ in ] BOOL fIsManagedIn
    //      )
    //
    //  Description:
    //      Setting this flag will cause the resource to be configured as being managed
    //      by the cluster.
    //
    //  Parameter:
    //      fIsManagedIn
    //          If TRUE, the resource will be marked as being managed by the cluster.
    //
    //      Setting this to TRUE will cause a resource to be created for this device
    //      in the cluster.  Setting this to FALSE will prevent a resource for for
    //      this device from being created in the cluster.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetManaged( [ in ] BOOL fIsManagedIn );

    //
    // Quorum resource?
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IsQuorumResource( void )
    //
    //  Description:
    //      Call this to determine if the resource is/will be set as the quorum
    //      resource.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded and the result is "TRUE."
    //
    //      S_FALSE
    //          Call succeeded and the result is "FALSE."
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        IsQuorumResource( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetQuorumResource(
    //      [ in ] BOOL fIsQuorumResourceIn
    //      )
    //
    //  Description:
    //      Setting this flag will cause the resource to be configured as the
    //      quorum resource in the cluster.
    //
    //  Parameter:
    //      fIsQuorumResourceIn
    //          If TRUE, the resource will be marked to be the quorum resource.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      HRESULT_FROM_WIN32( ERROR_NOT_QUORUM_CAPABLE )
    //          You tried to set a resource to be the quorum when the resource
    //          is not capable of being a quorum resource.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetQuorumResource( [ in ] BOOL fIsQuorumResourceIn );

    //
    // Quorum Capable?
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IsQuorumCapable( void )
    //
    //  Description:
    //      Call this to determine if the resource is capable be set as the quorum
    //      resource.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded and the result is "TRUE."
    //
    //      S_FALSE
    //          Call succeeded and the result is "FALSE."
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        IsQuorumCapable( void );

    //
    // Set Quorum Capable
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetQuorumCapable(
    //      [ in ] BOOL fIsQuorumCapableIn
    //      )
    //
    //  Description:
    //      Call this to set whether the resource is capable to be the quorum
    //      resource or not.
    //
    //  Parameter:
    //      fSetQuorumCapableIn
    //          If TRUE, the resource will be marked as quorum capable.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded.
    //      E_NOTIMPL
    //          The call is not implemented.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetQuorumCapable( [ in ] BOOL fIsQuorumCapableIn );

    //
    // Drive Letter Mapping
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetDriveLetterMappings(
    //      [ out ] SDriveLetterMapping dlmDriveLetterMappingsOut
    //      )
    //
    //  Description:
    //      Retrieves the drive mappings for the resource (if any).
    //
    //  Parameter:
    //      rgDriveLetterMappings
    //          An array of flags representing A: thru Z: (26) drive mappings to
    //          the resource. See SDriveLetterMapping for flag values.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetDriveLetterMappings( [ out ] SDriveLetterMapping * pdlmDriveLetterMappingOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetDriveLetterMappings(
    //      [ in ] SDriveLetterMapping dlmDriveLetterMappingIn
    //      )
    //
    //  Description:
    //      Stores the drive mappings for the resource. The change will not take
    //      effect until the configuration has been committed.
    //
    //  Parameter:
    //      rgDriveLetterMappings
    //          An array of flags representing A: thru Z: (26) drive mappings to
    //          the resource. See EDriveLetterUsage for flag values.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetDriveLetterMappings( [ in ] SDriveLetterMapping dlmDriveLetterMappingIn );

    //
    // Manageable by the cluster?
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IsManagedByDefault( void )
    //
    //  Description:
    //      Call this to determine if the resource wants to be managed by default
    //      by the cluster.
    //
    //      When doing a full configuration all devices that are
    //      managed by default will be have resources created for them
    //      in the cluster and will therefore be managed by the cluster.
    //      When doing a minimum configuration resources will not be created
    //      for any devices that want to be managed by default by the cluster.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded and the result is "TRUE."
    //
    //      S_FALSE
    //          Call succeeded and the result is "FALSE."
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        IsManagedByDefault( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetManagedByDefault(
    //      [ in ] BOOL fIsManageableIn
    //      )
    //
    //  Description:
    //      Setting this flag will cause the resource to be managed by default
    //      by the cluster.
    //
    //  Parameter:
    //      fIsManagedByDefaultIn
    //          If TRUE, the resource will be marked as being managed by default
    //          by the cluster.
    //
    //      Setting this to TRUE will cause a cluster resource to be created for
    //      this device by default when doing a full configuration.  By
    //      setting this to FALSE the device will not have a resource created
    //      for it in the cluster by default.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetManagedByDefault( [ in ] BOOL fIsManagedByDefaultIn );

}; //*** interface IClusCfgManagedResourceInfo

//****************************************************************************
//++
//
//  interface IEnumClusCfgPartitions
//
//  Description:
//      This interface enumerates the partitions on a storage device that the
//      cluster service can manage.
//
//--
//****************************************************************************
[
    object,
    uuid( 4440BB6A-B0AC-479d-B534-7265A31D6C55 ),
    async_uuid( 4440BB6A-B0AC-479d-B534-7265A31D6C56 ),
    pointer_default( unique )
]
interface IEnumClusCfgPartitions : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Next(
    //      [ in ]                                                                 ULONG                    cNumberRequestedIn,
    //      [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgPartitionInfo ** rgpPartitionInfoOut,
    //      [ out ]                                                                ULONG *                  pcNumberFetchedOut
    //      );
    //
    //  Description:
    //      Retrieves the next cNumberRequestedIn items in the enumeration sequence.
    //      If there are fewer than the requested number of elements left in the
    //      sequence, it retrieves the remaining elements. The number of elements
    //      actually retrieved is returned through pcNumberFetchedOut (unless the
    //      caller passed in NULL for that parameter).
    //
    //  Parameters:
    //      cNumberRequestedIn
    //          number of elements being requested.
    //
    //      rgpPartitionInfoOut
    //          Array of size cNumberRequestedIn (or larger) of the elements of interest.
    //          The type of this parameter depends on the item being enumerated.
    //
    //      pcNumberFetchedOut
    //          Pointer to the number of elements actually supplied in
    //          rgpPartitionInfoOut. Caller can pass in NULL if cNumberRequestedIn
    //          is one.
    //
    //  Return Values:
    //      S_OK
    //          The number of elements supplied is cNumberRequestedIn
    //
    //      S_FALSE
    //          The number of elements supplied is not cNumberRequestedIn
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Next(
            [ in ]                                                                 ULONG                    cNumberRequestedIn,
            [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgPartitionInfo ** rgpPartitionInfoOut,
            [ out ]                                                                ULONG *                  pcNumberFetchedOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Reset( void );
    //
    //  Description:
    //      Reset the enumeration sequence to the beginning.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Reset( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Skip(
    //      [ in ] ULONG cNumberToSkip
    //      );
    //
    //  Description:
    //      Skips over the next specified number of elements in the enumeration sequence.
    //
    //  Parameter:
    //      cNumberToSkip
    //          The number of elements to be skipped.
    //
    //  Return Value:
    //      S_OK
    //          The number of elements skipped is cNumberToSkip.
    //
    //      S_FALSE
    //          Success, but you've past the last element.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Skip( [ in ] ULONG cNumberToSkip );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Clone(
    //      [ out ] IEnumClusCfgPartitions ** ppEnumPartitions
    //      );
    //
    //  Description:
    //      Creates another enumerator that contains the same enumeration state
    //      as the current one. Using this function, a client can record a
    //      particular point in the enumeration sequence, and then return to
    //      that point at a later time. The new enumerator supports the same
    //      interface as the original one.
    //
    //  Return Values:
    //      E_INVALIDARG
    //          ppEnumPartitions is invalid.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      E_UNEXPECTED
    //          Unknown error (it's in the EnumXXXX docs).
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Clone( [ out ] IEnumClusCfgPartitions ** ppEnumPartitions );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Count(
    //      [ out, ref ] DWORD * pnCountOut
    //      );
    //
    //  Description:
    //      Returns the size (possibly zero) of the enumerator's collection.
    //
    //  Return Values:
    //      E_POINTER
    //          pnCountOut was null.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Count( [ out, ref ] DWORD * pnCountOut );

}; //*** interface IEnumClusCfgPartitions


//****************************************************************************
//++
//
//  interface IClusCfgPartitionInfo
//
//  Description:
//      This interface provides the partition info.
//
//--
//****************************************************************************
[
    object,
    uuid( EC1EBD9F-5866-4846-8952-EC36C3961EEE ),
    async_uuid( EC1EBD9F-5866-4846-8952-EC36C3961EEF ),
    pointer_default( unique )
]
interface IClusCfgPartitionInfo : IUnknown
{
    //
    // UID
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetUID(
    //      [ out ] BSTR * pbstrUIDOut
    //      )
    //
    //  Description:
    //      Retrieve the "Unique IDentifier" for this partition. This is not a Universally
    //      Unique IDentifier (UUID or GUID). This indentifer should match identifiers
    //      that can be generated on other nodes, but must be unique for the partition
    //      the interface (NIC) is on.
    //
    //  Parameters:
    //      pbstrUIDOut
    //          Pointer to the UID string. pbstrUIDOut should be freed by the caller
    //          by calling SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetUID( [ out ] BSTR * pbstrUIDOut );

    //
    // Name
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetName(
    //      [ out ] BSTR * pbstrNameOut
    //      )
    //
    //  Description:
    //      Retrieves a "user friendly" name of the interface.
    //
    //  Parameter:
    //      pbstrNameOut
    //          Pointer to partition interface name. This should be freed by the caller
    //          by calling SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetName( [ out ] BSTR * pbstrNameOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetName(
    //      [ in ] LPCWSTR pcszNameIn
    //      )
    //
    //  Description:
    //      Stores a new name of the partition interface to be set when the cluster
    //      configuration is commited.
    //
    //  Parameter:
    //      pcszNameIn
    //          The name of the user wants to assigned the interface.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );

    //
    // Description
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetDescription(
    //      [ out ] BSTR * pbstrDescriptionOut
    //      )
    //
    //  Description:
    //      Retrieves the description string for a partition interface.
    //
    //  Parameter:
    //      pbstrDescription
    //          Pointer to the description of the partition. This should be freed
    //          by the caller by calling SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetDescription( [ out ] BSTR * pbstrDescriptionOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetDescription(
    //      [ in ] LPCWSTR pcszDescriptionIn
    //      )
    //
    //  Description:
    //      Stores a new name of the partition interface to be set when the cluster
    //      configuration is commited.
    //
    //  Parameter:
    //      pcszDescriptionIn
    //          The description the user wants to assign to the interface.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetDescription(
            [ in, pointer_default( unique ) ] LPCWSTR pcszDescriptionIn
            );

    //
    // Drive Letter Mapping
    //

    //////////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetDriveLetterMappings(
    //      [ out ] SDriveLetterMapping dlmDriveLetterUsageOut
    //      )
    //
    //  Description:
    //      Retrieves the drive letter mappings of the partition.
    //
    //  Parameter:
    //      rgDriveLetterUsage
    //          An array of flags representing A: thru Z: (26) drive mappings to
    //          the disk. See SDriveLetterMapping for flag values.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetDriveLetterMappings( [ out ] SDriveLetterMapping * pdlmDriveLetterUsageOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetDriveLetterMappings(
    //      [ in ] SDriveLetterMapping dlmDriveLetterMappingIn
    //      )
    //
    //  Description:
    //      Stores the drive mappings for the disk. The change will not take
    //      effect until the configuration has been committed.
    //
    //  Parameter:
    //      rgDriveLetterMappings
    //          An array of flags representing A: thru Z: (26) drive mappings to
    //          the disk. See EDriveLetterUsage for flag values.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetDriveLetterMappings( [ in ] SDriveLetterMapping dlmDriveLetterMappingIn );

    //
    // Partition Size
    //

    //////////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetSize(
    //      [ out ] ULONG * pcMegaBytes
    //      )
    //
    //  Description:
    //      Retrieves the size of the partition in Megabytes.
    //
    //  Parameter:
    //      pcMegaBytes
    //          Retrieves the partition size.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetSize( [ out ] ULONG * pcMegaBytes );

}; //*** interface IClusCfgPartitionInfo


//****************************************************************************
//++
//
//  interface IEnumClusCfgIPAddresses
//
//  Description:
//      This interface enumerates the IP addresses on this adapter.
//
//--
//****************************************************************************
[
    object,
    uuid( BD5F35BA-0BC0-455f-926D-C3D356419486 ),
    async_uuid( BD5F35BA-0BC0-455f-926D-C3D356419487 ),
    pointer_default( unique )
]
interface IEnumClusCfgIPAddresses : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Next(
    //      [ in ]                                                                 ULONG                    cNumberRequestedIn,
    //      [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgIPAddressInfo ** rgpIPAddressInfoOut,
    //      [ out ]                                                                ULONG *                  pcNumberFetchedOut
    //      );
    //
    //  Description:
    //      Retrieves the next cNumberRequestedIn items in the enumeration sequence.
    //      If there are fewer than the requested number of elements left in the
    //      sequence, it retrieves the remaining elements. The number of elements
    //      actually retrieved is returned through pcNumberFetchedOut (unless the
    //      caller passed in NULL for that parameter).
    //
    //  Parameters:
    //      cNumberRequestedIn
    //          number of elements being requested.
    //
    //      rgpIPAddressInfoOut
    //          Array of size cNumberRequestedIn (or larger) of the elements of interest.
    //          The type of this parameter depends on the item being enumerated.
    //
    //      pcNumberFetchedOut
    //          Pointer to the number of elements actually supplied in
    //          rgpIPAddressInfoOut. Caller can pass in NULL if cNumberRequestedIn
    //          is one.
    //
    //  Return Values:
    //      S_OK
    //          The number of elements supplied is cNumberRequestedIn
    //
    //      S_FALSE
    //          The number of elements supplied is not cNumberRequestedIn.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Next(
            [ in ]                                                                  ULONG                       cNumberRequestedIn,
            [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ]  IClusCfgIPAddressInfo **    rgpIPAddressInfoOut,
            [ out ]                                                                 ULONG *                     pcNumberFetchedOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Skip(
    //      [ in ] ULONG cNumberToSkip
    //      );
    //
    //  Description:
    //      Skips over the next specified number of elements in the enumeration sequence.
    //
    //  Parameter:
    //      cNumberToSkip
    //          The number of elements to be skipped.
    //
    //  Return Value:
    //      S_OK
    //          The number of elements skipped is cNumberToSkip.
    //
    //      S_FALSE
    //          Success, but you've past the last element.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Skip( [ in ] ULONG cNumberToSkipIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Reset( void );
    //
    //  Description:
    //      Reset the enumeration sequence to the beginning.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Reset( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Clone(
    //      [ out ] IEnumClusCfgIPAddresses ** ppEnumIPAddressesOut
    //      );
    //
    //  Description:
    //      Creates another enumerator that contains the same enumeration state
    //      as the current one. Using this function, a client can record a
    //      particular point in the enumeration sequence, and then return to
    //      that point at a later time. The new enumerator supports the same
    //      interface as the original one.
    //
    //  Parameter:
    //      ppEnumIPAddressesOut
    //          Address of IEnumClusCfgManagedResources * pointer variable that receives
    //          the interface pointer to the enumeration object. If the method is
    //          unsuccessful, the value of this output variable is undefined.
    //
    //  Return Values:
    //      E_INVALIDARG
    //          ppEnumIPAddressesOut is invalid.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      E_UNEXPECTED
    //          Unknown error (it's in the EnumXXXX docs).
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Clone( [ out ] IEnumClusCfgIPAddresses **  ppEnumIPAddressesOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Count(
    //      [ out, ref ] DWORD * pnCountOut
    //      );
    //
    //  Description:
    //      Returns the size (possibly zero) of the enumerator's collection.
    //
    //  Return Values:
    //      E_POINTER
    //          pnCountOut was null.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Count( [ out, ref ] DWORD * pnCountOut );

}; //*** interface IEnumClusCfgIPAddresses


//****************************************************************************
//++
//
//  interface IClusCfgIPAddressInfo
//
//  Description:
//      This interface encapsulates the info about an IP address.
//
//--
//****************************************************************************
[
    object,
    uuid( AAEAF0A5-E310-4604-A55E-2F9DDC4157A8 ),
    async_uuid( AAEAF0A5-E310-4604-A55E-2F9DDC4157A9 ),
    pointer_default( unique )
]
interface IClusCfgIPAddressInfo : IUnknown
{
    //
    // UID
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetUID(
    //      [ out ] BSTR * pbstrUIDOut
    //      )
    //
    //  Description:
    //      Retrieve the "Unique IDentifier" for this IP address. This is not a Universally
    //      Unique IDentifier (UUID or GUID). This indentifer should match identifiers
    //      that can be generated on other nodes, but must be unique for the network
    //      the interface (NIC) is on.
    //
    //  Parameters:
    //      pbstrUIDOut
    //          Pointer to the UID string. pbstrUIDOut should be freed by the caller
    //          by calling SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetUID( [ out ] BSTR * pbstrUIDOut );

    //
    // IP Address
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetIPAddress(
    //      [ out ] ULONG * pulDottedQuadOut
    //      )
    //
    //  Description:
    //      Retrieves an IP Address for the network inteface.
    //
    //  Paramater:
    //      pulDottedQuadOut
    //          The IP address of the interface in dotted quad format.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetIPAddress( [ out ] ULONG * pulDottedQuadOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetIPAddress(
    //      [ in ] ULONG ulDottedQuadIn
    //      )
    //
    //  Description:
    //      Stores an IP Address of the network interface to be set when the cluster
    //      configuration is committed.
    //
    //  Parameter:
    //      ulDottedQuadIn
    //          The IP address of the interface to be stored in dotted quad format.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetIPAddress( [ in ] ULONG ulDottedQuadIn );

    //
    // Subnet Mask
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetSubnetMask(
    //      [ out ] ULONG * pulDottedQuadOut
    //      )
    //
    //  Description:
    //      Retrieves a subnet mask for the network interface.
    //
    //  Parameter:
    //      ulDottedQuadOut
    //          The subnet mask of the interface in dotted quad format.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetSubnetMask( [ out ] ULONG * pulDottedQuadOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetSubnetMask(
    //      [ in ] ULONG ulDottedQuadIn
    //      )
    //
    //  Description:
    //      Stores a subnet mask for the network interface to be set when the cluster
    //      configuration is committed.
    //
    //  Parameter:
    //      ulDottedQuadIn
    //          The subnet mask of the interface to be stored in dotted quad format.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetSubnetMask( [ in ] ULONG ulDottedQuadIn );

}; //*** interface IClusCfgIPAddressInfo


//****************************************************************************
//++
//
//  interface IClusCfgNetworkInfo
//
//  Description:
//      This interface enumerates the networks on this computer.
//
//--
//****************************************************************************
[
    object,
    uuid( 19FC7580-950A-44a6-966E-74B14B20918F ),
    async_uuid( ED71FD2D-AD02-4dfc-B376-5FFA5F5A7C2C ),
    pointer_default( unique )
]
interface IClusCfgNetworkInfo : IUnknown
{
    //
    // UID
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetUID(
    //      [ out ] BSTR * pbstrUIDOut
    //      )
    //
    //  Description:
    //      Retrieve the "Unique IDentifier" for this network. This is not a Universally
    //      Unique IDentifier (UUID or GUID). This indentifer should match identifiers
    //      that can be generated on other nodes, but must be unique for the network
    //      the interface (NIC) is on.
    //
    //  Parameters:
    //      pbstrUIDOut
    //          Pointer to the UID string. pbstrUIDOut should be freed by the caller
    //          by calling SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetUID( [ out ] BSTR * pbstrUIDOut );

    //
    // Name
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetName(
    //      [ out ] BSTR * pbstrNameOut
    //      )
    //
    //  Description:
    //      Retrieves a "user friendly" name of the interface.
    //
    //  Parameter:
    //      pbstrNameOut
    //          Pointer to network interface name. This should be freed by the caller
    //          by calling SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetName( [ out ] BSTR * pbstrNameOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetName(
    //      [ in ] LPCWSTR pcszNameIn
    //      )
    //
    //  Description:
    //      Stores a new name of the network interface to be set when the cluster
    //      configuration is commited.
    //
    //  Parameter:
    //      pcszNameIn
    //          The name of the user wants to assigned the interface.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );

    //
    // Description
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetDescription(
    //      [ out ] BSTR * pbstrDescriptionOut
    //      )
    //
    //  Description:
    //      Retrieves the description string for a network interface.
    //
    //  Parameter:
    //      pbstrDescription
    //          Pointer to the description of the network. This should be freed
    //          by the caller by calling SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetDescription( [ out ] BSTR * pbstrDescriptionOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetDescription(
    //      [ in ] LPCWSTR pcszDescriptionIn
    //      )
    //
    //  Description:
    //      Stores a new name of the network interface to be set when the cluster
    //      configuration is commited.
    //
    //  Parameter:
    //      pcszDescriptionIn
    //          The description the user wants to assign to the interface.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetDescription(
            [ in, pointer_default( unique ) ] LPCWSTR pcszDescriptionIn
            );

    //
    // Network Address
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetPrimaryNetworkAddress(
    //      [ out ] IClusCfgIPAddressInfo ** ppIPAddressOut
    //      )
    //
    //  Description:
    //      Get the primary network address.
    //
    //  Parameter:
    //      ppIPAddressOut
    //          Pointer to the IClusCfgIPAddressInfo interface.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetPrimaryNetworkAddress( [ out ] IClusCfgIPAddressInfo ** ppIPAddressOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetPrimaryNetworkAddress(
    //      [ in ] IClusCfgIPAddressInfo * pIPAddressIn
    //      )
    //
    //  Description:
    //      Set the primary network address.
    //
    //  Parameter:
    //      pIPAddressIn
    //          Pointer to the IClusCfgIPAddressInfo interface.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPrimaryNetworkAddress( [ in ] IClusCfgIPAddressInfo * pIPAddressIn );

    //
    // Public?
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IsPublic( void )
    //
    //  Description:
    //      Call this to determine if the network has been configured to be a
    //      public network. Note that an interface can be both public and private.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded and the result is "TRUE."
    //
    //      S_FALSE
    //          Call succeeded and the result is "FALSE."
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        IsPublic( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetPublic(
    //      [ in ] BOOL fIsPublicIn
    //      )
    //
    //  Description:
    //      Sets the "public property" of a network interface. The change will not
    //      take effect until the configuration has been committed.
    //
    //  Parameter:
    //      fIsPublicIn
    //          If TRUE, the interface will be marked to be a public interface.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPublic( [ in ] BOOL fIsPublicIn );

    //
    // Private?
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IsPrivate( void )
    //
    //  Description:
    //      Call this to determine if the network has been configured to be a
    //      private network. Note that an interface can be both public and private.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded and the result is "TRUE."
    //      S_FALSE
    //          Call succeeded and the result is "FALSE."
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        IsPrivate( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetPrivate(
    //      [ in ] BOOL fIsPrivateIn
    //      )
    //
    //  Description:
    //      Sets the "private property" of a network interface. The change will not
    //      take effect until the configuration has been committed.
    //
    //  Parameter:
    //      fIsPrivateIn
    //          Value to set the flag to. If TRUE the interface will be marked as
    //          a private interface. If FALSE the interface will be marked as NOT
    //          a private interface.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPrivate( [ in ] BOOL fIsPrivateIn );

}; //*** interface IClusCfgNetworkInfo


//****************************************************************************
//++
//
//  interface IClusCfgClusterInfo
//
//  Description:
//      This interface contains information about the cluster configuration.
//
//--
//****************************************************************************
[
    object,
    uuid( 85B4BBC0-DDC4-4ae7-8268-F4850BB2A6EE ),
    async_uuid( 8BDBA247-04F5-4114-837E-B263412A4B64 ),
    pointer_default( unique )
]
interface IClusCfgClusterInfo : IUnknown
{
    //
    // CommitChanges Mode
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetCommitMode(
    //      [ in ] ECommitMode ecmNewModeIn
    //      )
    //
    //  Description:
    //      Sets the CommitChanges processing to be the new mode that
    ///     is passed in.
    //
    //  Parameter:
    //      eccbNewModeIn
    //          The new mode to set the CommitChanges processing to.
    //
    //  Return Values:
    //      S_OK
    //          Call succeed.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCommitMode( [ in ] ECommitMode ecmNewModeIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetCommitMode(
    //      [ out ] ECommitMode * pecmCurrentModeOut
    //      )
    //
    //  Description:
    //      Call this to determine the operation that will be done when
    //      CommitChanges is invoked.
    //
    //  Parameter:
    //      pecmCurrentModeOut
    //          The current mode for CommitChanges processing.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetCommitMode( [ out ] ECommitMode * pecmCurrentModeOut );

    //
    //  Cluster Name
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetName(
    //      [ out ] BSTR * pbstrNameOut
    //      )
    //
    //  Description:
    //      Retrieves the name of the cluster to be formed or joined.
    //
    //  Notes:
    //      Name (Fully Qualified Domiain Name) e.g. cluster1.ntdev.microsoft.com
    //
    //      In Forming the cluster, this is the resulting cluster name.
    //      In Joining the cluster, this is the sponsers cluster name.
    //
    //  Parameter:
    //      pbstrNameOut
    //          Pointer to cluster name. This should be freed by the caller by calling
    //          SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetName( [ out ] BSTR * pbstrNameOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetName(
    //      [ in ] LPCWSTR pcszNameIn
    //      )
    //
    //  Description:
    //      Stores a new name for the cluster to be set when the cluster
    //      configuration is commited. If the node is joining, then this will
    ///     will be the cluster to be joined.
    //
    //  Notes:
    //      Name (Fully Qualified Domiain Name) e.g. cluster1.ntdev.microsoft.com
    //
    //      In Forming the cluster, this is the resulting cluster name.
    //      In Joining the cluster, this is the sponsers cluster name.
    //
    //  Parameter:
    //      pcszNameIn
    //          The name of the user wants to assign to the cluster.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );

    //
    // Cluster IP Address
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetIPAddress(
    //      [ out ] ULONG * pulDottedQuadOut
    //      )
    //
    //  Description:
    //      Retrieves the IP address of the cluster.
    //
    //  Parameter:
    //      pulDottedQuadOut
    //          The IP address of the cluster in dotted quad format.
    //
    //  Return Value:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetIPAddress( [ out ] ULONG * pulDottedQuadOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetIPAddress(
    //      [ in ] ULONG ulDottedQuadIn
    //      )
    //
    //  Description:
    //      Stores the IP address to be used to form the cluster. If joining,
    //      this is the IP address of the sponsor.
    //
    //  Parameter:
    //      ulDottedQuadIn
    //          IP address in dotted quad format.
    //
    //  Return Value:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetIPAddress( [ in ] ULONG ulDottedQuadIn );


    //
    // Cluster Subnet Mask
    //


    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetSubnetMask(
    //      [ out ] ULONG * pulDottedQuadOut
    //      )
    //
    //  Description:
    //      Retrieves the subnet mask to be used for the cluster.
    //
    //  Parameter:
    //      pulDottedQuadOut
    //          Subnet mask of the cluster in dotted quad format.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetSubnetMask( [ out ] ULONG * pulDottedQuadOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetSubnetMask(
    //      [ in ] ULONG ulDottedQuadIn
    //      )
    //
    //  Description:
    //      Stores the subnet mask to be used to form the cluster. If joining,
    //      this is the subnet mask of the sponsor.
    //
    //  Parameter:
    //      ulDottedQuadIn
    //          Subnet mask in dotted quad format.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetSubnetMask( [ in ] ULONG ulDottedQuadIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetNetworkInfo(
    //      [ out ] IClusCfgNetworkInfo ** ppiccniOut
    //      )
    //
    //  Description:
    //      Retrieves the network to be used for the cluster IP address
    //      and name.
    //
    //  Parameter:
    //      ppiccniOut
    //          Pointer of the network to use for the cluster IP address
    //          and name.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetNetworkInfo( [ out ] IClusCfgNetworkInfo ** ppiccniOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetNetworkInfo(
    //      [ in ] IClusCfgNetworkInfo * piccniIn
    //      )
    //
    //  Description:
    //      Stores the network to be used for the cluster IP address and name.
    //
    //  Parameter:
    //      piccniIn
    //          Pointer to the network to use for the cluster IP address
    //          and name.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetNetworkInfo( [ in ] IClusCfgNetworkInfo * piccniIn );

    //
    // Cluster Service Account
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetClusterServiceAccountCredentials(
    //      [ out ] IClusCfgCredentials ** ppicccCredentialsOut
    //      )
    //
    //  Description:
    //      Retrieves the cluster service account credentials used by the
    //      cluster for authenication. The password is not available from the
    //      sponsor node and must be supplied by the user. Once supplied, it can
    //      be retrieved by calling this method.
    //
    //  Parameters:
    //      ppicccCredentialsOut
    //          An IClusCfgCredentials * that contains the cluster
    //          service account credentials.
    //
    //  Return Values:
    //      S_OK
    //          The called succeeded.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetClusterServiceAccountCredentials(
            [ out ] IClusCfgCredentials ** ppicccCredentialsOut
            );

    //
    //  Cluster Binding String
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetBindingString(
    //      [ out ] BSTR * pbstrBindingStringOut
    //      )
    //
    //  Description:
    //      Retrieves the binding string (IP address) of the cluster to be
    //      formed or joined.
    //
    //  Notes:
    //
    //  Parameter:
    //      pbstrBindingStringOut
    //          Pointer to a BSTR. This should be freed by the caller by
    //          calling SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetBindingString( [ out ] BSTR * pbstrBindingStringOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetBindingString(
    //      [ in ] LPCWSTR pcszBindingStringIn
    //      )
    //
    //  Description:
    //      Stores the binding string for the cluster.
    //
    //  Notes:
    //
    //  Parameter:
    //      pcszBindingStringIn
    //          The binding string to use when connecting to this cluster.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetBindingString(
            [ in, pointer_default( unique ) ] LPCWSTR pcszBindingStringIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetMaxNodeCount(
    //      [ out ] DWORD * pcMaxNodesOut
    //      )
    //
    //  Description:
    //      Returns the maximun number of nodes supported in this cluster.
    //
    //  Notes:
    //
    //  Parameter:
    //      pcMaxNodesOut
    //          The maximum number of nodes allowed in this cluster.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetMaxNodeCount(
            [ out ] DWORD * pcMaxNodesOut
            );

}; //*** interface IClusCfgClusterInfo


//****************************************************************************
//++
//
//  interface IClusCfgInitialize
//
//  Description:
//      This interface is used to initialize a configuration object.
//
//--
//****************************************************************************
[
    object,
    uuid( 2A0EB82D-F878-492a-951E-AE000918C4A6 ),
    async_uuid( 2A0EB82E-F878-492a-951E-AE000918C4A6 ),
    pointer_default( unique )
]
interface IClusCfgInitialize : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Initialize(
    //      [ in ] IUnknown *   punkCallbackIn,
    //      [ in ] LCID         lcidIn
    //      )
    //
    //  Description:
    //      Register callbacks, locale id, etc.
    //
    //  Parameters:
    //      punkCallbackIn
    //          The callback interface.
    //
    //      lcidIn
    //          The locale ID to be used for strings that are passed.
    //
    //  Return Values:
    //      S_OK
    //          The initialization succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Initialize(
            [ in ] IUnknown *   punkCallbackIn,
            [ in ] LCID         lcidIn
            );

}; //*** interface IClusCfgInitialize


//****************************************************************************
//++
//
//  interface IClusCfgCallback
//
//  Description:
//      This interface is used to callback to the client to indicate
//      status or progess (or both) about a task being completed on the
//      server.
//
//--
//****************************************************************************
[
    object,
    uuid( 238DCA63-E2EF-4f32-A24D-ACBF975BE842 ),
    async_uuid( EBCE8945-AC69-4b3a-865D-E2D4EB33E41B ),
    pointer_default( unique )
]
interface IClusCfgCallback : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SendStatusReport(
    //      [ in ]  LPCWSTR     pcszNodeNameIn,
    //      [ in ]  CLSID       clsidTaskMajorIn
    //      [ in ]  CLSID       clsidTaskMinorIn,
    //      [ in ]  ULONG       ulMinIn,
    //      [ in ]  ULONG       ulMaxIn,
    //      [ in ]  ULONG       ulCurrentIn,
    //      [ in ]  HRESULT     hrStatusIn,
    //      [ in ]  LPCWSTR     pcszDescriptionIn,
    //      [ in ]  FILETIME *  pftTimeIn,
    //      [ in ]  LPCWSTR     pcszReferenceIn
    //      )
    //
    //  Description:
    //      Send a status report back to the user interface/script.
    //
    //  Parameters:
    //      pcszNodeNameIn
    //          The name of the node (server) that sent the report.
    //
    //      clsidTaskMajorIn
    //          CLSID of the major task item to give status about. For the
    //          wizard, this indicates which node in the tree view control
    //          to publish this status message under. If clsidTaskMajorIn
    //          equals TASKID_Major_Client_Log, TASKID_Major_Server_Log, or
    //          TASKID_Major_Client_And_Server_Log, only a log entry will be
    //          made.
    //
    //      clsidTaskMinorIn
    //          CLSID of the minor task to give status about. These should be
    //          unique to each sub-task and message.
    //
    //      ulMinIn
    //          The min value of progress.
    //
    //      ulMaxIn
    //          The max value of progress.
    //
    //      ulCurrentIn
    //          The current value of progress.
    //
    //      hrStatusIn
    //          The current status.
    //
    //      pcszDescriptionIn
    //          The description of the status. Can be NULL to indicate that nothing
    //          needs to be passed.
    //
    //      pftTimeIn
    //          UTC time of when this event was generated.
    //
    //      pcszReference
    //          Optional reference data, additional context, URL, etc. that
    //          might better help explain the problem is this is an error
    //          report.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SendStatusReport(
            [ in, pointer_default( unique )  ]  LPCWSTR     pcszNodeNameIn,
            [ in ]                              CLSID       clsidTaskMajorIn,
            [ in ]                              CLSID       clsidTaskMinorIn,
            [ in ]                              ULONG       ulMinIn,
            [ in ]                              ULONG       ulMaxIn,
            [ in ]                              ULONG       ulCurrentIn,
            [ in ]                              HRESULT     hrStatusIn,
            [ in, pointer_default( unique )  ]  LPCWSTR     pcszDescriptionIn,
            [ in ]                              FILETIME *  pftTimeIn,
            [ in, pointer_default( unique ) ]   LPCWSTR     pcszReferenceIn
            );

}; //*** interface IClusCfgCallback


//****************************************************************************
//++
//
//  interface IClusCfgCredentials
//
//  Description:
//      The IClusCfgCredentials interface provides the functions
//      for getting and setting user credentials.
//
//--
//****************************************************************************
[
    object,
    uuid( 54AA9406-A409-4b49-B314-5F0A0CE4C88E ),
    async_uuid( 54AA9406-A409-4b49-B314-5F0A0CE4C88F ),
    pointer_default( unique )
]
interface IClusCfgCredentials : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //      SetCredentials(
    //          [ in ] LPCWSTR pcszUserIn,
    //          [ in ] LPCWSTR pcszDomainIn,
    //          [ in ] LPCWSTR pcszPasswordIn
    //          )
    //
    //  Description:
    //      Set the credentials.
    //
    //  Parameters:
    //      pcszUserIn
    //          The user name.
    //
    //      pcszDomainIn
    //          The domain name.
    //
    //      pcszPasswordIn
    //          The user's password.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCredentials(
              [ in, pointer_default( unique ) ] LPCWSTR pcszUserIn
            , [ in, pointer_default( unique ) ] LPCWSTR pcszDomainIn
            , [ in, pointer_default( unique ) ] LPCWSTR pcszPasswordIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //      GetCredentials(
    //          [ out ] BSTR * pbstrUserOut,
    //          [ out ] BSTR * pbstrDomainOut,
    //          [ out ] BSTR * pbstrPasswordOut
    //          )
    //
    //  Description:
    //      Get the credentials.
    //
    //  Parameters:
    //      pbstrUserOut
    //          Catches the user name.
    //
    //      pbstrDomainOut
    //          Catches the domain name.
    //
    //      pbstrPasswordOut
    //          Catches the user's password.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetCredentials(
              [ out ] BSTR * pbstrUserOut
            , [ out ] BSTR * pbstrDomainOut
            , [ out ] BSTR * pbstrPasswordOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //      GetIdentity(
    //          [ out ] BSTR * pbstrUserOut,
    //          [ out ] BSTR * pbstrDomainOut
    //          )
    //
    //  Description:
    //      Get the credentials.
    //
    //  Parameters:
    //      pbstrUserOut
    //          Catches the user name.
    //
    //      pbstrDomainOut
    //          Catches the domain name.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetIdentity(
              [ out ] BSTR * pbstrUserOut
            , [ out ] BSTR * pbstrDomainOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //      GetPassword( [ out ] BSTR * pbstrPasswordOut )
    //
    //  Description:
    //      Get the credentials.
    //
    //  Parameters:
    //
    //      pbstrPasswordOut
    //          Catches the user's password.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetPassword( [ out ] BSTR * pbstrPasswordOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //      AssignTo(
    //          [ in ] IClusCfgCredentials * picccDestIn
    //          )
    //
    //  Description:
    //      Write contents to another instance.
    //
    //  Parameters:
    //      picccDestIn
    //          Instance that receives contents.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        AssignTo(
            [ in ] IClusCfgCredentials * picccDestIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //      AssignFrom(
    //          [ in ] IClusCfgCredentials * picccSourceIn
    //          )
    //
    //  Description:
    //      Overwrite contents with those from another instance.
    //
    //  Parameters:
    //      picccSourceIn
    //          Instance from which to overwrite contents.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        AssignFrom(
            [ in ] IClusCfgCredentials * picccSourceIn
            );
}; //*** interface IClusCfgCredentials


//****************************************************************************
//++
//
//  interface IClusCfgCapabilities
//
//  Description:
//      The IClusCfgCapabilities interface provides the functions
//      for determining the capabilities of a node.
//
//--
//****************************************************************************
[
    object,
    uuid( D94AB253-36C7-41c1-B52E-26B451975C8D ),
    pointer_default( unique )
]
interface IClusCfgCapabilities : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  CanNodeBeClustered( void )
    //
    //  Description:
    //      Determines if a node can be clustered.
    //
    //  Parameters:
    //      None.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded. The node can be clustered.
    //
    //      S_FALSE
    //          The call succeeded. The node can not be clustered.
    //
    //      E_NOTIMPL
    //          The call failed. This is treated as a "don't care."
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        CanNodeBeClustered( void );

}; //*** interface IClusCfgCapabilities


//****************************************************************************
//++
//
//  interface IClusCfgManagedResourceCfg
//
//--
//****************************************************************************
[
    object,
    uuid( 60300A0F-77E1-440c-BD94-6BFB0DBFDB3A ),
    local,
    pointer_default( unique )
]
interface IClusCfgManagedResourceCfg : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgManagedResourceCfg::PreCreate(
    //      IUnknown * punkServicesIn
    //      )
    //
    //  Description:
    //      This method is called by the post configuration manager to
    //      determine the requirements of the resource. Querying the
    //      punkServicesIn allows the managed resource to use services
    //      provided by the manager.
    //
    //  Arguments:
    //      punkServicesIn
    //          The resource should QI this interface for services provided
    //          by the post configuration manager and to set its dependencies.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        PreCreate( [ in ] IUnknown * punkServicesIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgManagedResourceCfg::Create(
    //      IUnknown * punkServicesIn
    //      )
    //
    //  Description:
    //      This method is called by the post configuration manager to
    //      have the resource create an instance of itself. Querying the
    //      punkServicesIn allows the managed resource to use services
    //      provided by the manager.
    //
    //  Arguments:
    //      punkServicesIn
    //          The resource should QI this interface for services provided
    //          by the post configuration manager and to create itself.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Create( [ in ] IUnknown * punkServicesIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgManagedResourceCfg::PostCreate(
    //      IUnknown * punkServicesIn
    //      )
    //
    //  Description:
    //      This method is called by the post configuration manager to allow
    //      resources to perform any post-creation configuration that may be
    //      needed. At this point the cluster is fully configured. Querying
    //      the punkServicesIn allows the managed resource to use services
    //      provided by the manager.
    //
    //  Arguments:
    //      punkServicesIn
    //          The resource should QI this interface for services provided
    //          by the post configuration manager.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        PostCreate( [ in ] IUnknown * punkServicesIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgManagedResourceCfg::Evict(
    //      IUnknown * punkServicesIn
    //      )
    //
    //  Description:
    //      This method is called by the post configuration manager to alert
    //      the resource that this node was evicted from the cluster. The
    //      resource should do whatever cleanup it needs to do revert to a
    //      non-clustered state. Querying the  punkServicesIn allows the
    //      managed resource to uses services provided by the post
    //      configuration manager.
    //
    //  Arguments:
    //      punkServicesIn
    //          The resource should QI this interface for services provided
    //          by the post configuration manager.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed. Errors are ignored and do not prevent a node
    //          from being evicted.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Evict( [ in ] IUnknown * punkServicesIn );

}; //*** interface IClusCfgManagedResourceCfg


//****************************************************************************
//++
//
//  interface IClusCfgResourcePreCreate
//
//--
//****************************************************************************
[
    object,
    uuid( 4240F6A1-9D49-427e-8F3D-09384E1F59E4 ),
    local,
    pointer_default( unique )
]
interface IClusCfgResourcePreCreate : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourcePreCreate::SetDependency(
    //      LPCLSID             pclsidDepResTypeIn,
    //      EDependencyFlags    dflagIn
    //      )
    //
    //  Description:
    //      Informs the post configuration manager that a resource has a
    //      dependency on another type of resource and if the resource needs
    //      the resource for shared access or exclusive access.
    //
    //  Arguments:
    //      pclsidDepResTypeIn
    //          The CLSID of the type of resource that a resource is
    //          requesting a dependency on. These are documented in the SDK
    //          or by the 3rd party resource.
    //
    //      dfIn
    //          Flags to modify the dependency relationship. The following
    //          are defined flags:
    //
    //          dfSHARED       - the dependent resource can be shared.
    //          dfEXCLUSIVE    - the dependent resource can not be shared.
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetDependency(
              [ in ] LPCLSID pclsidDepResTypeIn
            , [ in ] DWORD  dfIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourcePreCreate::SetType(
    //      CLSID * pclsidIn
    //      )
    //
    //  Description:
    //      A managed resource MUST call this to indicate its resource type.
    //      Failure to call this during PreCreate will result in your
    //      resource not being created.
    //
    //  Arguments:
    //      pclsidIn
    //          Pointer to the GUID of the resource type.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetType( [ in ] CLSID * pclsidIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourcePreCreate::SetClassType(
    //      CLSID * pclsidIn
    //      )
    //
    //  Description:
    //      A managed resource sets this to indicate that its resource type
    //      can be considered to be of a class of resource. You may call this
    //      multiple times to indicate all the classes you belong to.
    //
    //  Arguments:
    //      pclsidIn
    //          Pointer to the GUID of the resource class type.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetClassType( [ in ] CLSID * pclsidIn );

}; //*** interface IClusCfgResourcePreCreate


//****************************************************************************
//++
//
//  interface IClusCfgResourceCreate
//
//--
//****************************************************************************
[
    object,
    uuid( 0647B41A-C777-443c-9432-02CCCF4FF443 ),
    local,
    pointer_default( unique )
]
interface IClusCfgResourceCreate : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SetPropertyBinary(
    //        [ in ] LPCWSTR        pcszNameIn
    //      , [ in ] const DWORD    cbSizeIn
    //      , [ in ] const BYTE *   pbyteIn
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPropertyBinary(
              [ in, pointer_default( unique ) ] LPCWSTR         pcszNameIn
            , [ in ]                            const DWORD     cbSizeIn
            , [ in ]                            const BYTE *    pbyteIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SetPropertyDWORD(
    //        [ in ] LPCWSTR     pcszNameIn
    //      , [ in ] const DWORD dwDWORDIn
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPropertyDWORD(
              [ in, pointer_default( unique ) ] LPCWSTR        pcszNameIn
            , [ in ]                            const DWORD    dwDWORDIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SetPropertyString(
    //        [ in ] LPCWSTR pcszNameIn
    //      , [ in ] LPCWSTR pcszStringIn
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPropertyString(
              [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
            , [ in, pointer_default( unique ) ] LPCWSTR pcszStringIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SetPropertyExpandString(
    //        [ in ] LPCWSTR pcszNameIn
    //      , [ in ] LPCWSTR pcszStringIn
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPropertyExpandString(
              [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
            , [ in, pointer_default( unique ) ] LPCWSTR pcszStringIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SetPropertyMultiString(
    //        [ in ] LPCWSTR     pcszNameIn
    //      , [ in ] const DWORD cbMultiStringIn
    //      , [ in ] LPCWSTR     pcszMultiStringIn
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPropertyMultiString(
              [ in, pointer_default( unique ) ] LPCWSTR        pcszNameIn
            , [ in ]                            const DWORD    cbMultiStringIn
            , [ in, pointer_default( unique ) ] LPCWSTR        pcszMultiStringIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SetPropertyUnsignedLargeInt(
    //        [ in ] LPCWSTR                pcszNameIn
    //      , [ in ] const ULARGE_INTEGER   ulIntIn
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPropertyUnsignedLargeInt(
              [ in, pointer_default( unique ) ] LPCWSTR                pcszNameIn
            , [ in ]                            const ULARGE_INTEGER   ulIntIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SetPropertyLong(
    //        [ in ] LPCWSTR     pcszNameIn
    //      , [ in ] const LONG  lLongIn
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPropertyLong(
              [ in, pointer_default( unique ) ] LPCWSTR    pcszNameIn
            , [ in ]                            const LONG lLongIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SetPropertySecurityDescriptor(
    //        [ in ] LPCWSTR                     pcszNameIn
    //      , [ in ] const SECURITY_DESCRIPTOR * pcsdIn
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPropertySecurityDescriptor(
              [ in, pointer_default( unique ) ] LPCWSTR  pcszNameIn
            , [ in ] const SECURITY_DESCRIPTOR *   pcsdIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SetPropertyLargeInt(
    //        [ in ] LPCWSTR pcszNameIn
    //      , [ in ] const LARGE_INTEGER lIntIn
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPropertyLargeInt(
              [ in, pointer_default( unique ) ] LPCWSTR             pcszNameIn
            , [ in ]                            const LARGE_INTEGER lIntIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SendResourceControl(
    //        [ in ] DWORD   dwControlCode
    //      , [ in ] LPVOID  lpInBuffer
    //      , [ in ] DWORD   cbInBufferSize
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SendResourceControl(
              [ in ] DWORD   dwControlCodeIn
            , [ in ] LPVOID  lpBufferIn
            , [ in ] DWORD   cbBufferSizeIn
            );

}; //*** interface IClusCfgResourceCreate


//****************************************************************************
//++
//
//  interface IClusCfgResourcePostCreate
//
//--
//****************************************************************************
[
    object,
    uuid( 72A9BF54-13B6-451f-910D-6913EBF025AB ),
    local,
    pointer_default( unique )
]
interface IClusCfgResourcePostCreate : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourcePostCreate::ChangeName(
    //      [ in ] LPCWSTR pcszNameIn
    //      )
    //
    //  Description:
    //      Changes the name of the resource.
    //
    //  Arguments:
    //      pcszNameIn
    //          The name to assign the group.
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ChangeName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceCreate::SendResourceControl(
    //        [ in ]  DWORD   dwControlCode
    //      , [ in ]  LPVOID  lpInBuffer
    //      , [ in ]  DWORD   cbInBufferSize
    //      , [ in ]  LPVOID  lpOutBuffer
    //      , [ in ]  DWORD   cbOutBufferSize
    //      , [ out ] LPDWORD lpcbBytesReturned
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SendResourceControl(
              [ in ]  DWORD   dwControlCodeIn
            , [ in ]  LPVOID  lpBufferIn
            , [ in ]  DWORD   cbBufferSizeIn
            , [ in ]  LPVOID  lBufferInout
            , [ in ]  DWORD   cbOutBufferSizeIn
            , [ out ] LPDWORD lpcbBytesReturnedOut
            );

}; //*** interface IClusCfgResourcePostCreate


//****************************************************************************
//++
//
//  interface IClusCfgGroupCfg
//
//--
//****************************************************************************
[
    object,
    uuid( DCB6D3D2-A55F-49e5-A64A-0CCFEB01ED3A ),
    local,
    pointer_default( unique )
]
interface IClusCfgGroupCfg : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgGroupCfg::SetName(
    //      [ in ] LPCWSTR pcszNameIn
    //      )
    //
    //  Description:
    //      Changes the name of the group in which the resource was created.
    //      Note that the last resource to set the name wins. The ordering
    //      of the last resource is the resource that doesn't have anything
    //      depending on it.
    //
    //  Arguments:
    //      pcszNameIn
    //          The name to assign the group.
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgGroupCfg::GetName(
    //      BSTR * pbstrNameOut
    //      )
    //
    //  Description:
    //      Retrieves the name of the group in which the resource was created.
    //      Note that the last resource to set the name wins. The ordering
    //      of the last resource is the resource that doesn't have anything
    //      depending on it. Do not cache this value as the name may change
    //      after control has been returned to the manager.
    //
    //  Arguments:
    //      pbstrNameOut
    //          The name to assign the group.
    //
    // Return Value:
    //      S_OK
    //          Success.
    //
    //      HRESULT_FROM_WIN32( ERROR_MORE_DATA )
    //          The buffer size specified is too small.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetName( [ out ] BSTR * pbstrNameOut );

}; //*** interface IClusCfgGroupCfg


//****************************************************************************
//++
//
//  interface IClusCfgMemberSetChangeListener
//
//  Description:
//      This interface is implemented by an component that wishes to be notified
//      of when the local computer becomes part of a cluster or when it leaves
//      a cluster - in other words, when the member set of a cluster changes
//      as a result of a cluster configuration operation on the local computer.
//
//--
//****************************************************************************
[
    object,
    uuid( 2B64534F-2643-4ABC-A4E5-824D881B7582 ),
    async_uuid( 2B645350-2643-4ABC-A4E5-824D881B7582 ),
    pointer_default( unique )
]
interface IClusCfgMemberSetChangeListener : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgMemberSetChangeListener::Notify(
    //      [ in ] IUnknown * punkClusterInfoIn
    //      )
    //
    //  Description:
    //      This method is called to notify a component that this computer has
    //      either joined or left a cluster. During this call, a component typically
    //      performs operations that are required to switch it from the "clustered"
    //      to "non-clustered" mode or vice versa. For example, an application
    //      that implements this interface could use this function to create
    //      its resource type when the local computer joins a cluster.
    //
    //      If the node has just become part of a cluster, the cluster
    //      service is guaranteed to be running when this method is called.
    //      Querying the punkClusterInfoIn allows the listener to get more
    //      information about the event that caused the listener to be notified.
    //
    //  Arguments:
    //      punkClusterInfoIn
    //          The resource should QI this interface for services provided
    //          by the caller of this function. Typically, the component that
    //          this punk refers to also implements the IClusCfgClusterInfo
    //          interface.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Notify( [ in ] IUnknown * punkClusterInfoIn );

}; //*** interface IClusCfgMemberSetChangeListener


//****************************************************************************
//++
//
//  interface IClusCfgResourceTypeInfo
//
//  Description:
//      This interface is implemented by components that wish to configure
//      ( create, delete, etc. ) resource types during cluster configuration
//      ( cluster formation, node addition, node eviction, etc. ).
//
//--
//****************************************************************************
[
    object,
    uuid( C649A281-C847-4F5C-9841-D2F73B5AA71D ),
    async_uuid( C649A282-C847-4F5C-9841-D2F73B5AA71D ),
    pointer_default( unique )
]
interface IClusCfgResourceTypeInfo : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceTypeInfo::CommitChanges(
    //      [ in ] IUnknown * punkClusterInfoIn
    //      )
    //
    //  Description:
    //      A component that wishes to participate in the configuration of
    //      cluster resource types should perform the configuration steps
    //      necessary for its resource type in this method.
    //
    //      This method is called by the cluster configuration server when
    //      the local computer becomes part of a cluster. The cluster service
    //      is guaranteed to be running at this stage. This method is also
    //      called when the local computer is evicted from a cluster - the
    //      cluster service will not be running if this is the case.
    //
    //      Typically, a component will create a resource type in this method
    //      during cluster formation and join and will perform any cleanup
    //      required during node evict.
    //
    //  Arguments:
    //      punkClusterInfoIn
    //          The resource type should QI this interface for services provided
    //          by the caller of this function. Typically, the component that
    //          this punk refers to also implements the IClusCfgClusterInfo
    //          interface.
    //
    //      punkResTypeServicesIn
    //          Pointer to the IUnknown interface of a component that provides
    //          methods that help configuring a resource type. For example,
    //          during a join or a form, this punk can be queried for the
    //          IClusCfgResourceTypeCreate interface, which provides methods
    //          for resource type creation.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        CommitChanges(
            [ in ] IUnknown * punkClusterInfoIn,
            [ in ] IUnknown * punkResTypeServicesIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceTypeInfo::GetTypeName(
    //      [ out ] BSTR *  pbstrTypeNameOut
    //      )
    //
    //  Description:
    //      Get the resource type name of this resource type.
    //
    //  Arguments:
    //      pbstrTypeNameOut
    //          Pointer to the BSTR that holds the name of the resource type.
    //          This BSTR has to be freed by the caller using the function
    //          SysFreeString().
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetTypeName( [ out ] BSTR *  pbstrTypeNameOut );


    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceTypeInfo::GetTypeGUID(
    //      [ out ] GUID * pguidGUIDOut
    //      )
    //
    //  Description:
    //      Get the globally unique identifier of this resource type.
    //
    //  Arguments:
    //      pguidGUIDOut
    //          Pointer to the GUID object which will receive the GUID of this
    //          resource type.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded and the *pguidGUIDOut contains the type GUID.
    //
    //      S_FALSE
    //          The call succeeded but this resource type does not have a GUID.
    //          The value of *pguidGUIDOut is undefined after this call.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetTypeGUID( [ out ] GUID * pguidGUIDOut );

}; //*** interface IClusCfgResourceTypeInfo


//****************************************************************************
//++
//
//  interface IClusCfgResourceTypeCreate
//
//  Description:
//      This interface provides functions that help create a resource type
//      during cluster configuration. A pointer to this interface is provided
//      to components that participate in resource type configuration during
//      cluster configuration.
//
//--
//****************************************************************************
[
    object,
    uuid( 3AFCE3B8-5F3E-4DDF-A8F4-4B4FCBF28F8F ),
    async_uuid( 3AFCE3B9-5F3E-4DDF-A8F4-4B4FCBF28F8F ),
    pointer_default( unique )
]
interface IClusCfgResourceTypeCreate : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceTypeCreate::Create(
    //      [in, string ] const WCHAR *     pcszResTypeNameIn,
    //      [in, string ] const WCHAR *     pcszResTypeDisplayNameIn,
    //      [in, string ] const WCHAR *     pcszResDllNameIn,
    //      [in] DWORD                      dwLooksAliveIntervalIn,
    //      [in] DWORD                      dwIsAliveIntervalIn
    //      )
    //
    //  Description:
    //      This method creates a cluster resource type.
    //
    //  Arguments:
    //      pcszResTypeNameIn
    //          Name of the resource type
    //
    //      pcszResTypeDisplayNameIn
    //          Display name of the resource type
    //
    //      pcszResDllNameIn
    //          Name (with or without path information) of DLL of the resource type.
    //
    //      dwLooksAliveIntervalIn
    //          Looks-alive interval for the resource type (in milliseconds).
    //
    //      dwIsAliveIntervalIn
    //          Is-alive interval for the resource type (in milliseconds).
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Create(
            [in, string ] const WCHAR *      pcszResTypeNameIn,
            [in, string ] const WCHAR *      pcszResTypeDisplayNameIn,
            [in, string ] const WCHAR *      pcszResDllNameIn,
            [in] DWORD                       dwLooksAliveIntervalIn,
            [in] DWORD                       dwIsAliveIntervalIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgResourceTypeCreate::RegisterAdminExtensions(
    //      [in, string ]                           const WCHAR *       pcszResDllNameIn,
    //      [in]                                    ULONG               cExtClsidCountIn,
    //      [in, size_is( cExtClsidCountIn ) ]      const CLSID *       rgclsidExtClsidsIn
    //      )
    //
    //  Description:
    //      This method registers the cluster administrator extensions for
    //      a resource type.
    //
    //  Arguments:
    //      pcszResTypeNameIn
    //          Name of the resource type against for the extensions are to be
    //          registered.
    //
    //      cExtClsidCountIn
    //          Number of extension class ids in the next parameter.
    //
    //      rgclsidExtClsidsIn
    //          Pointer to an array of class ids of cluster administrator extensions.
    //          This can be NULL if cExtClsidCountIn is 0.
    //
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        RegisterAdminExtensions(
            [in, string ]                           const WCHAR *   pcszResTypeNameIn,
            [in]                                    ULONG           cExtClsidCountIn,
            [in, size_is( cExtClsidCountIn ) ]      const CLSID *   rgclsidExtClsidsIn
            );

}; //*** interface IClusCfgResourceTypeCreate


//****************************************************************************
//++
//
//  interface IClusCfgEvictCleanup
//
//  Description:
//      This interface can be used to cleanup a node that has been evicted from
//      a cluster.
//
//--
//****************************************************************************
[
    object,
    uuid( 6FE3E361-D373-4C5F-A0AF-1DFE8493C655 ),
    async_uuid( 6FE3E362-D373-4C5F-A0AF-1DFE8493C655 ),
    pointer_default( unique )
]
interface
IClusCfgEvictCleanup : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgEvictCleanup::CleanupLocal( [ in ] DWORD dwDelayIn )
    //
    //  Description:
    //      This method performs the clean up actions on the local node after
    //      it has been evicted from a cluster, so that the node can go back
    //      to its "pre-clustered" state.
    //
    //  Arguments:
    //      DWORD dwDelayIn
    //          Number of milliseconds that this method will wait before starting
    //          cleanup. If some other process cleans up this node while this thread
    //          is waiting, the wait is terminated. If this value is zero, this method
    //          will attempt to clean up this node immediately.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      Other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        CleanupLocalNode( [ in ] DWORD dwDelayIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgEvictCleanup::CleanupRemoteNode(
    //        const WCHAR * pcszEvicteeNodeNameIn
    //      , DWORD dwDelayIn
    //      )
    //
    //  Description:
    //      This method performs the clean up actions on a remote node after
    //      it has been evicted from a cluster, so that the node can go back
    //      to its "pre-clustered" state.
    //
    //  Arguments:
    //      const WCHAR * pcszEvictedNodeNameIn
    //          Name of the node that has just been evicted. This can be the
    //          NetBios name of the node, the fully qualified domain name or
    //          the node IP address.
    //
    //      DWORD dwDelayIn
    //          Number of milliseconds that this method will wait before starting
    //          cleanup. If some other process cleans up this node while this thread
    //          is waiting, the wait is terminated. If this value is zero, this method
    //          will attempt to clean up this node immediately.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      Other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        CleanupRemoteNode(
              [ in, string ] const WCHAR * pcszEvictedNodeNameIn
            , [ in ] DWORD dwDelayIn
            );

}; // interface IClusCfgEvictCleanup

//****************************************************************************
//++
//
//  interface IClusCfgStartupListener
//
//  Description:
//      This interface is implemented by a component that wishes to be notified
//      when the cluster service has started.
//
//--
//****************************************************************************
[
    object,
    uuid( D282CAEF-2EDE-4ab9-A5D5-F7BDE3D23F0F ),
    async_uuid( D282CAF0-2EDE-4ab9-A5D5-F7BDE3D23F10 ),
    pointer_default( unique )
]
interface
IClusCfgStartupListener : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgStartupListener::Notify( [ in ] IUnknown * punkIn )
    //
    //  Description:
    //      This method is called to inform a component that the cluster service
    //      has started on the local node.
    //
    //  Arguments:
    //      IUnknown * punkIn
    //          The component that implements this Punk may also provide services
    //          that are useful to the implementor of this method. For example,
    //          this component usually implements the IClusCfgResourceTypeCreate
    //          interface.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      Other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Notify( [ in ] IUnknown * punkIn );

}; // interface IClusCfgStartupListener


//****************************************************************************
//++
//
//  interface IClusCfgStartupNotify
//
//  Description:
//      This interface is implemented by a component that the cluster service
//      instantiates. When the cluster service calls the only method on this
//      interface, this component will enumerate the startup listeners and
//      inform them that the cluster service has started on the local node.
//
//--
//****************************************************************************
[
    object,
    uuid( C2B0D069-6353-4EE1-B253-6B0D75DB2CD3 ),
    async_uuid( C2B0D06A-6353-4EE1-B253-6B0D75DB2CD3 ),
    pointer_default( unique )
]
interface
IClusCfgStartupNotify : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgStartupNotify::SendNotifications( void )
    //
    //  Description:
    //      This method is called by the Cluster Service to inform the implementor
    //      of this interface to send out notification of cluster service startup
    //      to interested listeners. If this method is being called for the first
    //      time, the method waits till the post configuration steps are complete
    //      before sending out the notifications.
    //
    //  Arguments:
    //      None.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      Other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SendNotifications( void );

}; // interface IClusCfgStartupNotify


//****************************************************************************
//++
//
//  interface IClusCfgManagedResourceData
//
//  Description:
//      This inteface allows instances of resources to get, set, and exchange
//      data between instances of themselves on different nodes.
//
//--
//****************************************************************************
[
    object,
    uuid( 8447ECB7-2171-4e21-A108-0EB5B0B516DA ),
    pointer_default( unique )
]
interface IClusCfgManagedResourceData : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgManagedResourceData::GetResourcePrivateData(
    //        [ out ] BYTE *    pbBufferOut
    //      , [ out ] DWORD *   pcbBufferInout
    //      )
    //
    //  Description:
    //      Get an already managed resource's private state data.  This
    //      data will then be passed to the instances of that resource on all
    //      nodes that are being added to the cluster.
    //
    //  Arguments:
    //      pbBufferOut
    //          Pointer to a buffer to contain the resource's private state data.
    //
    //      pcbBufferInout
    //          On input it is the size of the buffer.  On output it is the size
    //          of the data.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //  ERROR_INSUFFICIENT_BUFFER as an HRESULT
    //      When the passed in buffer is too small to hold the data.
    //      pcbBufferOutIn will contain the size required.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetResourcePrivateData(
              [ out, size_is( *pcbBufferInout ) ] BYTE *    pbBufferOut
            , [ in, out ] DWORD *                           pcbBufferInout
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgManagedResourceData::SetResourcePrivateData(
    //        [ in ] const BYTE *   pcbBufferIn
    //      , [ in ] DWORD          cbBufferIn
    //      )
    //
    //  Description:
    //      Set the private resource data into this instance of a managed
    //      resource.
    //
    //  Arguments:
    //      pcbBufferIn
    //          Pointer to a buffer containing the resource's private data.
    //
    //      cbBufferIn
    //          The length in bytes of the data buffer.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetResourcePrivateData(
              [  in
               , pointer_default( unique )
               , size_is( cbBufferIn )
               ]                            const BYTE *   pcbBufferIn
            , [ in ] DWORD                  cbBufferIn
            );

}; //*** interface IClusCfgManagedResourceData


//****************************************************************************
//++
//
//  interface IClusCfgVerifyQuorum
//
//  Description:
//      Ensure that the quorum resource can be hosted on all nodes being added
//      to the cluster.
//
//      The IClusCfgManagedResourceData interface will be called just prior to
//      any calls to the methods of this interface to allow the quorum resource
//      to set all data needed for the quorum to be hosted on the nodes that
//      are being added to the cluster.
//
//--
//****************************************************************************
[
    object,
    uuid( 90A2EFAE-1B62-4ada-BF1C-BECAB56F748D ),
    pointer_default( unique )
]
interface IClusCfgVerifyQuorum : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgVerifyQuorum::PrepareToHostQuorumResource(
    //      void
    //      )
    //
    //  Description:
    //      This method is called when the implementing managed resource
    //      is the quorum resource.  This gives the implementer a chance
    //      to do anything required to ensure that this node can
    //      indeed host the quorum resource.
    //
    //      This method will be called after the SetResourcePrivateData()
    //      method of the IClusCfgManagedResourceData interface has been
    //      called. This allows the implementer to get the latest state data
    //      from a running instance of their resource.
    //
    //  Arguments:
    //      None.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        PrepareToHostQuorumResource( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgVerifyQuorum::Cleanup(
    //      EClusCfgCleanupReason cccrReasonIn
    //      )
    //
    //  Description:
    //      This method is called when a cluster configuration task is
    //      shutting down.  The reason for the shut down is passed in
    //      the cccrReasonIn parameter.
    //
    //      It is expected that any lingering changes made in
    //      PrepareToHostQuorumResource() would be undone when the
    //      reason code in not a success code.
    //
    //  Arguments:
    //      cccrReasonIn
    //          The reason that this method was called.  See
    //          EClusCfgCleanupReason for the complete list of possbile
    //          reason codes.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Cleanup( [ in ] EClusCfgCleanupReason cccrReasonIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IsMultiNodeCapable( void )
    //
    //  Description:
    //      Call this to determine if this quorum capable resource allows
    //      other nodes to join the cluster and create a multi node cluster.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded and the result is "TRUE."
    //
    //      S_FALSE
    //          Call succeeded and the result is "FALSE."
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        IsMultiNodeCapable( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetMultiNodeCapable(
    //      [ in ] BOOL fMultiNodeCapableIn
    //      )
    //
    //  Description:
    //      Call this to set this quorum resource as being multi node capable.
    //
    //  Return Values:
    //      S_OK
    //          Call succeeded
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetMultiNodeCapable( [ in ] BOOL fMultiNodeCapableIn );

}; //*** interface IClusCfgVerifyQuorum


//****************************************************************************
//++
//
//  interface IClusCfgEvictListener
//
//  Description:
//      This interface is implemented by a component that wishes to be notified
//      when the a node has been evicted from the cluster.
//
//--
//****************************************************************************
[
    object,
    uuid( E20DDEE3-DEFC-4d54-B1F7-2AEB784C3847 ),
    async_uuid( 08609AC3-D284-4009-805F-17D3CFE4160B ),
    pointer_default( unique )
]
interface
IClusCfgEvictListener : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgEvictListener::EvictNotify(
    //      [ in ] LPCWSTR pcszNodeNameIn
    //      )
    //
    //  Description:
    //      This method is called to inform a component that a node has been
    //      evicted from the cluster.
    //
    //  Arguments:
    //      pcszNodeNameIn
    //          The name of the node that was evicted.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      Other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        EvictNotify(
            [ in, pointer_default( unique ) ] LPCWSTR pcszNodeNameIn
            );

}; // interface IClusCfgEvictListener


//****************************************************************************
//++
//
//  interface IClusCfgEvictNotify
//
//  Description:
//      This interface is implemented by a component that the cluster service
//      instantiates. When the cluster service calls the only method on this
//      interface, this component will enumerate the evict listeners and
//      inform them that a node has been evicted from the cluster.  These
//      components will be running on a cluster node and are capable of using
//      the cluster API in their implementation.
//
//--
//****************************************************************************
[
    object,
    uuid( 090E7745-9E5B-4d76-936E-D760CF2FF3B9 ),
    async_uuid( AD2E83CC-1D14-4d20-928E-22D344847454 ),
    pointer_default( unique )
]
interface
IClusCfgEvictNotify : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IClusCfgEvictNotify::SendNotifications(
    //      [ in, pointer_default( unique ) ] LPCWSTR pcszNodeNameIn
    //      )
    //
    //  Description:
    //      This method is called by the Cluster Service to inform the implementor
    //      of this interface to send out notification when a node is evicted from
    //      the cluster to interested listeners.
    //
    //  Arguments:
    //      pcszNodeNameIn
    //          The name of the node that was evicted.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      Other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SendNotifications(
            [ in, pointer_default( unique ) ] LPCWSTR pcszNodeNameIn
            );

}; // interface IClusCfgEvictNotify