windows-server-2003/ds/netapi/svcdlls/lls/idl/llsrpc.idl

/*++

Copyright (C) Microsoft Corporation, 1995 - 1997

Module Name:

   llsrpc.idl

Abstract:

   License Logging Service RPC Interface Definition File

   This file contains the RPC Interface Definition Language file for
   the LLS.

Author:

   Arthur Hanson       (arth)      Jan 20-1994

Environment:

   User Mode

Revision History:

   Jeff Parham (jeffparh) 06-Dec-1995
      o  Added LLS_LICENSE_INFO_1 and LLS_PRODUCT_LICENSE_INFO_1 support.
      o  Added new API's for SUR.
      o  Plugged memory leak at the server caused by LlsConnect() and
         LlsReplConnect() being defined as taking PNAMEW parameters (which
         differ from LPWSTR's in the sense that they're not automatically
         freed at the server), even though they neither stored nor freed
         the passed pointers.

--*/

[
    uuid(342CFD40-3C6C-11CE-A893-08002B2E9C6D),
    version(0.0),
#ifdef __midl
    ms_union,
#endif // __midl
    pointer_default(unique)
]

interface llsrpc

{

//
// Import a dummy interface containing #includes for public .h files.  This
// trick is necessary so that midl will only generate marshalling routines
// for subtypes that are relevant to the parameters specified on the RPC
// interface.  midl also ingores function prototypes contained therein.
//

import "llsimp.idl" ;

//
// Emit these constants into the generated file.
//
cpp_quote("#define LLS_LPC_ENDPOINT \"llslpc\"")
//
// Note: Must use quad backslash to emit two backslashes into #define
// which when compiled will boil down to single backslash
//
cpp_quote("#define LLS_NP_ENDPOINT \"\\\\pipe\\\\llsrpc\"")

//
// LLS RPC Context Handle
//

typedef [context_handle] PVOID   LLS_HANDLE;
typedef [context_handle] PVOID   LLS_REPL_HANDLE;

typedef [ref] LLS_HANDLE *       PLLS_HANDLE;
typedef [ref] LLS_REPL_HANDLE *  PLLS_REPL_HANDLE;

// these are not freed at the server
typedef [string] LPWSTR  PNAMEW;
typedef [string] LPSTR   PNAMEA;


///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////
// License Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_LICENSE_INFO_0W {
   PNAMEW Product;
   LONG   Quantity;
   DWORD  Date;
   PNAMEW Admin;
   PNAMEW Comment;
} LLS_LICENSE_INFO_0W, *PLLS_LICENSE_INFO_0W;

typedef struct _LLS_LICENSE_INFO_1W {
   PNAMEW Product;
   PNAMEW Vendor;
   LONG   Quantity;
   DWORD  MaxQuantity;
   DWORD  Date;
   PNAMEW Admin;
   PNAMEW Comment;
   DWORD  AllowedModes;
   DWORD  CertificateID;
   PNAMEW Source;
   DWORD  ExpirationDate;
   DWORD  Secrets[ 4 ];
} LLS_LICENSE_INFO_1W, *PLLS_LICENSE_INFO_1W;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_LICENSE_INFO_0W LicenseInfo0;
   [case(1)]    LLS_LICENSE_INFO_1W LicenseInfo1;
} LLS_LICENSE_INFOW, *PLLS_LICENSE_INFOW;

typedef struct _LLS_LICENSE_INFO_0_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_LICENSE_INFO_0W Buffer;
} LLS_LICENSE_INFO_0_CONTAINERW, *PLLS_LICENSE_INFO_0_CONTAINERW;

typedef struct _LLS_LICENSE_INFO_1_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_LICENSE_INFO_1W Buffer;
} LLS_LICENSE_INFO_1_CONTAINERW, *PLLS_LICENSE_INFO_1_CONTAINERW;

typedef struct _LLS_LICENSE_ENUM_STRUCTW {
    DWORD   Level;
    [switch_is(Level)] union _LLS_LICENSE_ENUM_UNIONW {
        [case(0)]
            PLLS_LICENSE_INFO_0_CONTAINERW Level0;
        [case(1)]
            PLLS_LICENSE_INFO_1_CONTAINERW Level1;
        [default]
            ;
    } LlsLicenseInfo;
} LLS_LICENSE_ENUM_STRUCTW, *PLLS_LICENSE_ENUM_STRUCTW;


//
// ANSI
//
typedef struct _LLS_LICENSE_INFO_0A {
   PNAMEA Product;
   LONG   Quantity;
   DWORD  Date;
   PNAMEA Admin;
   PNAMEA Comment;
} LLS_LICENSE_INFO_0A, *PLLS_LICENSE_INFO_0A;

typedef struct _LLS_LICENSE_INFO_1A
{
   PNAMEA Product;
   PNAMEA Vendor;
   LONG   Quantity;
   DWORD  MaxQuantity;
   DWORD  Date;
   PNAMEA Admin;
   PNAMEA Comment;
   DWORD  AllowedModes;
   DWORD  CertificateID;
   PNAMEA Source;
   DWORD  ExpirationDate;
   DWORD  Secrets[ 4 ];
} LLS_LICENSE_INFO_1A, *PLLS_LICENSE_INFO_1A;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_LICENSE_INFO_0A LicenseInfo0;
   [case(1)]    LLS_LICENSE_INFO_1A LicenseInfo1;
} LLS_LICENSE_INFOA, *PLLS_LICENSE_INFOA;

typedef struct _LLS_LICENSE_INFO_0_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_LICENSE_INFO_0A Buffer;
} LLS_LICENSE_INFO_0_CONTAINERA, *PLLS_LICENSE_INFO_0_CONTAINERA;

typedef struct _LLS_LICENSE_INFO_1_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_LICENSE_INFO_1A Buffer;
} LLS_LICENSE_INFO_1_CONTAINERA, *PLLS_LICENSE_INFO_1_CONTAINERA;

typedef struct _LLS_LICENSE_ENUM_STRUCTA {
    DWORD   Level;
    [switch_is(Level)] union _LLS_LICENSE_ENUM_UNIONA {
        [case(0)]
            PLLS_LICENSE_INFO_0_CONTAINERA Level0;
        [case(1)]
            PLLS_LICENSE_INFO_1_CONTAINERA Level1;
        [default]
            ;
    } LlsLicenseInfo;
} LLS_LICENSE_ENUM_STRUCTA, *PLLS_LICENSE_ENUM_STRUCTA;



///////////////////////////////////////////////////////////////////////////////
// Product Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_PRODUCT_INFO_0W {
   PNAMEW Product;
} LLS_PRODUCT_INFO_0W, *PLLS_PRODUCT_INFO_0W;

typedef struct _LLS_PRODUCT_INFO_1W {
   PNAMEW Product;
   ULONG  Purchased;
   ULONG  InUse;
   ULONG  TotalConcurrent;
   ULONG  HighMark;
} LLS_PRODUCT_INFO_1W, *PLLS_PRODUCT_INFO_1W;

typedef [switch_type(DWORD)] union {
   [case(0)] LLS_PRODUCT_INFO_0W ProductInfo0;
   [case(1)] LLS_PRODUCT_INFO_1W ProductInfo1;
} LLS_PRODUCT_INFOW, *PLLS_PRODUCT_INFOW;

typedef struct _LLS_PRODUCT_INFO_0_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_INFO_0W Buffer;
} LLS_PRODUCT_INFO_0_CONTAINERW, *PLLS_PRODUCT_INFO_0_CONTAINERW;

typedef struct _LLS_PRODUCT_INFO_1_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_INFO_1W Buffer;
} LLS_PRODUCT_INFO_1_CONTAINERW, *PLLS_PRODUCT_INFO_1_CONTAINERW;

typedef struct _LLS_PRODUCT_ENUM_STRUCTW {
    DWORD   Level;
    [switch_is(Level)] union _LLS_PRODUCT_ENUM_UNIONW {
        [case(0)]
            PLLS_PRODUCT_INFO_0_CONTAINERW Level0;
        [case(1)]
            PLLS_PRODUCT_INFO_1_CONTAINERW Level1;
        [default]
            ;
    } LlsProductInfo;
} LLS_PRODUCT_ENUM_STRUCTW, *PLLS_PRODUCT_ENUM_STRUCTW;


//
// ANSI
//
typedef struct _LLS_PRODUCT_INFO_0A {
   PNAMEA Product;
} LLS_PRODUCT_INFO_0A, *PLLS_PRODUCT_INFO_0A;

typedef struct _LLS_PRODUCT_INFO_1A {
   PNAMEA Product;
   ULONG  Purchased;
   ULONG  InUse;
   ULONG  TotalConcurrent;
   ULONG  HighMark;
} LLS_PRODUCT_INFO_1A, *PLLS_PRODUCT_INFO_1A;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_PRODUCT_INFO_0A ProductInfo0;
   [case(1)]    LLS_PRODUCT_INFO_1A ProductInfo1;
} LLS_PRODUCT_INFOA, *PLLS_PRODUCT_INFOA;

typedef struct _LLS_PRODUCT_INFO_0_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_INFO_0A Buffer;
} LLS_PRODUCT_INFO_0_CONTAINERA, *PLLS_PRODUCT_INFO_0_CONTAINERA;

typedef struct _LLS_PRODUCT_INFO_1_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_INFO_1A Buffer;
} LLS_PRODUCT_INFO_1_CONTAINERA, *PLLS_PRODUCT_INFO_1_CONTAINERA;

typedef struct _LLS_PRODUCT_ENUM_STRUCTA {
    DWORD   Level;
    [switch_is(Level)] union _LLS_PRODUCT_ENUM_UNIONA {
        [case(0)]
            PLLS_PRODUCT_INFO_0_CONTAINERW Level0;
        [case(1)]
            PLLS_PRODUCT_INFO_1_CONTAINERW Level1;
        [default]
            ;
    } LlsProductInfo;
} LLS_PRODUCT_ENUM_STRUCTA, *PLLS_PRODUCT_ENUM_STRUCTA;


///////////////////////////////////////////////////////////////////////////////
// Product User Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_PRODUCT_USER_INFO_0W {
   PNAMEW User;
} LLS_PRODUCT_USER_INFO_0W, *PLLS_PRODUCT_USER_INFO_0W;

typedef struct _LLS_PRODUCT_USER_INFO_1W {
   PNAMEW User;
   DWORD  Flags;
   DWORD  LastUsed;
   ULONG  UsageCount;
} LLS_PRODUCT_USER_INFO_1W, *PLLS_PRODUCT_USER_INFO_1W;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_PRODUCT_USER_INFO_0W ProductUserInfo0;
   [case(1)]    LLS_PRODUCT_USER_INFO_1W ProductUserInfo1;
} LLS_PRODUCT_USER_INFOW, *PLLS_PRODUCT_USER_INFOW;

typedef struct _LLS_PRODUCT_USER_INFO_0_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_USER_INFO_0W Buffer;
} LLS_PRODUCT_USER_INFO_0_CONTAINERW, *PLLS_PRODUCT_USER_INFO_0_CONTAINERW;

typedef struct _LLS_PRODUCT_USER_INFO_1_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_USER_INFO_1W Buffer;
} LLS_PRODUCT_USER_INFO_1_CONTAINERW, *PLLS_PRODUCT_USER_INFO_1_CONTAINERW;

typedef struct _LLS_PRODUCT_USER_ENUM_STRUCTW {
    DWORD   Level;
    [switch_is(Level)] union _LLS_PRODUCT_USER_ENUM_UNIONW {
        [case(0)]
            PLLS_PRODUCT_USER_INFO_0_CONTAINERW Level0;
        [case(1)]
            PLLS_PRODUCT_USER_INFO_1_CONTAINERW Level1;
        [default]
            ;
    } LlsProductUserInfo;
} LLS_PRODUCT_USER_ENUM_STRUCTW, *PLLS_PRODUCT_USER_ENUM_STRUCTW;


//
// ANSI
//
typedef struct _LLS_PRODUCT_USER_INFO_0A {
   PNAMEA User;
} LLS_PRODUCT_USER_INFO_0A, *PLLS_PRODUCT_USER_INFO_0A;

typedef struct _LLS_PRODUCT_USER_INFO_1A {
   PNAMEA User;
   DWORD  Flags;
   DWORD  LastUsed;
   ULONG  UsageCount;
} LLS_PRODUCT_USER_INFO_1A, *PLLS_PRODUCT_USER_INFO_1A;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_PRODUCT_USER_INFO_0A ProductUserInfo0;
   [case(1)]    LLS_PRODUCT_USER_INFO_1A ProductUserInfo1;
} LLS_PRODUCT_USER_INFOA, *PLLS_PRODUCT_USER_INFOA;

typedef struct _LLS_PRODUCT_USER_INFO_0_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_USER_INFO_0A Buffer;
} LLS_PRODUCT_USER_INFO_0_CONTAINERA, *PLLS_PRODUCT_USER_INFO_0_CONTAINERA;

typedef struct _LLS_PRODUCT_USER_INFO_1_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_USER_INFO_1A Buffer;
} LLS_PRODUCT_USER_INFO_1_CONTAINERA, *PLLS_PRODUCT_USER_INFO_1_CONTAINERA;

typedef struct _LLS_PRODUCT_USER_ENUM_STRUCTA {
    DWORD   Level;
    [switch_is(Level)] union _LLS_PRODUCT_USER_ENUM_UNIONA {
        [case(0)]
            PLLS_PRODUCT_USER_INFO_0_CONTAINERA Level0;
        [case(1)]
            PLLS_PRODUCT_USER_INFO_1_CONTAINERA Level1;
        [default]
            ;
    } LlsProductUserInfo;
} LLS_PRODUCT_USER_ENUM_STRUCTA, *PLLS_PRODUCT_USER_ENUM_STRUCTA;


///////////////////////////////////////////////////////////////////////////////
// Product License Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_PRODUCT_LICENSE_INFO_0W {
   LONG   Quantity;
   DWORD  Date;
   PNAMEW Admin;
   PNAMEW Comment;
} LLS_PRODUCT_LICENSE_INFO_0W, *PLLS_PRODUCT_LICENSE_INFO_0W;

typedef struct _LLS_PRODUCT_LICENSE_INFO_1W {
   LONG   Quantity;
   DWORD  MaxQuantity;
   DWORD  Date;
   PNAMEW Admin;
   PNAMEW Comment;
   DWORD  AllowedModes;
   DWORD  CertificateID;
   PNAMEW Source;
   DWORD  ExpirationDate;
   DWORD  Secrets[ 4 ];
} LLS_PRODUCT_LICENSE_INFO_1W, *PLLS_PRODUCT_LICENSE_INFO_1W;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_PRODUCT_LICENSE_INFO_0W ProductLicenseInfo0;
   [case(1)]    LLS_PRODUCT_LICENSE_INFO_1W ProductLicenseInfo1;
} LLS_PRODUCT_LICENSE_INFOW, *PLLS_PRODUCT_LICNESE_INFOW;

typedef struct _LLS_PRODUCT_LICENSE_INFO_0_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_LICENSE_INFO_0W Buffer;
} LLS_PRODUCT_LICENSE_INFO_0_CONTAINERW, *PLLS_PRODUCT_LICENSE_INFO_0_CONTAINERW;

typedef struct _LLS_PRODUCT_LICENSE_INFO_1_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_LICENSE_INFO_1W Buffer;
} LLS_PRODUCT_LICENSE_INFO_1_CONTAINERW, *PLLS_PRODUCT_LICENSE_INFO_1_CONTAINERW;

typedef struct _LLS_PRODUCT_LICENSE_ENUM_STRUCTW {
    DWORD   Level;
    [switch_is(Level)] union _LLS_PRODUCT_LICENSE_ENUM_UNIONW {
        [case(0)]
            PLLS_PRODUCT_LICENSE_INFO_0_CONTAINERW Level0;
        [case(1)]
            PLLS_PRODUCT_LICENSE_INFO_1_CONTAINERW Level1;
        [default]
            ;
    } LlsProductLicenseInfo;
} LLS_PRODUCT_LICENSE_ENUM_STRUCTW, *PLLS_PRODUCT_LICENSE_ENUM_STRUCTW;


//
// ANSI
//
typedef struct _LLS_PRODUCT_LICENSE_INFO_0A {
   LONG   Quantity;
   DWORD  Date;
   PNAMEA Admin;
   PNAMEA Comment;
} LLS_PRODUCT_LICENSE_INFO_0A, *PLLS_PRODUCT_LICENSE_INFO_0A;

typedef struct _LLS_PRODUCT_LICENSE_INFO_1A {
   LONG   Quantity;
   DWORD  MaxQuantity;
   DWORD  Date;
   PNAMEA Admin;
   PNAMEA Comment;
   DWORD  AllowedModes;
   DWORD  CertificateID;
   PNAMEA Source;
   DWORD  ExpirationDate;
   DWORD  Secrets[ 4 ];
} LLS_PRODUCT_LICENSE_INFO_1A, *PLLS_PRODUCT_LICENSE_INFO_1A;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_PRODUCT_LICENSE_INFO_0A ProductLicenseInfo0;
   [case(1)]    LLS_PRODUCT_LICENSE_INFO_1A ProductLicenseInfo1;
} LLS_PRODUCT_LICENSE_INFOA, *PLLS_PRODUCT_LICENSE_INFOA;

typedef struct _LLS_PRODUCT_LICENSE_INFO_0_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_LICENSE_INFO_0A Buffer;
} LLS_PRODUCT_LICENSE_INFO_0_CONTAINERA, *PLLS_PRODUCT_LICENSE_INFO_0_CONTAINERA;

typedef struct _LLS_PRODUCT_LICENSE_INFO_1_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_PRODUCT_LICENSE_INFO_1A Buffer;
} LLS_PRODUCT_LICENSE_INFO_1_CONTAINERA, *PLLS_PRODUCT_LICENSE_INFO_1_CONTAINERA;

typedef struct _LLS_PRODUCT_LICENSE_ENUM_STRUCTA {
    DWORD   Level;
    [switch_is(Level)] union _LLS_PRODUCT_LICENSE_ENUM_UNIONA {
        [case(0)]
            PLLS_PRODUCT_LICENSE_INFO_0_CONTAINERA Level0;
        [case(1)]
            PLLS_PRODUCT_LICENSE_INFO_1_CONTAINERA Level1;
        [default]
            ;
    } LlsProductLicenseInfo;
} LLS_PRODUCT_LICENSE_ENUM_STRUCTA, *PLLS_PRODUCT_LICENSE_ENUM_STRUCTA;


///////////////////////////////////////////////////////////////////////////////
// Server Product Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_SERVER_PRODUCT_INFO_0W {
   PNAMEW Name;
} LLS_SERVER_PRODUCT_INFO_0W, *PLLS_SERVER_PRODUCT_INFO_0W;

typedef struct _LLS_SERVER_PRODUCT_INFO_1W {
   PNAMEW Name;
   DWORD Flags;
   ULONG MaxUses;
   ULONG MaxSetUses;
   ULONG HighMark;
} LLS_SERVER_PRODUCT_INFO_1W, *PLLS_SERVER_PRODUCT_INFO_1W;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_SERVER_PRODUCT_INFO_0W ServerProductInfo0;
   [case(1)]    LLS_SERVER_PRODUCT_INFO_1W ServerProductInfo1;
} LLS_SERVER_PRODUCT_INFOW, *PLLS_SERVER_PRODUCT_INFOW;

typedef struct _LLS_SERVER_PRODUCT_INFO_0_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_SERVER_PRODUCT_INFO_0W Buffer;
} LLS_SERVER_PRODUCT_INFO_0_CONTAINERW, *PLLS_SERVER_PRODUCT_INFO_0_CONTAINERW;

typedef struct _LLS_SERVER_PRODUCT_INFO_1_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_SERVER_PRODUCT_INFO_1W Buffer;
} LLS_SERVER_PRODUCT_INFO_1_CONTAINERW, *PLLS_SERVER_PRODUCT_INFO_1_CONTAINERW;

typedef struct _LLS_SERVER_PRODUCT_ENUM_STRUCTW {
    DWORD   Level;
    [switch_is(Level)] union _LLS_SERVER_PRODUCT_ENUM_UNIONW {
        [case(0)]
            PLLS_SERVER_PRODUCT_INFO_0_CONTAINERW Level0;
        [case(1)]
            PLLS_SERVER_PRODUCT_INFO_1_CONTAINERW Level1;
        [default]
            ;
    } LlsServerProductInfo;
} LLS_SERVER_PRODUCT_ENUM_STRUCTW, *PLLS_SERVER_PRODUCT_ENUM_STRUCTW;


//
// ANSI
//
typedef struct _LLS_SERVER_PRODUCT_INFO_0A {
   PNAMEA Name;
} LLS_SERVER_PRODUCT_INFO_0A, *PLLS_SERVER_PRODUCT_INFO_0A;

typedef struct _LLS_SERVER_PRODUCT_INFO_1A {
   PNAMEA Name;
   DWORD Flags;
   ULONG MaxUses;
   ULONG MaxSetUses;
   ULONG HighMark;
} LLS_SERVER_PRODUCT_INFO_1A, *PLLS_SERVER_PRODUCT_INFO_1A;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_SERVER_PRODUCT_INFO_0A ServerProductInfo0;
   [case(1)]    LLS_SERVER_PRODUCT_INFO_1A ServerProductInfo1;
} LLS_SERVER_PRODUCT_INFOA, *PLLS_SERVER_PRODUCT_INFOA;

typedef struct _LLS_SERVER_PRODUCT_INFO_0_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_SERVER_PRODUCT_INFO_0A Buffer;
} LLS_SERVER_PRODUCT_INFO_0_CONTAINERA, *PLLS_SERVER_PRODUCT_INFO_0_CONTAINERA;

typedef struct _LLS_SERVER_PRODUCT_INFO_1_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_SERVER_PRODUCT_INFO_1A Buffer;
} LLS_SERVER_PRODUCT_INFO_1_CONTAINERA, *PLLS_SERVER_PRODUCT_INFO_1_CONTAINERA;

typedef struct _LLS_SERVER_PRODUCT_ENUM_STRUCTA {
    DWORD   Level;
    [switch_is(Level)] union _LLS_SERVER_PRODUCT_ENUM_UNIONA {
        [case(0)]
            PLLS_SERVER_PRODUCT_INFO_0_CONTAINERA Level0;
        [case(1)]
            PLLS_SERVER_PRODUCT_INFO_1_CONTAINERA Level1;
        [default]
            ;
    } LlsServerProductInfo;
} LLS_SERVER_PRODUCT_ENUM_STRUCTA, *PLLS_SERVER_PRODUCT_ENUM_STRUCTA;



///////////////////////////////////////////////////////////////////////////////
// User Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_USER_INFO_0W {
   PNAMEW Name;
} LLS_USER_INFO_0W, *PLLS_USER_INFO_0W;

typedef struct _LLS_USER_INFO_1W {
   PNAMEW Name;
   DWORD  Flags;
   PNAMEW Mapping;
   ULONG  Licensed;
   ULONG  UnLicensed;
} LLS_USER_INFO_1W, *PLLS_USER_INFO_1W;

typedef struct _LLS_USER_INFO_2W {
   PNAMEW Name;
   DWORD  Flags;
   PNAMEW Mapping;
   ULONG  Licensed;
   ULONG  UnLicensed;
   [string, unique] LPWSTR Products;
} LLS_USER_INFO_2W, *PLLS_USER_INFO_2W;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_USER_INFO_0W UserInfo0;
   [case(1)]    LLS_USER_INFO_1W UserInfo1;
   [case(2)]    LLS_USER_INFO_2W UserInfo2;
} LLS_USER_INFOW, *PLLS_USER_INFOW;

typedef struct _LLS_USER_INFO_0_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_USER_INFO_0W Buffer;
} LLS_USER_INFO_0_CONTAINERW, *PLLS_USER_INFO_0_CONTAINERW;

typedef struct _LLS_USER_INFO_1_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_USER_INFO_1W Buffer;
} LLS_USER_INFO_1_CONTAINERW, *PLLS_USER_INFO_1_CONTAINERW;

typedef struct _LLS_USER_INFO_2_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_USER_INFO_2W Buffer;
} LLS_USER_INFO_2_CONTAINERW, *PLLS_USER_INFO_2_CONTAINERW;

typedef struct _LLS_USER_ENUM_STRUCTW {
    DWORD   Level;
    [switch_is(Level)] union _LLS_USER_ENUM_UNIONW {
        [case(0)]
            PLLS_USER_INFO_0_CONTAINERW Level0;
        [case(1)]
            PLLS_USER_INFO_1_CONTAINERW Level1;
        [case(2)]
            PLLS_USER_INFO_2_CONTAINERW Level2;
        [default]
            ;
    } LlsUserInfo;
} LLS_USER_ENUM_STRUCTW, *PLLS_USER_ENUM_STRUCTW;


//
// ANSI
//
typedef struct _LLS_USER_INFO_0A {
   PNAMEA Name;
} LLS_USER_INFO_0A, *PLLS_USER_INFO_0A;

typedef struct _LLS_USER_INFO_1A {
   PNAMEA Name;
   DWORD  Flags;
   PNAMEA Mapping;
   ULONG  Licensed;
   ULONG  UnLicensed;
} LLS_USER_INFO_1A, *PLLS_USER_INFO_1A;

typedef struct _LLS_USER_INFO_2A {
   PNAMEA Name;
   DWORD  Flags;
   PNAMEA Mapping;
   ULONG  Licensed;
   ULONG  UnLicensed;
   [string, unique] LPSTR Products;
} LLS_USER_INFO_2A, *PLLS_USER_INFO_2A;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_USER_INFO_0A UserInfo0;
   [case(1)]    LLS_USER_INFO_1A UserInfo1;
   [case(2)]    LLS_USER_INFO_2A UserInfo2;
} LLS_USER_INFOA, *PLLS_USER_INFOA;

typedef struct _LLS_USER_INFO_0_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_USER_INFO_0A Buffer;
} LLS_USER_INFO_0_CONTAINERA, *PLLS_USER_INFO_0_CONTAINERA;

typedef struct _LLS_USER_INFO_1_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_USER_INFO_1A Buffer;
} LLS_USER_INFO_1_CONTAINERA, *PLLS_USER_INFO_1_CONTAINERA;

typedef struct _LLS_USER_INFO_2_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_USER_INFO_2A Buffer;
} LLS_USER_INFO_2_CONTAINERA, *PLLS_USER_INFO_2_CONTAINERA;

typedef struct _LLS_USER_ENUM_STRUCTA {
    DWORD   Level;
    [switch_is(Level)] union _LLS_USER_ENUM_UNIONA {
        [case(0)]
            PLLS_USER_INFO_0_CONTAINERA Level0;
        [case(1)]
            PLLS_USER_INFO_1_CONTAINERA Level1;
        [case(2)]
            PLLS_USER_INFO_2_CONTAINERA Level2;
        [default]
            ;
    } LlsUserInfo;
} LLS_USER_ENUM_STRUCTA, *PLLS_USER_ENUM_STRUCTA;


///////////////////////////////////////////////////////////////////////////////
// User Product info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_USER_PRODUCT_INFO_0W {
   PNAMEW Product;
} LLS_USER_PRODUCT_INFO_0W, *PLLS_USER_PRODUCT_INFO_0W;

typedef struct _LLS_USER_PRODUCT_INFO_1W {
   PNAMEW Product;
   DWORD  Flags;
   DWORD  LastUsed;
   ULONG  UsageCount;
} LLS_USER_PRODUCT_INFO_1W, *PLLS_USER_PRODUCT_INFO_1W;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_USER_PRODUCT_INFO_0W UserProduct0;
   [case(1)]    LLS_USER_PRODUCT_INFO_1W UserProduct1;
} LLS_USER_PRODUCT_INFOW, *PLLS_USER_PRODUCT_INFOW;

typedef struct _LLS_USER_PRODUCT_INFO_0_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_USER_PRODUCT_INFO_0W Buffer;
} LLS_USER_PRODUCT_INFO_0_CONTAINERW, *PLLS_USER_PRODUCT_INFO_0_CONTAINERW;

typedef struct _LLS_USER_PRODUCT_INFO_1_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_USER_PRODUCT_INFO_1W Buffer;
} LLS_USER_PRODUCT_INFO_1_CONTAINERW, *PLLS_USER_PRODUCT_INFO_1_CONTAINERW;

typedef struct _LLS_USER_PRODUCT_ENUM_STRUCTW {
    DWORD   Level;
    [switch_is(Level)] union _LLS_USER_PRODUCT_ENUM_UNIONW {
        [case(0)]
            PLLS_USER_PRODUCT_INFO_0_CONTAINERW Level0;
        [case(1)]
            PLLS_USER_PRODUCT_INFO_1_CONTAINERW Level1;
        [default]
            ;
    } LlsUserProductInfo;
} LLS_USER_PRODUCT_ENUM_STRUCTW, *PLLS_USER_PRODUCT_ENUM_STRUCTW;


//
// ANSI
//
typedef struct _LLS_USER_PRODUCT_INFO_0A {
   PNAMEA Product;
} LLS_USER_PRODUCT_INFO_0A, *PLLS_USER_PRODUCT_INFO_0A;

typedef struct _LLS_USER_PRODUCT_INFO_1A {
   PNAMEA Product;
   DWORD  Flags;
   DWORD  LastUsed;
   ULONG  UsageCount;
} LLS_USER_PRODUCT_INFO_1A, *PLLS_USER_PRODUCT_INFO_1A;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_USER_PRODUCT_INFO_0A UserProduct0;
   [case(1)]    LLS_USER_PRODUCT_INFO_1A UserProduct1;
} LLS_USER_PRODUCT_INFOA, *PLLS_USER_PRODUCT_INFOA;

typedef struct _LLS_USER_PRODUCT_INFO_0_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_USER_PRODUCT_INFO_0A Buffer;
} LLS_USER_PRODUCT_INFO_0_CONTAINERA, *PLLS_USER_PRODUCT_INFO_0_CONTAINERA;

typedef struct _LLS_USER_PRODUCT_INFO_1_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_USER_PRODUCT_INFO_1A Buffer;
} LLS_USER_PRODUCT_INFO_1_CONTAINERA, *PLLS_USER_PRODUCT_INFO_1_CONTAINERA;

typedef struct _LLS_USER_PRODUCT_ENUM_STRUCTA {
    DWORD   Level;
    [switch_is(Level)] union _LLS_USER_PRODUCT_ENUM_UNIONA {
        [case(0)]
            PLLS_USER_PRODUCT_INFO_0_CONTAINERA Level0;
        [case(1)]
            PLLS_USER_PRODUCT_INFO_1_CONTAINERA Level1;
        [default]
            ;
    } LlsUserProductInfo;
} LLS_USER_PRODUCT_ENUM_STRUCTA, *PLLS_USER_PRODUCT_ENUM_STRUCTA;


///////////////////////////////////////////////////////////////////////////////
// Mapping Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_MAPPING_INFO_0W {
   PNAMEW Name;
} LLS_MAPPING_INFO_0W, *PLLS_MAPPING_INFO_0W;

typedef struct _LLS_MAPPING_INFO_1W {
   PNAMEW Name;
   PNAMEW Comment;
   ULONG  Licenses;
} LLS_MAPPING_INFO_1W, *PLLS_MAPPING_INFO_1W;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_MAPPING_INFO_0W MappingInfo0;
   [case(1)]    LLS_MAPPING_INFO_1W MappingInfo1;
} LLS_MAPPING_INFOW, *PLLS_MAPPING_INFOW;

typedef struct _LLS_MAPPING_INFO_0_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_MAPPING_INFO_0W Buffer;
} LLS_MAPPING_INFO_0_CONTAINERW, *PLLS_MAPPING_INFO_0_CONTAINERW;

typedef struct _LLS_MAPPING_INFO_1_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_MAPPING_INFO_1W Buffer;
} LLS_MAPPING_INFO_1_CONTAINERW, *PLLS_MAPPING_INFO_1_CONTAINERW;

typedef struct _LLS_MAPPING_ENUM_STRUCTW {
    DWORD   Level;
    [switch_is(Level)] union _LLS_MAPPING_ENUM_UNIONW {
        [case(0)]
            PLLS_MAPPING_INFO_0_CONTAINERW Level0;
        [case(1)]
            PLLS_MAPPING_INFO_1_CONTAINERW Level1;
        [default]
            ;
    } LlsMappingInfo;
} LLS_MAPPING_ENUM_STRUCTW, *PLLS_MAPPING_ENUM_STRUCTW;


//
// ANSI
//
typedef struct _LLS_MAPPING_INFO_0A {
   PNAMEA Name;
} LLS_MAPPING_INFO_0A, *PLLS_MAPPING_INFO_0A;

typedef struct _LLS_MAPPING_INFO_1A {
   PNAMEA Name;
   PNAMEA Comment;
   ULONG  Licenses;
} LLS_MAPPING_INFO_1A, *PLLS_MAPPING_INFO_1A;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_MAPPING_INFO_0A MappingInfo0;
   [case(1)]    LLS_MAPPING_INFO_1A MappingInfo1;
} LLS_MAPPING_INFOA, *PLLS_MAPPING_INFOA;

typedef struct _LLS_MAPPING_INFO_0_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_MAPPING_INFO_0A Buffer;
} LLS_MAPPING_INFO_0_CONTAINERA, *PLLS_MAPPING_INFO_0_CONTAINERA;

typedef struct _LLS_MAPPING_INFO_1_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_MAPPING_INFO_1A Buffer;
} LLS_MAPPING_INFO_1_CONTAINERA, *PLLS_MAPPING_INFO_1_CONTAINERA;

typedef struct _LLS_MAPPING_ENUM_STRUCTA {
    DWORD   Level;
    [switch_is(Level)] union _LLS_MAPPING_ENUM_UNIONA {
        [case(0)]
            PLLS_MAPPING_INFO_0_CONTAINERA Level0;
        [case(1)]
            PLLS_MAPPING_INFO_1_CONTAINERA Level1;
        [default]
            ;
    } LlsMappingInfo;
} LLS_MAPPING_ENUM_STRUCTA, *PLLS_MAPPING_ENUM_STRUCTA;



///////////////////////////////////////////////////////////////////////////////
// Service Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_SERVICE_INFO_0W {
   DWORD Version;
   DWORD TimeStarted;
   DWORD Mode;
   PNAMEW ReplicateTo;
   PNAMEW EnterpriseServer;
   DWORD ReplicationType;
   DWORD ReplicationTime;
   DWORD UseEnterprise;
   DWORD LastReplicated;
} LLS_SERVICE_INFO_0W, *PLLS_SERVICE_INFO_0W;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_SERVICE_INFO_0W ServiceInfo0;
} LLS_SERVICE_INFOW, *PLLS_SERVICE_INFOW;


//
// ANSI
//
typedef struct _LLS_SERVICE_INFO_0A {
   DWORD Version;
   DWORD TimeStarted;
   DWORD Mode;
   PNAMEA ReplicateTo;
   PNAMEA EnterpriseServer;
   DWORD ReplicationType;
   DWORD ReplicationTime;
   DWORD UseEnterprise;
   DWORD LastReplicated;
} LLS_SERVICE_INFO_0A, *PLLS_SERVICE_INFO_0A;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_SERVICE_INFO_0A ServiceInfo0;
} LLS_SERVICE_INFOA, *PLLS_SERVICE_INFOA;



///////////////////////////////////////////////////////////////////////////////
// Server Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_SERVER_INFO_0W {
   PNAMEW Name;
} LLS_SERVER_INFO_0W, *PLLS_SERVER_INFO_0W;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_SERVER_INFO_0W ServerInfo0;
} LLS_SERVER_INFOW, *PLLS_SERVER_INFOW;

typedef struct _LLS_SERVER_INFO_0_CONTAINERW {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_SERVER_INFO_0W Buffer;
} LLS_SERVER_INFO_0_CONTAINERW, *PLLS_SERVER_INFO_0_CONTAINERW;

typedef struct _LLS_SERVER_ENUM_STRUCTW {
    DWORD   Level;
    [switch_is(Level)] union _LLS_SERVER_ENUM_UNIONW {
        [case(0)]
            PLLS_SERVER_INFO_0_CONTAINERW Level0;
        [default]
            ;
    } LlsServerInfo;
} LLS_SERVER_ENUM_STRUCTW, *PLLS_SERVER_ENUM_STRUCTW;


//
// ANSI
//
typedef struct _LLS_SERVER_INFO_0A {
   PNAMEA Name;
} LLS_SERVER_INFO_0A, *PLLS_SERVER_INFO_0A;

typedef [switch_type(DWORD)] union {
   [case(0)]    LLS_SERVER_INFO_0A ServerInfo0;
} LLS_SERVER_INFOA, *PLLS_SERVER_INFOA;

typedef struct _LLS_SERVER_INFO_0_CONTAINERA {
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_SERVER_INFO_0A Buffer;
} LLS_SERVER_INFO_0_CONTAINERA, *PLLS_SERVER_INFO_0_CONTAINERA;

typedef struct _LLS_SERVER_ENUM_STRUCTA {
    DWORD   Level;
    [switch_is(Level)] union _LLS_SERVER_ENUM_UNIONA {
        [case(0)]
            PLLS_SERVER_INFO_0_CONTAINERA Level0;
        [default]
            ;
    } LlsServerInfo;
} LLS_SERVER_ENUM_STRUCTA, *PLLS_SERVER_ENUM_STRUCTA;


///////////////////////////////////////////////////////////////////////////////
// Replication Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _REPL_REQUEST {
   DWORD Version;
   WCHAR EnterpriseServer[18];
   DWORD EnterpriseServerDate;
   DWORD LastReplicated;
   DWORD CurrentTime;
   ULONG NumberServices;
   ULONG NumberUsers;
   ULONG ReplSize;
   ULONG Backoff;
} REPL_REQUEST, *PREPL_REQUEST;

typedef struct _REPL_SERVER_SERVICE_RECORD {
   ULONG Server;
   DWORD Flags;
   ULONG Service;
   ULONG MaxSessionCount;
   ULONG MaxSetSessionCount;
   ULONG HighMark;
} REPL_SERVER_SERVICE_RECORD, *PREPL_SERVER_SERVICE_RECORD;

typedef struct _REPL_SERVER_RECORD {
   ULONG Index;
   PNAMEW Name;
   ULONG MasterServer;
} REPL_SERVER_RECORD, *PREPL_SERVER_RECORD;

typedef struct _REPL_SERVICE_RECORD {
   ULONG Index;
   PNAMEW Name;
   DWORD Version;
   PNAMEW FamilyName;
} REPL_SERVICE_RECORD, *PREPL_SERVICE_RECORD;

typedef struct _REPL_USER_NAME_RECORD {
   PNAMEW Name;
} REPL_USER_NAME_RECORD, *PREPL_USER_NAME_RECORD;

typedef [unique] PREPL_SERVER_RECORD         REPL_SERVERS;
typedef [unique] PREPL_SERVER_SERVICE_RECORD REPL_SERVER_SERVICES;
typedef [unique] PREPL_SERVICE_RECORD        REPL_SERVICES;


///////////////////////////////////////////////////////////////////////////////
// Certificate Target Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_CERTIFICATE_CLAIM_INFO_0W
{
   WCHAR    ServerName[ 16 ]; // 1 + MAX_COMPUERNAME_LENGTH
   LONG     Quantity;
} LLS_CERTIFICATE_CLAIM_INFO_0W, *PLLS_CERTIFICATE_CLAIM_INFO_0W;

typedef [switch_type(DWORD)] union
{
   [case(0)] LLS_CERTIFICATE_CLAIM_INFO_0W ClaimInfo0;
} LLS_CERTIFICATE_CLAIM_INFO_W, *PLLS_CERTIFICATE_CLAIM_INFO_W;

typedef struct _LLS_CERTIFICATE_CLAIM_INFO_0_CONTAINERW
{
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_CERTIFICATE_CLAIM_INFO_0W Buffer;
} LLS_CERTIFICATE_CLAIM_INFO_0_CONTAINERW, *PLLS_CERTIFICATE_CLAIM_INFO_0_CONTAINERW;

typedef struct _LLS_CERTIFICATE_CLAIM_ENUM_STRUCTW
{
    DWORD   Level;
    [switch_is(Level)] union _LLS_CERTIFICATE_CLAIM_ENUM_UNIONW
    {
        [case(0)]
            PLLS_CERTIFICATE_CLAIM_INFO_0_CONTAINERW Level0;
        [default]
            ;
    } LlsCertificateClaimInfo;
} LLS_CERTIFICATE_CLAIM_ENUM_STRUCTW, *PLLS_CERTIFICATE_CLAIM_ENUM_STRUCTW;

//
// ANSI
//
typedef struct _LLS_CERTIFICATE_CLAIM_INFO_0A
{
   CHAR     ServerName[ 16 ]; // 1 + MAX_COMPUERNAME_LENGTH
   LONG     Quantity;
} LLS_CERTIFICATE_CLAIM_INFO_0A, *PLLS_CERTIFICATE_CLAIM_INFO_0A;

typedef [switch_type(DWORD)] union
{
   [case(0)] LLS_CERTIFICATE_CLAIM_INFO_0A ClaimInfo0;
} LLS_CERTIFICATE_CLAIM_INFO_A, *PLLS_CERTIFICATE_CLAIM_INFO_A;

typedef struct _LLS_CERTIFICATE_CLAIM_INFO_0_CONTAINERA
{
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_CERTIFICATE_CLAIM_INFO_0A Buffer;
} LLS_CERTIFICATE_CLAIM_INFO_0_CONTAINERA, *PLLS_CERTIFICATE_CLAIM_INFO_0_CONTAINERA;

typedef struct _LLS_CERTIFICATE_CLAIM_ENUM_STRUCTA
{
    DWORD   Level;
    [switch_is(Level)] union _LLS_CERTIFICATE_CLAIM_ENUM_UNIONA
    {
        [case(0)]
            PLLS_CERTIFICATE_CLAIM_INFO_0_CONTAINERA Level0;
        [default]
            ;
    } LlsCertificateClaimInfo;
} LLS_CERTIFICATE_CLAIM_ENUM_STRUCTA, *PLLS_CERTIFICATE_CLAIM_ENUM_STRUCTA;


///////////////////////////////////////////////////////////////////////////////
// Certificate Replication Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _REPL_CERT_DB_CERTIFICATE_CLAIM_0
{
   WCHAR  ServerName[ 16 ]; // 1 + MAX_COMPUTERNAME_LENGTH
   DWORD  ReplicationDate;
   LONG   Quantity;
} REPL_CERT_DB_CERTIFICATE_CLAIM_0, *PREPL_CERT_DB_CERTIFICATE_CLAIM_0;

typedef struct _REPL_CERT_DB_CERTIFICATE_CLAIM_CONTAINER_0
{
   DWORD                                                       NumClaims;
   [size_is(NumClaims)] PREPL_CERT_DB_CERTIFICATE_CLAIM_0      Claims;
} REPL_CERT_DB_CERTIFICATE_CLAIM_CONTAINER_0, *PREPL_CERT_DB_CERTIFICATE_CLAIM_CONTAINER_0;

typedef [switch_type(DWORD)] union
{
   [case(0)] REPL_CERT_DB_CERTIFICATE_CLAIM_CONTAINER_0     Level0;
} REPL_CERT_DB_CERTIFICATE_CLAIM_CONTAINER, *PREPL_CERT_DB_CERTIFICATE_CLAIM_CONTAINER;

typedef struct _REPL_CERT_DB_CERTIFICATE_HEADER_0
{
   DWORD                            CertificateID;
   DWORD                            AllowedModes;
   DWORD                            MaxQuantity;
   DWORD                            ExpirationDate;

   DWORD                            NumClaims;
} REPL_CERT_DB_CERTIFICATE_HEADER_0, *PREPL_CERT_DB_CERTIFICATE_HEADER_0;

typedef struct _REPL_CERT_DB_CERTIFICATE_HEADER_CONTAINER_0
{
   DWORD                                                       NumHeaders;
   [size_is(NumHeaders)] PREPL_CERT_DB_CERTIFICATE_HEADER_0    Headers;
} REPL_CERT_DB_CERTIFICATE_HEADER_CONTAINER_0, *PREPL_CERT_DB_CERTIFICATE_HEADER_CONTAINER_0;

typedef [switch_type(DWORD)] union
{
   [case(0)] REPL_CERT_DB_CERTIFICATE_HEADER_CONTAINER_0    Level0;
} REPL_CERT_DB_CERTIFICATE_HEADER_CONTAINER, *PREPL_CERT_DB_CERTIFICATE_HEADER_CONTAINER;

typedef struct _REPL_CERTIFICATE_DB_0
{
   DWORD                                           HeaderLevel;
   [switch_is(HeaderLevel)]
      REPL_CERT_DB_CERTIFICATE_HEADER_CONTAINER    HeaderContainer;

   DWORD                                           ClaimLevel;
   [switch_is(ClaimLevel)]
      REPL_CERT_DB_CERTIFICATE_CLAIM_CONTAINER     ClaimContainer;

   DWORD                                           StringSize;
   [size_is(StringSize)] WCHAR *                   Strings;
} REPL_CERTIFICATE_DB_0, *PREPL_CERTIFICATE_DB_0;

typedef [switch_type(DWORD)] union
{
   [case(0)] REPL_CERTIFICATE_DB_0  Level0;
} REPL_CERTIFICATE_DB, *PREPL_CERTIFICATE_DB;

typedef [unique] PREPL_CERTIFICATE_DB  REPL_CERTIFICATES;


///////////////////////////////////////////////////////////////////////////////
// Product Security Replication Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _REPL_PRODUCT_SECURITY_0
{
   DWORD                            StringSize;
   [size_is(StringSize)] WCHAR *    Strings;
} REPL_PRODUCT_SECURITY_0, *PREPL_PRODUCT_SECURITY_0;

typedef [switch_type(DWORD)] union
{
   [case(0)] REPL_PRODUCT_SECURITY_0  Level0;
} REPL_PRODUCT_SECURITY, *PREPL_PRODUCT_SECURITY;

typedef [unique] PREPL_PRODUCT_SECURITY  REPL_SECURE_PRODUCTS;


///////////////////////////////////////////////////////////////////////////////
// User Replication Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _REPL_USER_RECORD_0
{
   PNAMEW   Name;
   ULONG    Service;
   ULONG    AccessCount;
   DWORD    LastAccess;
} REPL_USER_RECORD_0, *PREPL_USER_RECORD_0;

typedef struct _REPL_USER_RECORD_CONTAINER_0
{
   DWORD                                     NumUsers;
   [size_is(NumUsers)] PREPL_USER_RECORD_0   Users;
} REPL_USER_RECORD_CONTAINER_0, *PREPL_USER_RECORD_CONTAINER_0;

typedef struct _REPL_USER_RECORD_1
{
   PNAMEW   Name;
   ULONG    Service;
   ULONG    AccessCount;
   DWORD    LastAccess;
   DWORD    Flags;
} REPL_USER_RECORD_1, *PREPL_USER_RECORD_1;

typedef struct _REPL_USER_RECORD_CONTAINER_1
{
   DWORD                                     NumUsers;
   [size_is(NumUsers)] PREPL_USER_RECORD_1   Users;
} REPL_USER_RECORD_CONTAINER_1, *PREPL_USER_RECORD_CONTAINER_1;

typedef [switch_type(DWORD)] union
{
   [case(0)] REPL_USER_RECORD_CONTAINER_0  Level0;
   [case(1)] REPL_USER_RECORD_CONTAINER_1  Level1;
} REPL_USER_RECORD_CONTAINER, *PREPL_USER_RECORD_CONTAINER;

typedef [switch_type(DWORD)] union
{
   [case(0)] PREPL_USER_RECORD_0  Level0;
   [case(1)] PREPL_USER_RECORD_1  Level1;
} PREPL_USER_RECORD;

typedef [unique] PREPL_USER_RECORD_CONTAINER    REPL_USERS;
typedef [unique] PREPL_USER_RECORD_0            REPL_USERS_0;


///////////////////////////////////////////////////////////////////////////////
// Local Service Info
///////////////////////////////////////////////////////////////////////////////
//
// Unicode
//
typedef struct _LLS_LOCAL_SERVICE_INFO_0W
{
   PNAMEW   KeyName;
   PNAMEW   DisplayName;
   PNAMEW   FamilyDisplayName;
   DWORD    Mode;
   DWORD    FlipAllow;
   DWORD    ConcurrentLimit;
   DWORD    HighMark;
} LLS_LOCAL_SERVICE_INFO_0W, *PLLS_LOCAL_SERVICE_INFO_0W;

typedef [switch_type(DWORD)] union
{
   [case(0)] LLS_LOCAL_SERVICE_INFO_0W LocalServiceInfo0;
} LLS_LOCAL_SERVICE_INFOW, *PLLS_LOCAL_SERVICE_INFOW;

typedef struct _LLS_LOCAL_SERVICE_INFO_0_CONTAINERW
{
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_LOCAL_SERVICE_INFO_0W Buffer;
} LLS_LOCAL_SERVICE_INFO_0_CONTAINERW, *PLLS_LOCAL_SERVICE_INFO_0_CONTAINERW;

typedef struct _LLS_LOCAL_SERVICE_ENUM_STRUCTW
{
    DWORD   Level;
    [switch_is(Level)] union _LLS_LOCAL_SERVICE_ENUM_UNIONW
    {
        [case(0)]
            PLLS_LOCAL_SERVICE_INFO_0_CONTAINERW Level0;
        [default]
            ;
    } LlsLocalServiceInfo;
} LLS_LOCAL_SERVICE_ENUM_STRUCTW, *PLLS_LOCAL_SERVICE_ENUM_STRUCTW;

//
// ANSI
//
typedef struct _LLS_LOCAL_SERVICE_INFO_0A
{
   PNAMEA   KeyName;
   PNAMEA   DisplayName;
   PNAMEA   FamilyDisplayName;
   DWORD    Mode;
   DWORD    FlipAllow;
   DWORD    ConcurrentLimit;
   DWORD    HighMark;
} LLS_LOCAL_SERVICE_INFO_0A, *PLLS_LOCAL_SERVICE_INFO_0A;

typedef [switch_type(DWORD)] union
{
   [case(0)] LLS_LOCAL_SERVICE_INFO_0A LocalServiceInfo0;
} LLS_LOCAL_SERVICE_INFOA, *PLLS_LOCAL_SERVICE_INFOA;

typedef struct _LLS_LOCAL_SERVICE_INFO_0_CONTAINERA
{
   DWORD    EntriesRead;
   [size_is(EntriesRead)] PLLS_LOCAL_SERVICE_INFO_0A Buffer;
} LLS_LOCAL_SERVICE_INFO_0_CONTAINERA, *PLLS_LOCAL_SERVICE_INFO_0_CONTAINERA;

typedef struct _LLS_LOCAL_SERVICE_ENUM_STRUCTA
{
    DWORD   Level;
    [switch_is(Level)] union _LLS_LOCAL_SERVICE_ENUM_UNIONA
    {
        [case(0)]
            PLLS_LOCAL_SERVICE_INFO_0_CONTAINERA Level0;
        [default]
            ;
    } LlsLocalServiceInfo;
} LLS_LOCAL_SERVICE_ENUM_STRUCTA, *PLLS_LOCAL_SERVICE_ENUM_STRUCTA;


///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////
//
// Connect / Disconnect API's
//
NTSTATUS
LlsrConnect(
   [out] PLLS_HANDLE Handle,
   [in, string] LPWSTR Name
   );

NTSTATUS
LlsrClose(
   [in] LLS_HANDLE Handle
   );

///////////////////////////////////////////////////////////////////////////////
//
// License control API's
//
NTSTATUS
LlsrLicenseEnumW(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_LICENSE_ENUM_STRUCTW LicenseInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrLicenseEnumA(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_LICENSE_ENUM_STRUCTA LicenseInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

// Add purchase of license for a product.
NTSTATUS
LlsrLicenseAddW(
   [in] LLS_HANDLE Handle,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_LICENSE_INFOW BufPtr
   );

NTSTATUS
LlsrLicenseAddA(
   [in] LLS_HANDLE Handle,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_LICENSE_INFOA BufPtr
   );

///////////////////////////////////////////////////////////////////////////////
//
// Product control API's
//
NTSTATUS
LlsrProductEnumW(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_PRODUCT_ENUM_STRUCTW ProductInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrProductEnumA(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_PRODUCT_ENUM_STRUCTA ProductInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrProductAddW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR ProductFamily,
   [in, string] LPWSTR Product,
   [in, string] LPWSTR Version
   );

NTSTATUS
LlsrProductAddA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR ProductFamily,
   [in, string] LPSTR Product,
   [in, string] LPSTR Version
   );

NTSTATUS
LlsrProductUserEnumW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Product,
   [in, out] PLLS_PRODUCT_USER_ENUM_STRUCTW ProductUserInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrProductUserEnumA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Product,
   [in, out] PLLS_PRODUCT_USER_ENUM_STRUCTA ProductUserInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrProductServerEnumW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Product,
   [in, out] PLLS_SERVER_PRODUCT_ENUM_STRUCTW ProductServerInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrProductServerEnumA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Product,
   [in, out] PLLS_SERVER_PRODUCT_ENUM_STRUCTA ProductServerInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );


NTSTATUS
LlsrProductLicenseEnumW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Product,
   [in, out] PLLS_PRODUCT_LICENSE_ENUM_STRUCTW ProductLicenseInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrProductLicenseEnumA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Product,
   [in, out] PLLS_PRODUCT_LICENSE_ENUM_STRUCTA ProductLicenseInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

///////////////////////////////////////////////////////////////////////////////
//
//  User control API's
//
NTSTATUS
LlsrUserEnumW(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_USER_ENUM_STRUCTW UserInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrUserEnumA(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_USER_ENUM_STRUCTA UserInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrUserInfoGetW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR User,
   [in] DWORD Level,
   [out, switch_is(Level)] PLLS_USER_INFOW *BufPtr
   );

NTSTATUS
LlsrUserInfoGetA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR User,
   [in] DWORD Level,
   [out, switch_is(Level)] PLLS_USER_INFOA *BufPtr
   );

NTSTATUS
LlsrUserInfoSetW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR User,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_USER_INFOW BufPtr
   );

NTSTATUS
LlsrUserInfoSetA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR User,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_USER_INFOA BufPtr
   );

NTSTATUS
LlsrUserDeleteW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR User
   );

NTSTATUS
LlsrUserDeleteA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR User
   );

NTSTATUS
LlsrUserProductEnumW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR User,
   [in, out] PLLS_USER_PRODUCT_ENUM_STRUCTW UserProductInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrUserProductEnumA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR User,
   [in, out] PLLS_USER_PRODUCT_ENUM_STRUCTA UserProductInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrUserProductDeleteW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR User,
   [in, string] LPWSTR Product
   );

NTSTATUS
LlsrUserProductDeleteA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR User,
   [in] LPSTR Product
   );

///////////////////////////////////////////////////////////////////////////////
//
// Mapping control API's
//
NTSTATUS
LlsrMappingEnumW(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_MAPPING_ENUM_STRUCTW MappingInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrMappingEnumA(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_MAPPING_ENUM_STRUCTA MappingInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrMappingInfoGetW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Mapping,
   [in] DWORD Level,
   [out, switch_is(Level)] PLLS_MAPPING_INFOW *BufPtr
   );

NTSTATUS
LlsrMappingInfoGetA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Mapping,
   [in] DWORD Level,
   [out, switch_is(Level)] PLLS_MAPPING_INFOA *BufPtr
   );

NTSTATUS
LlsrMappingInfoSetW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Mapping,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_MAPPING_INFOW BufPtr
   );

NTSTATUS
LlsrMappingInfoSetA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Mapping,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_MAPPING_INFOA BufPtr
   );

NTSTATUS
LlsrMappingUserEnumW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Mapping,
   [in, out] PLLS_USER_ENUM_STRUCTW MappingUserInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrMappingUserEnumA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Mapping,
   [in, out] PLLS_USER_ENUM_STRUCTA MappingUserInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrMappingUserAddW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Mapping,
   [in, string] LPWSTR User
   );

NTSTATUS
LlsrMappingUserAddA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Mapping,
   [in, string] LPSTR User
   );

NTSTATUS
LlsrMappingUserDeleteW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Mapping,
   [in, string] LPWSTR User
   );

NTSTATUS
LlsrMappingUserDeleteA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Mapping,
   [in, string] LPSTR User
   );

NTSTATUS
LlsrMappingAddW(
   [in] LLS_HANDLE Handle,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_MAPPING_INFOW BufPtr
   );

NTSTATUS
LlsrMappingAddA(
   [in] LLS_HANDLE Handle,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_MAPPING_INFOA BufPtr
   );

NTSTATUS
LlsrMappingDeleteW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Mapping
   );

NTSTATUS
LlsrMappingDeleteA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Mapping
   );

///////////////////////////////////////////////////////////////////////////////
//
// Server Product API's
//
NTSTATUS
LlsrServerEnumW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Server,
   [in, out] PLLS_SERVER_ENUM_STRUCTW ServerInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrServerEnumA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Server,
   [in, out] PLLS_SERVER_ENUM_STRUCTA ServerInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrServerProductEnumW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Server,
   [in, out] PLLS_SERVER_PRODUCT_ENUM_STRUCTW ServerProductInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrServerProductEnumA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Server,
   [in, out] PLLS_SERVER_PRODUCT_ENUM_STRUCTA ServerProductInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

///////////////////////////////////////////////////////////////////////////////
//
// Registry Wrapper API's
//
NTSTATUS
LlsrLocalProductEnumW(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_SERVER_PRODUCT_ENUM_STRUCTW ServerProductInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrLocalProductEnumA(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_SERVER_PRODUCT_ENUM_STRUCTA ServerProductInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrLocalProductInfoGetW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Product,
   [in] DWORD Level,
   [out, switch_is(Level)] PLLS_SERVER_PRODUCT_INFOW *BufPtr
   );

NTSTATUS
LlsrLocalProductInfoGetA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Product,
   [in] DWORD Level,
   [out, switch_is(Level)] PLLS_SERVER_PRODUCT_INFOA *BufPtr
   );

NTSTATUS
LlsrLocalProductInfoSetW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Product,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_SERVER_PRODUCT_INFOW BufPtr
   );

NTSTATUS
LlsrLocalProductInfoSetA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Product,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_SERVER_PRODUCT_INFOA BufPtr
   );


///////////////////////////////////////////////////////////////////////////////
//
// Service control API's
//
NTSTATUS
LlsrServiceInfoGetW(
   [in]  LLS_HANDLE Handle,
   [in]  DWORD      Level,
   [out, switch_is(Level)] PLLS_SERVICE_INFOW *BufPtr
   );

NTSTATUS
LlsrServiceInfoGetA(
   [in]  LLS_HANDLE Handle,
   [in]  DWORD      Level,
   [out, switch_is(Level)] PLLS_SERVICE_INFOA *BufPtr
   );

NTSTATUS
LlsrServiceInfoSetW(
   [in] LLS_HANDLE Handle,
   [in] DWORD      Level,
   [in, switch_is(Level)] PLLS_SERVICE_INFOW BufPtr
   );

NTSTATUS
LlsrServiceInfoSetA(
   [in] LLS_HANDLE Handle,
   [in] DWORD      Level,
   [in, switch_is(Level)] PLLS_SERVICE_INFOA BufPtr
   );

///////////////////////////////////////////////////////////////////////////////
//
// Replication API's
//
NTSTATUS
LlsrReplConnect(
   [out] PLLS_REPL_HANDLE Handle,
   [in, string] LPWSTR Name
   );

NTSTATUS
LlsrReplClose(
   [in, out] LLS_REPL_HANDLE *Handle
   );

NTSTATUS
LlsrReplicationRequestW(
   [in] LLS_REPL_HANDLE Handle,
   [in] DWORD Version,
   [in, out] PREPL_REQUEST Request
   );

NTSTATUS
LlsrReplicationServerAddW(
   [in] LLS_REPL_HANDLE Handle,
   [in, range(0, 1024*1024)] ULONG NumRecords,
   [in, size_is(NumRecords)] REPL_SERVERS Servers
   );

NTSTATUS
LlsrReplicationServerServiceAddW(
   [in] LLS_REPL_HANDLE Handle,
   [in, range(0, 1024*1024)] ULONG NumRecords,
   [in, size_is(NumRecords)] REPL_SERVER_SERVICES ServerServices
   );

NTSTATUS
LlsrReplicationServiceAddW(
   [in] LLS_REPL_HANDLE Handle,
   [in, range(0, 1024)] ULONG NumRecords,
   [in, size_is(NumRecords)] REPL_SERVICES Services
   );

NTSTATUS
LlsrReplicationUserAddW(
   [in] LLS_REPL_HANDLE Handle,
   [in, range(0, 10*1024*1024)] ULONG NumRecords,
   [in, size_is(NumRecords)] REPL_USERS_0 Users
   );

///////////////////////////////////////////////////////////////////////////////
//
// LLS Extended API's (added for SUR)
//
NTSTATUS
LlsrProductSecurityGetW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Product,
   [out] LPBOOL pIsSecure
   );

NTSTATUS
LlsrProductSecurityGetA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Product,
   [out] LPBOOL pIsSecure
   );

NTSTATUS
LlsrProductSecuritySetW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR Product
   );

NTSTATUS
LlsrProductSecuritySetA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR Product
   );

NTSTATUS
LlsrProductLicensesGetA(
   [in] LLS_HANDLE         Handle,
   [in,string] LPSTR       DisplayName,
   [in] DWORD              Mode,
   [out] LPDWORD           pQuantity );

NTSTATUS
LlsrProductLicensesGetW(
   [in] LLS_HANDLE         Handle,
   [in, string] LPWSTR     DisplayName,
   [in] DWORD              Mode,
   [out] LPDWORD           pQuantity );

NTSTATUS
LlsrCertificateClaimEnumA(
   [in] LLS_HANDLE        Handle,
   [in] DWORD             LicenseLevel,
   [in, switch_is(LicenseLevel)] PLLS_LICENSE_INFOA LicensePtr,
   [in,out] PLLS_CERTIFICATE_CLAIM_ENUM_STRUCTA ClaimInfo );

NTSTATUS
LlsrCertificateClaimEnumW(
   [in] LLS_HANDLE        Handle,
   [in] DWORD             LicenseLevel,
   [in, switch_is(LicenseLevel)] PLLS_LICENSE_INFOW LicensePtr,
   [in,out] PLLS_CERTIFICATE_CLAIM_ENUM_STRUCTW ClaimInfo );

NTSTATUS
LlsrCertificateClaimAddCheckA(
   [in] LLS_HANDLE        Handle,
   [in] DWORD             Level,
   [in, switch_is(Level)] PLLS_LICENSE_INFOA LicensePtr,
   [out] LPBOOL           pbMayInstall );

NTSTATUS
LlsrCertificateClaimAddCheckW(
   [in] LLS_HANDLE        Handle,
   [in] DWORD             Level,
   [in, switch_is(Level)] PLLS_LICENSE_INFOW LicensePtr,
   [out] LPBOOL           pbMayInstall );

NTSTATUS
LlsrCertificateClaimAddA(
   [in] LLS_HANDLE        Handle,
   [in, string] LPSTR     ServerName,
   [in] DWORD             Level,
   [in, switch_is(Level)] PLLS_LICENSE_INFOA LicensePtr );

NTSTATUS
LlsrCertificateClaimAddW(
   [in] LLS_HANDLE        Handle,
   [in, string] LPWSTR    ServerName,
   [in] DWORD             Level,
   [in, switch_is(Level)] PLLS_LICENSE_INFOW LicensePtr );

NTSTATUS
LlsrReplicationCertDbAddW(
   [in] LLS_REPL_HANDLE             Handle,
   [in] DWORD                       Level,
   [in, switch_is(Level)] REPL_CERTIFICATES Certificates );

NTSTATUS
LlsrReplicationProductSecurityAddW(
   [in] LLS_REPL_HANDLE             Handle,
   [in] DWORD                       Level,
   [in, switch_is(Level)] REPL_SECURE_PRODUCTS SecureProducts );

NTSTATUS
LlsrReplicationUserAddExW(
   [in] LLS_REPL_HANDLE             Handle,
   [in] DWORD                       Level,
   [in, switch_is(Level)] REPL_USERS Users );

NTSTATUS
LlsrCapabilityGet(
   [in] LLS_HANDLE                        Handle,
   [in, range(0, 1024)] DWORD             cbCapabilities,
   [out, size_is(cbCapabilities)] LPBYTE  pbCapabilities );

NTSTATUS
LlsrLocalServiceEnumW(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_LOCAL_SERVICE_ENUM_STRUCTW LocalServiceInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrLocalServiceEnumA(
   [in] LLS_HANDLE Handle,
   [in, out] PLLS_LOCAL_SERVICE_ENUM_STRUCTA LocalServiceInfo,
   [in] DWORD PrefMaxLen,
   [out] LPDWORD TotalEntries,
   [in, out, unique] LPDWORD ResumeHandle
   );

NTSTATUS
LlsrLocalServiceAddW(
   [in] LLS_HANDLE                 Handle,
   [in] DWORD                      Level,
   [in, switch_is(Level)] PLLS_LOCAL_SERVICE_INFOW LocalServiceInfo
   );

NTSTATUS
LlsrLocalServiceAddA(
   [in] LLS_HANDLE                 Handle,
   [in] DWORD                      Level,
   [in, switch_is(Level)] PLLS_LOCAL_SERVICE_INFOA LocalServiceInfo
   );

NTSTATUS
LlsrLocalServiceInfoSetW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR KeyName,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_LOCAL_SERVICE_INFOW LocalServiceInfo
   );

NTSTATUS
LlsrLocalServiceInfoSetA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR KeyName,
   [in] DWORD Level,
   [in, switch_is(Level)] PLLS_LOCAL_SERVICE_INFOA LocalServiceInfo
   );

NTSTATUS
LlsrLocalServiceInfoGetW(
   [in] LLS_HANDLE Handle,
   [in, string] LPWSTR KeyName,
   [in] DWORD Level,
   [out, switch_is(Level)] PLLS_LOCAL_SERVICE_INFOW * LocalServiceInfo
   );

NTSTATUS
LlsrLocalServiceInfoGetA(
   [in] LLS_HANDLE Handle,
   [in, string] LPSTR KeyName,
   [in] DWORD Level,
   [out, switch_is(Level)] PLLS_LOCAL_SERVICE_INFOA * LocalServiceInfo
   );                                                               

//
// New : the handle should've been in,out originally.
//

NTSTATUS
LlsrCloseEx(
   [in, out] LLS_HANDLE * pHandle
   );
}