//////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2000-2001 Microsoft Corporation
//
//  Module Name:
//      ClusCfgClient.idl
//
//  Description:
//      This file is the IDL file for the middler tier framework for the
//      Cluster Configuration Wizard.
//
//////////////////////////////////////////////////////////////////////////////


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


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

import "unknwn.idl";
import "objidl.idl";
import "ocidl.idl";
import "ClusCfgServer.idl";


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

interface IClusCfgCallback;

interface INotifyUI;
interface IObjectManager;
interface INotificationManager;
interface ITaskManager;
interface IDoTask;
interface ITaskLoginDomain;
interface ITaskLoginDomainCallback;
interface ITaskGetDomains;
interface ITaskGetDomainsCallback;
interface ITaskAnalyzeCluster;
interface ITaskCommitClusterChanges;
interface ITaskVerifyIPAddress;
interface IStandardInfo;
interface IConnectionManager;
interface IConnectionInfo;
interface IGatherData;
interface IConfigurationConnection;
interface ITaskGatherNodeInfo;
interface ITaskGatherInformation;
interface IEnumNodes;
interface ITaskCompareAndPushInformation;
interface ITaskGatherClusterInfo;
interface IEnumCookies;
interface ITaskPollingCallback;
interface ILogManager;
interface ILogger;

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


typedef DWORD   OBJECTCOOKIE;


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


//****************************************************************************
//++
//
//  interface INotifyUI
//
//  Description:
//      TODO:   gpease  10-MAR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( E5E8D401-1A37-4fbf-880C-826CC89516FD ),
    pointer_default( unique )
]
interface INotifyUI : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  INotifyUI::ObjectChanged(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Notifies the UI layer that the object "cookieIn"has changed. The
    //      object implementing this interface must marshall the data.
    //
    //  Arguments:
    //      cookieIn
    //          Data Manager cookie to the object that changed.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ObjectChanged(
            [ in ] OBJECTCOOKIE cookieIn
            );

}; //*** interace INotifyUI

//****************************************************************************
//++
//
//  interface IDoTask
//
//  Description:
//      TODO:   gpease  15-APR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 0230C9F8-EE7F-4307-98DB-726EBCAE55D6 ),
    pointer_default( unique )
]
interface
IDoTask : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IDoTask::BeginTask( void )
    //
    //  Description:
    //      Entry method for a task object.
    //
    //  Arguments:
    //      None. You should describe a private interface to communicate
    //      parameters to your task.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        BeginTask( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IDoTask::StopTask( void )
    //
    //  Description:
    //      Entry method to stop/cancel and running task.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        StopTask( void );

}; //*** interface IDoTask

//****************************************************************************
//++
//
//  interface INotificationManager
//
//  Description:
//      TODO:   gpease  15-APR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 95531501-8782-4845-901D-312F36BA6C6E ),
    pointer_default( unique )
]
interface
INotificationManager : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  INotificationManager::AddConnectionPoint(
    //        REFIID                riidIn
    //      , IConnectionPoint *    pcpIn
    //      )
    //
    //  Description:
    //      Adds a connection point for the notification manager to manage
    //      for a particular interface. There can only be one registration
    //      for a particular interface.
    //
    //  Arguments:
    //      riidIn
    //          The IID of the interface.
    //
    //      pcpIn
    //          Interface to the connection point.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      CO_E_OBJISREG
    //          The interface for the connection point is already registered.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        AddConnectionPoint(
              [ in ] REFIID             riidIn
            , [ in ] IConnectionPoint * pcpIn
            );

}; //*** interface INotificationManager

//****************************************************************************
//++
//
//  interface IConnectionManager
//
//  Description:
//      TODO:   gpease  15-APR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( C0017768-1BF3-4352-8D6C-3A8C1D0FB477 ),
    pointer_default( unique )
]
interface
IConnectionManager : IUnknown
{

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetConnectionToObject(
    //        OBJECTCOOKIE  cookieIn
    //      , IUnknown **   ppunkOut
    //      )
    //
    //  Description:
    //      Establishes a connection to the object referenced by "cookieIn."
    //
    //  Arguments:
    //      cookieIn
    //          An object reference cookie from the Object Manager.
    //
    //      ppunkOut
    //          Interface pointer to the object.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetConnectionToObject(
              [ in ]  OBJECTCOOKIE  cookieIn
            , [ out ] IUnknown **   ppunkOut
            );

}; //*** interface IConnectionManager


//****************************************************************************
//++
//
//  interface ITaskManager
//
//  Description:
//      TODO:   gpease  15-APR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 16116694-DFC5-470b-AC12-46FBB01CEF10 ),
    pointer_default( unique )
]
interface
ITaskManager : IUnknown
{

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskManager::CreateTask(
    //        REFIID        clsidIn
    //      , IUnknown **   ppunkOut
    //      )
    //
    //  Description:
    //      Submits a task to the Action Manager.
    //
    //  Arguments:
    //      pTask
    //          Task to submit.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call fails.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        CreateTask(
              [ in ]  REFIID        clsidIn
            , [ out ] IUnknown **   ppunkOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskManager::SubmitTask(
    //      IDoTask *   pTask
    //      )
    //
    //  Description:
    //      Submits a task to the Action Manager.
    //
    //  Arguments:
    //      pTask
    //          Task to submit.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call fails.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SubmitTask(
            [ in ] IDoTask * pTask
            );

}; //*** interface ITaskManager


//****************************************************************************
//++
//
//  interface ITaskManager
//
//  Description:
//      TODO:   gpease  15-APR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( D51351DF-6394-4236-9783-65ED05631068 ),
    pointer_default( unique )
]
interface
IObjectManager : IUnknown
{

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IObjectManager::FindObject(
    //        REFCLSID          rclsidTypeIn
    //      , OBJECTCOOKIE      cookieParentIn
    //      , LPCWSTR           pcszNameIn
    //      , REFCLSID          rclsidFormatIn
    //      , OBJECTCOOKIE *    pcookieOut
    //      , LPUNKNOWN *       ppunkOut
    //      )
    //
    //  Description:
    //      Looks up and retrieves information about an object that has the
    //      type "rclsidTypeIn" and has the name "pcszNameIn". It will return
    //      an object that contains data in the format specified by
    //      "rclsidFormatIn". It will also return "pcookieOut" that can be
    //      used to identify the object in future requests.
    //
    //  Arguments:
    //      rclsidTypeIn
    //          The type of the object to find.
    //
    //      cookieParentIn
    //          Cookie of the cluster. NULL looking for a cluster.
    //
    //      pcszNameIn
    //          The name of the object to find.
    //
    //      rclsidFormatIn
    //          The format of the data to retrieve about the object.
    //
    //      pcookieOut
    //          A value that represents the object.
    //
    //      ppunkOut
    //          The requested data. NULL in indicates no data returned.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      S_PENDING
    //          Data being retrieved; ask again later using the cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        FindObject(
              [ in ]                            REFCLSID        rclsidTypeIn
            , [ in ]                            OBJECTCOOKIE    cookieClusterIn
            , [ in, pointer_default( unique ) ] LPCWSTR         pcszNameIn
            , [ in ]                            REFCLSID        rclsidFormatIn
            , [ out ]                           OBJECTCOOKIE *  pcookieOut
            , [ out ]                           LPUNKNOWN *     ppunkOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IObjectManager::GetObject(
    //        REFCLSID      rclsidFormatIn
    //      , OBJECTCOOKIE  cookieIn
    //      , LPUNKNOWN *   ppunkOut
    //      )
    //
    //  Description:
    //      Lookups and retrieves information about the object using "cookieIn"
    //      as a reference. It will return an object that contains data in the
    //      format specified by "rclsidFormatIn".
    //
    //  Arguments:
    //      rclsidFormatIn
    //          The format of the data to retrieve about the object.
    //
    //      pcookieIn
    //          The value of the object to retrieve data from.
    //
    //      ppunkOut
    //          The requested data. NULL in indicates no data returned.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      S_PENDING
    //          Data being retrieved; ask again later using the cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetObject(
              [ in ]  REFCLSID      rclsidFormatIn
            , [ in ]  OBJECTCOOKIE  cookieIn
            , [ out ] LPUNKNOWN *   ppunkOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IObjectManager::RemoveObject(
    //      OBJECTCOOKIE    cookieIn
    //      )
    //
    //  Description:
    //      Removes an object from the object cache and requests deletion all
    //      existing data format objects. This will also remove all children
    //      of the object (if any).
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the object to be removed.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        RemoveObject(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IObjectManager::SetObjectStatus(
    //        OBJECTCOOKIE  cookieIn
    //      , HRESULT       hrIn
    //      )
    //
    //  Description:
    //      Sets the status on an object.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the object.
    //
    //      hrIn
    //          Status to set.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetObjectStatus(
              [ in ] OBJECTCOOKIE   cookieIn
            , [ in ] HRESULT        hrIn
            );

}; //*** interface IObjectManager


//
//  Task Interfaces
//

//****************************************************************************
//++
//
//  interface ITaskLoginDomain
//
//  Description:
//      TODO:   gpease  15-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 76AD8E51-53C3-4347-895D-6C30F4139374 ),
    pointer_default( unique )
]
interface
ITaskLoginDomain : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskLoginDomain::SetCallback(
    //      ITaskLoginDomainCallback * punkIn
    //      )
    //
    //  Description:
    //      Sets the callback interface for the task to inform the caller
    //      of the status of the login.
    //
    //  Arguments:
    //      punkIn
    //          The ITaskLoginDomainCallback interface to inform caller of
    //          statuc.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCallback(
            [ in ] ITaskLoginDomainCallback * punkIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskLoginDomain::SetDomain(
    //      LPCWSTR    pcszDomainIn
    //      )
    //
    //  Description:
    //      Sets the domain to attempt to login into.
    //
    //  Arguments:
    //      pcszDomainIn
    //          Name of the domain to be logged into.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetDomain(
            [ in, pointer_default( unique ) ] LPCWSTR pcszDomainIn
            );

}; //*** interface ITaskLoginDomain

//****************************************************************************
//++
//
//  interface ITaskLoginDomainCallback
//
//  Description:
//      TODO:   gpease  15-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( EFAF3C43-7A8F-469b-B8BB-C80C5747CE05 ),
    pointer_default( unique )
]
interface
ITaskLoginDomainCallback : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskLoginDomainCallback::ReceiveLoginResult(
    //      HRESULT hrIn
    //      )
    //
    //  Description:
    //      Callback used to tell the invoker of TaskLoginDomain the results
    //      of the login attempt. All Win32 errors will be mapped to HRESULTs
    //      via HRESULT_FROM_WIN32.
    //
    //  Arguments:
    //      hrIn
    //          The HRESULT result code of the login attempt.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ReceiveLoginResult(
            [ in ] HRESULT hrIn
            );

}; //*** interface ITaskLoginDomainCallback

//****************************************************************************
//++
//
//  interface ITaskGetDomains
//
//  Description:
//      TODO:   gpease  15-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( DFCB4ACD-C4DB-4db4-8EBB-1DD07A9D5B82 ),
    pointer_default( unique )
]
interface
ITaskGetDomains : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGetDomains::SetCallback(
    //      ITaskGetDomainsCallback * pResultsCallbackIn
    //      )
    //
    //  Description:
    //      Stores the ITaskGetDomainsCallback that will be used to send
    //      status and names for this task.
    //
    //  Arguments:
    //      pResultsCallbackIn
    //          The ITaskGetDomainsCallback interface of the object that will
    //          receive the status information as well as the names that are
    //          enumerated.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCallback(
            [ in ] ITaskGetDomainsCallback * pResultsCallbackIn
            );

}; // *** interface ITaskGetDomains

//****************************************************************************
//++
//
//  interface ITaskGetDomainsCallback
//
//  Description:
//      TODO:   gpease  15-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 85402E44-6834-41df-8590-01827D124E1B ),
    pointer_default( unique )
]
interface
ITaskGetDomainsCallback : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    // STDMETHOD
    // ITaskGetDomainsCallback::ReceiveDomainResult(
    //      HRESULT hrIn
    //      )
    //
    // Description:
    //      Callback used to tell the invoker of TaskGetDomains the results
    //      of the enumeration. This will be only called if there is a
    //      problem.
    //
    // Arguments:
    //      hrIn
    //          The HRESULT result code of the login attempt.
    //
    // Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed - this will abort the enumeration.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ReceiveDomainResult( [ in ] HRESULT hrIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGetDomainsCallback::ReceiveDomainName(
    //      LPCWSTR    pcszDomainIn
    //      )
    //
    //  Description:
    //      This method will be called by the TaskGetDomains to send an
    //      enumerated name back to the UI layer.
    //
    //  Arguments:
    //      pcszDomainIn
    //          The next enumerated domain name.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs
    //          The call failed - this will abort the enumeration.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ReceiveDomainName(
            [ in, pointer_default( unique ) ] LPCWSTR pcszDomainIn
            );

}; //*** interface ITaskGetDomainsCallback

//****************************************************************************
//++
//
//  interface ITaskAnalyzeCluster
//
//  Description:
//      TODO:   gpease  18-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 795737A1-E13A-45eb-8DFD-8185C4B7AD4E ),
    pointer_default( unique )
]
interface
ITaskAnalyzeCluster : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskAnalyzeCluster::SetJoiningMode( void )
    //
    //  Description:
    //      Changes this task to joining mode.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetJoiningMode( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskAnalyzeCluster::SetCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie that will be used to send the notification that the
    //      task has been completed.
    //
    //  Arguments:
    //      cookieIn
    //          A cookie that will be sent as notification that the task is done.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskAnalyzeCluster::SetClusterCookie(
    //      OBJECTCOOKIE cookieClusterIn
    //      )
    //
    //  Description:
    //      Stores the cookie of the cluster configuration object.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the cluster to configure.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetClusterCookie(
            [ in ] OBJECTCOOKIE cookieClusterIn
            );

}; //*** interface ITaskAnalyzeCluster


//****************************************************************************
//++
//
//  interface ITaskCommitClusterChanges
//
//  Description:
//      TODO:   gpease  18-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 1BF12DDE-F8B0-49b1-A458-6747DB788A47 ),
    pointer_default( unique )
]
interface
ITaskCommitClusterChanges : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCommitClusterChanges::SetCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie that will be used to send the notification that the
    //      task has been completed.
    //
    //  Arguments:
    //      cookieIn
    //          A cookie that will be sent as notification that the task is done.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCommitClusterChanges::SetClusterCookie(
    //      OBJECTCOOKIE cookieClusterIn
    //      )
    //
    //  Description:
    //      Stores the cookie of the cluster configuration object.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the cluster to configure.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetClusterCookie(
            [ in ] OBJECTCOOKIE cookieClusterIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCommitClusterChanges::SetJoining( void )
    //
    //  Description:
    //      Sets the task into joining mode.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetJoining( void );

}; //*** interface ITaskCommitClusterChanges

//****************************************************************************
//++
//
//  interface IStandardInfo
//
//  Description:
//      TODO:   gpease  18-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( F1D9C1A5-9589-40dd-B63D-9BB0B38A1022 ),
    pointer_default( unique )
]
interface
IStandardInfo : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::GetType(
    //      CLSID * pclsidTypeOut
    //      )
    //
    //  Description:
    //      Retrieves the type of object.
    //
    //  Arguments:
    //      pclsidTypeOut
    //          The CLSID representing the type.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetType(
            [ out ] CLSID * pclsidTypeOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::GetName(
    //      BSTR * pbstrNameOut
    //      )
    //
    //  Description:
    //      Retrieve the object's name.
    //
    //  Arguments:
    //      pbstrNameOut
    //          The name of the object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetName(
            [ out ] BSTR * pbstrNameOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::SetName(
    //      LPCWSTR pcszNameIn
    //      )
    //
    //  Description:
    //      Sets the object's name.
    //
    //  Arguments:
    //      ppcszNameIn
    //          The name of the object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetName(
            [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::GetParent(
    //      OBJECTCOOKIE * pcookieOut
    //      )
    //
    //  Description:
    //      Retrieve the parent object's cookie.
    //
    //  Arguments:
    //      pcookieOut
    //          The cookie for the parent object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      S_FALSE
    //          Success but there wasn't a cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetParent(
            [ out ] OBJECTCOOKIE * pcookieOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::GetStatus(
    //      HRESULT * phrOut
    //      )
    //
    //  Description:
    //      Retrieves the status of the object.
    //
    //  Arguments:
    //      phrOut
    //          The last HRESULT received for the object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      S_FALSE
    //          Success but there wasn't a cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetStatus(
            [ out ] HRESULT * phrOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::SetStatus(
    //      HRESULT hrIn
    //      )
    //
    //  Description:
    //      Sets the status of the object.
    //
    //  Arguments:
    //      hrIn
    //          Sets the last HRESULT for the object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      S_FALSE
    //          Success but there wasn't a cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetStatus(
            [ in ] HRESULT hrIn
            );

}; //*** interface IStandardInfo

//****************************************************************************
//++
//
//  interface ITaskVerifyIPAddress
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 0c95e1b1-0cff-4740-8abd-69912d105bd1 ),
    pointer_default( unique )
]
interface
ITaskVerifyIPAddress : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskVerifyIPAddress::SetIPAddress(
    //      DWORD   dwIPAddressIn
    //      )
    //
    //  Description:
    //      Stores the IP Address to verify.
    //
    //  Arguments:
    //      dwIPAddressIn
    //          Dotted-quad network-byte-order IP address to verify.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetIPAddress(
            [ in ] DWORD dwIPAddressIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskVerifyIPAddress::SetCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie that will be used to send the notification that the
    //      task has been completed.
    //
    //  Arguments:
    //      cookieIn
    //          A cookie that will be sent as notification that the task is done.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

}; //*** interface ITaskVerifyIPAddress

//****************************************************************************
//++
//
//  interface IConfigurationConnection
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( DDAD8191-66C5-4a30-A4DF-CB6C216704CA ),
    pointer_default( unique )
]
interface
IConfigurationConnection : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ConnectTo(
    //      LPVOID  cookieIn
    //      )
    //
    //  Description:
    //      Opens a connection a cluster "cookieIn".
    //
    //  Arguments:
    //      cookieIn        - cookie to the cluster to open.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ConnectTo(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ConnectToObject(
    //        LPVOID        cookieIn
    //      , REFIID        riidIn
    //      , LPUNKNOWN *   ppunkOut
    //      )
    //
    //  Description:
    //      Opens a connection a cluster "cookieIn".
    //
    //  Arguments:
    //      cookieIn        - cookie to the cluster to open.
    //      riidIn          - riid of the interface to get.
    //      ppunkOut        - the interface to the object requested.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ConnectToObject(
              [ in ] OBJECTCOOKIE   cookieIn
            , [ in ] REFIID         riidIn
            , [ in ] LPUNKNOWN *    ppunkOut
            );

}; //*** interface IConfigurationConnection


//****************************************************************************
//++
//
//  interface IConnectionInfo
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 15182CE3-82D7-473f-92DE-706E2BCEA902 ),
    pointer_default( unique )
]
interface
IConnectionInfo : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IConnectionInfo::GetConnection(
    //      IConfigurationConnection ** pccOut
    //      )
    //
    //  Description:
    //      Retrieves the cookie for the connection object that is used to
    //      communicate with the object in question.
    //
    //  Arguments:
    //      pccOut
    //          The interface to the connection object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      S_FALSE
    //          Success but there wasn't a cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetConnection(
            [ out ] IConfigurationConnection ** pccOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IConnectionInfo::SetConnection(
    //      IConfigurationConnection * pccIn
    //      )
    //
    //  Description:
    //      Stores the cookie for the connection object that is used to
    //      communicate with the object in question.
    //
    //  Arguments:
    //      pccIn
    //          The interface to the connection object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetConnection(
            [ in ] IConfigurationConnection * pccIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IConnectionInfo::GetParent(
    //      OBJECTCOOKIE * pcookieOut
    //      )
    //
    //  Description:
    //      Retrieve the parent object's cookie.
    //
    //  Arguments:
    //      pcookieOut
    //          The cookie for the parent object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      S_FALSE
    //          Success but there wasn't a cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetParent(
            [ out ] OBJECTCOOKIE * pcookieOut
            );

}; //*** interface IConnectionInfo


//****************************************************************************
//++
//
//  interface IEnumCookies
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//  Documentation:
//      See IEnumXXXX in MSDN.
//
//--
//****************************************************************************
[
    object,
    uuid( 5E3E482E-3C22-482c-B664-693051AD0A5D ),
    pointer_default( unique )
]
interface
IEnumCookies : IUnknown
{
    HRESULT
        Next(
              [ in ]                                                    ULONG           celtIn
            , [ out, size_is( celtIn ), length_is( *pceltFetchedOut ) ] OBJECTCOOKIE *  rgcookieOut
            , [ out ]                                                   ULONG *         pceltFetchedOut
            );

    HRESULT
        Skip(
            [ in ] ULONG celtIn
            );

    HRESULT
        Reset( void );

    HRESULT
        Clone(
            [ out ] IEnumCookies ** ppenumOut
            );

    HRESULT
        Count(
            [ out, ref ] DWORD * pnCountOut
            );

}; //*** interface IEnumCookies


//****************************************************************************
//++
//
//  interface IEnumNodes
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//  Documentation:
//      See IEnumXXXX in MSDN.
//
//--
//****************************************************************************
[
    object,
    uuid( C477E363-AF0A-4203-A604-45CD607DD710 ),
    pointer_default( unique )
]
interface
IEnumNodes : IUnknown
{
    HRESULT
        Next(
              [ in ]                                                    ULONG               celtIn
            , [ out, size_is( celtIn ), length_is( *pceltFetchedOut ) ] IClusCfgNodeInfo ** rgccniOut
            , [ out ]                                                   ULONG *             pceltFetchedOut
            );

    HRESULT
        Skip(
            [ in ] ULONG celtIn
            );

    HRESULT
        Reset( void );

    HRESULT
        Clone(
            [ out ] IEnumNodes ** ppenumOut
            );

    HRESULT
        Count(
            [ out, ref ] DWORD * pnCountOut
            );

}; //*** interface IEnumNodes


//****************************************************************************
//++
//
//  interface ITaskGatherClusterInfo
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( E167965C-C5D6-493c-A343-4C105C01DDE7 ),
    pointer_default( unique )
]
interface
ITaskGatherClusterInfo : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherClusterInfo::SetCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to the Node to retrieve information about.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the Node to retrieve information about.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      E_OUTOFMEMORY   - Out of memory.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherClusterInfo::SetCompletionCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to signal when task is completed.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie to signal when the task is completed.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCompletionCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

}; //*** interface ITaskGatherClusterInfo


//****************************************************************************
//++
//
//  interface IGatherData
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 65318F4A-B63C-4e21-ADDC-BDCFB969E181 ),
    pointer_default( unique )
]
interface
IGatherData : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IGatherData::Gather(
    //      OBJECTCOOKIE cookieParentIn,
    //      IUnknown * punkIn
    //      )
    //
    //  Description:
    //      An object representation gathers the information from the punk.
    //
    //  Arguments:
    //      cookieParentIn
    //          The parent of the object.
    //
    //      punkIn
    //          The interface that can be used to gather information.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Gather(
              [ in ] OBJECTCOOKIE   cookieParentIn
            , [ in ] IUnknown *     punkIn
            );

}; //*** interface IGatherData


//****************************************************************************
//++
//
//  interface ITaskGatherNodeInfo
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( F19A2E01-2CB3-47b4-8F5D-B977176B45C8 ),
    pointer_default( unique )
]
interface
ITaskGatherNodeInfo : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherNodeInfo::SetCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to the Node to retrieve information about.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the Node to retrieve information about.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      E_OUTOFMEMORY   - Out of memory.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherNodeInfo::SetCompletionCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to signal when the task is completed.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie to signal when the task is completed.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCompletionCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

}; //*** interface ITaskGatherNodeInfo

//****************************************************************************
//++
//
//  interface ITaskCompareAndPushInformation
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( D4F1C2AF-B370-49de-8768-4010B568636C ),
    pointer_default( unique )
]
interface
ITaskCompareAndPushInformation : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCompareAndPushInformation::SetNodeCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to the Node to retrieve information about.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the Node to retrieve information about.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetNodeCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCompareAndPushInformation::SetCompletionCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to signal when the task is completed.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie to signal when the task is completed.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCompletionCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

}; //*** interface ITaskCompareAndPushInformation

//****************************************************************************
//++
//
//  interface ITaskGatherInformation
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( B9AAF3F8-238E-4993-BA31-14859804F92C ),
    pointer_default( unique )
]
interface
ITaskGatherInformation : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherInformation::SetNodeCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to the Node to retrieve information about.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the Node to retrieve information about.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetNodeCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherInformation::SetCompletionCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to signal when the task is completed.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie to signal when the task is completed.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCompletionCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherInformation::SetJoining( void )
    //
    //  Description:
    //      Sets the task to indicate that it going to be joining nodes.
    //
    //  Arguments:
    //      None.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetJoining( void );

}; //*** interface ITaskGatherInformation


//****************************************************************************
//++
//
//  interface ITaskPollingCallback
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 49E92395-66AF-4add-A41E-43512CB519B3 ),
    pointer_default( unique )
]
interface
ITaskPollingCallback : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskPollingCallback::SetServerGITCookie(
    //      DWORD dwGITCookieIn
    //      )
    //
    //  Description:
    //      Stores the GIT cookie to the IClusCfgServer interface of the
    //      server object.
    //
    //  Arguments:
    //      dwGITCookieIn
    //          The GIT cookie to the server object used to obtain the
    //          polling callback interface.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetServerGITCookie(
            [ in ] DWORD dwGITCookieIn
            );

}; //*** interface ITaskPollingCallback


//****************************************************************************
//++
//
//  interface IClusCfgAsyncEvictCleanup
//
//  Description:
//      This interface can be used to cleanup a node that has been evicted from
//      a cluster. This interface can be used to cleanup both local and remote
//      nodes. Note, you cannot use asynchronous COM with this interface, since
//      it is an oleautomation interface.
//
//--
//****************************************************************************
[
    object,
    oleautomation,
    uuid( 52C80B95-C1AD-4240-8D89-72E9FA84025E ),
    pointer_default( unique )
]
interface
IClusCfgAsyncEvictCleanup : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  HRESULT
    //  CleanupNode(
    //        LPCWSTR  pcszEvictedNodeNameIn
    //      , DWORD dwDelayIn
    //      , DWORD dwTimeoutIn
    //      )
    //
    //  Routine Description:
    //      Cleanup a node that has been evicted.
    //
    //  Arguments:
    //      LPCWSTR  pcszEvictedNodeNameIn
    //          Name of the node on which cleanup is to be initiated. If this is NULL
    //          the local node is cleaned up.
    //
    //      DWORD dwDelayIn
    //          Number of milliseconds that will elapse before cleanup is started
    //          on the target node. If some other process cleans up the target node while
    //          delay is in progress, the delay is terminated. If this value is zero,
    //          the node is cleaned up immediately.
    //
    //      DWORD dwTimeoutIn
    //          Number of milliseconds that this method will wait for cleanup to complete.
    //          This timeout is independent of the delay above, so if dwDelayIn is greater
    //          than dwTimeoutIn, this method will most probably timeout. Once initiated,
    //          however, cleanup will run to completion - this method just may not wait for it
    //          to complete.
    //
    //  Return Value:
    //      S_OK
    //          If the cleanup operations were successful
    //
    //      RPC_S_CALLPENDING
    //          If cleanup is not complete in dwTimeoutIn milliseconds
    //
    //      Other HRESULTS
    //          In case of error
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        CleanupNode(
              [ in, pointer_default( unique ) ] LPCWSTR  pcszEvictedNodeNameIn
            , [ in ]                            DWORD dwDelayIn
            , [ in ]                            DWORD dwTimeoutIn
            );

}; //*** interface IClusCfgAsyncEvictCleanup

//****************************************************************************
//++
//
//  interface ILogManager
//
//  Description:
//      Manage logging for all clients of the middle tier.
//
//--
//****************************************************************************
[
    object,
    uuid( 4759DC11-8DA0-4261-BBFB-EC321911D1C9 ),
    pointer_default( unique )
]
interface
ILogManager : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ILogManager::StartLogging( void )
    //
    //  Description:
    //      Starts logging IClusCfgCallback notifications to the log file.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        StartLogging( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ILogManager::StopLogging( void )
    //
    //  Description:
    //      Stops logging IClusCfgCallback notifications to the log file.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        StopLogging( void );

}; //*** interface ILogManager

//****************************************************************************
//++
//
//  interface ILogger
//
//  Description:
//      Manage logging from multiple sources to the same log file.
//
//--
//****************************************************************************
[
    object,
    uuid( D9598418-304E-4f94-B6A1-E642FE95ED57 ),
    pointer_default( unique )
]
interface
ILogger : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ILogger::LogMsg(
    //      LPCWSTR pcszMsgIn
    //      )
    //
    //  Description:
    //      Logs a message to the log file.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        LogMsg(
            [ in, pointer_default( unique ) ] LPCWSTR pcszMsgIn
            );

}; //*** interface ILogger